Add files using upload-large-folder tool

parse/train/HyGySsAct7/HyGySsAct7.md

@@ -0,0 +1,175 @@
+# TARGETED ADVERSARIAL EXAMPLES FOR BLACK BOX AUDIO SYSTEMS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+The application of deep recurrent networks to audio transcription has led to impressive gains in automatic speech recognition (ASR) systems. Many have demonstrated that small adversarial perturbations can fool deep neural networks into incorrectly predicting a specified target with high confidence. Current work on fooling ASR systems have focused on white-box attacks, in which the model architecture and parameters are known. In this paper, we adopt a black-box approach to adversarial generation, combining the approaches of both genetic algorithms and gradient estimation to solve the task. We achieve a $8 9 . 2 5 \%$ targeted attack similarity after 3000 generations while maintaining $9 4 . 6 \%$ audio file similarity.
+
+# 1 INTRODUCTION
+
+Although neural networks have incredible expressive capacity, which allow them to be well suited for a variety of machine learning tasks, they have been shown to be vulnerable to adversarial attacks over multiple network architectures and datasets Goodfellow et al. (2014). These attacks can be done by adding small perturbations to the original input so that the network misclassifies the input but a human does not notice the difference.
+
+So far, there has been much more work done in generating adversarial examples for image inputs than for other domains, such as audio. Voice control systems are widely used in many products from personal assistants, like Amazon Alexa and Apple Siri, to voice command technologies in cars. One main challenge for such systems is determining exactly what the user is saying and correctly interpreting the statement. As deep learning helps these systems better understand the user, one potential issue is targeted adversarial attacks on the system, which perturb the waveform of what the user says to the system to cause the system to behave in a predetermined inappropriate way. For example, a seemingly benign TV advertisement could be adversely perturbed to cause Alexa to interpret the audio as “Alexa, buy 100 headphones.” If the original user went back to listen to the audio clip that prompted the order, the noise would be almost undetectable to the human ear.
+
+There are multiple different methods of performing adversarial attacks depending on what information the attacker has about the network. If given access to the parameters of a network, white box attacks are most successful, such as the Fast Gradient Sign Method Goodfellow et al. (2014) or DeepFool Moosavi-Dezfooli et al. (2015). However, assuming an attacker has access to all the parameters of a network is unrealistic in practice. In a black box setting, when an attacker only has access to the logits or outputs of a network, it is much harder to consistently create successful adversarial attacks.
+
+In certain special black box settings, white box attack methods can be reused if an attacker creates a model that approximates the original targeted model. However, even though attacks can transfer across networks for some domains, this requires more knowledge of how to solve the task that the original model is solving than an attacker may have Liu et al. (2016); Papernot et al. (2016). Instead, we propose a novel combination of genetic algorithms and gradient estimation to solve this task. The first phase of the attack is carried out by genetic algorithms, which are a gradient-free method of optimization that iterate over populations of candidates until a suitable sample is produced. In order to limit excess mutations and thus excess noise, we improve the standard genetic algorithm with a new momentum mutation update. The second phase of the attack utilizes gradient estimation, where the gradients of individual audio points are estimated, thus allowing for more careful noise placement when the adversarial example is nearing its target. The combination of these two approaches provides a $8 9 . 2 5 \%$ average targeted attack similarity with a $9 4 . 6 \%$ audio file similarity after 3000 generations.
+
+![](images/702a79e13def8c6dba6e31287f0a41fee5a20c11dbb53617509b9193ada57cd8.jpg)  
+Figure 1: Example of targeted adversarial attack on speech to text systems in practice
+
+# 1.1 PROBLEM STATEMENT
+
+Adversarial attacks can be created given a variety of information about the neural network, such as the loss function or the output probabilities. However in a natural setting, usually the neural network behind such a voice control system will not be publicly released so an adversary will only have access to an API which provides the text the system interprets given a continuous waveform. Given this constraint, we use the open sourced Mozilla DeepSpeech implementation as a black box system, without using any information on how the transcription is done.
+
+We perform our black box targeted attack on a model $M$ given a benign input $x$ and a target $t$ by perturbing $x$ to form the adversarial input $x ^ { \prime } = x + \delta$ , such that $M ( x ^ { \prime } ) = t$ . To minimize the audible noise added to the input, so a human cannot notice the target, we maximize the cross correlation between $x$ and $x ^ { \prime }$ . A sufficient value of $\delta$ is determined using our novel black box approach, so we do not need access to the gradients of $M$ to perform the attack.
+
+# 1.2 PRIOR WORK
+
+Compared to images, audio presents a much more significant challenge for models to deal with. While convolutional networks can operate directly on the pixel values of images, ASR systems typically require heavy pre-processing of the input audio. Most commonly, the Mel-Frequency Cepstrum (MFC) transform, essentially a fourier transform of the sampled audio file, is used to convert the input audio into a spectogram which shows frequencies over time. Models such as DeepSpeech (Fig. 2) use this spectogram as the initial input.
+
+In a foundational study for adversarial attacks, Cisse et al. (2017) developed a general attack framework to work across a wide variety of models including images and audio. When applying their method to audio samples, they ran into the roadblock of backpropagating through the MFC conversion layer. Thus, they were able to produce adversarial spectograms but not adversarial .wav files.
+
+Carlini & Wagner (2018) overcame this challenge by developing a method of passing gradients through the MFC layer, a task which was previously proved to be difficult Cisse et al. (2017). They applied their method to the Mozilla DeepSpeech model, which is a complex, recurrent, character-level network that can decode translations at up to 50 characters per second. With a gradient connection all the way to the raw input, they were able to achieve impressive results, including generating samples over $9 9 . 9 \%$ similar with a targeted attack accuracy of $100 \%$ . While the success of this attack opens new doors for white box attacks, adversaries in a real-life setting commonly do not have knowledge of model architectures or parameters.
+
+Alzantot et al. (2018) have demonstrated that black-box approaches for targeted attacks on ASR systems are possible. Using a genetic algorithm approach, they were able to iteratively apply noise to audio samples, pruning away poor performers at each generation, and ultimately end up with a perturbed version of the input that successfully fooled a classification system. This attack was conducted on the Speech Commands classification model Alzantot et al. (2018), which is a lightweight convolutional model for classifying up to 50 different single-word phrases.
+
+Extending the research done by Alzantot et al. (2018), we propose a genetic algorithm and gradient estimation approach to create targeted adversarial audio, but on the more complex DeepSpeech system. The difficulty of this task comes in attempting to apply black-box optimization to a deeplylayered, highly nonlinear decoder model that has the ability to decode phrases of arbitrary length. Nevertheless, the combination of two differing approaches as well as the momentum mutation update bring new success to this task.
+
+![](images/73371a04dc01d589dedd50963db02395c3c1c2164f92a9725fef55d67d3744ff.jpg)  
+Figure 2: Diagram of Baidu’s DeepSpeech model Hannun et al. (2014)
+
+# 1.3 BACKGROUND
+
+Dataset For the attack, we follow Carlini & Wagner (2018) and take the first 100 audio samples from the CommonVoice test set. For each, we randomly generate a 2-word target phrase and apply our black-box approach to construct an adversarial example. More details on evaluation can be found in section 3. Each sample in the dataset is a .wav file, which can easily be deserialized into a numpy array. Our algorithm operates directly on the numpy arrays, thus bypassing the difficulty of dealing with the MFC conversion.
+
+Victim model The model we attack is Baidu’s DeepSpeech model Hannun et al. (2014), implemented in Tensorflow and open-sourced by Mozilla.1 Though we have access to the full model, we treat it as if in a black box setting and only access the output logits of the model. In line with other speech to text systems Chiu et al. (2017); Cisse et al. (2017), DeepSpeech accepts a spectrogram of the audio file. After performing the MFC conversion, the model consists 3 layers of convolutions, followed by a bi-directional LSTM, followed by a fully connected layer. This layer is then fed into the decoder RNN, which outputs logits over the distribution of output characters, up to 50 characters per second of audio. The model is illustrated in figure 2.
+
+Connectionist temporal classication While the DeepSpeech model is designed to allow arbitrary length translations, there is no given labeled alignment of the output and input sequences during training time. Thus the connectionist temporal classication loss (CTC Loss) is introduced, as it allows computing a loss even when the position of a decoded word in the original audio is unknown Carlini & Wagner (2018).
+
+DeepSpeech outputs a probability distribution over all characters at every frame, for 50 frames per second of audio. In addition to outputting the normal alphabet a-z and space, it can output special character $\epsilon$ . Then CTC decoder $C ( \cdot )$ decodes the logits as such: for every frame, take the character with the max logit. Then first, remove all adjacent duplicate characters, and then second, remove any special $\epsilon$ characters. Thus aabb will decode to abb Carlini & Wagner (2018).
+
+As we can see, multiple outputs can decode to the same phrase. Following the notation in Carlini & Wagner (2018), for any target phrase $p$ , we call $\pi$ an alignment of $p$ if $C ( \pi ) = p$ . Let us also call the output distribution of our model $y$ . Now, in order to find the likelihood of alignment $\pi$ under $y$ :
+
+$$
+P r ( p | y ) = \sum _ { \pi | C ( \pi ) = p } P r ( \pi | y ) = \sum _ { \pi | C ( \pi ) = p } \prod _ { i } y _ { \pi } ^ { i }
+$$
+
+as noted by Carlini & Wagner (2018). This is the objective we use when scoring samples from the populations in each generation of our genetic algorithm as well as the score used in estimating gradients.
+
+Greedy decoding As in traditional recurrent decoder systems, DeepSpeech typically uses a beam search of beam width 500. At each frame of decoding, 500 of the most likely $\pi$ will be evaluated, each producing another 500 candidates for a total of 2500, which are pruned back down to 500 for the next timestep. Evaluating multiple assignments this way increases the robustness of the model decoding. However, following work in Carlini & Wagner (2018), we set the model to use greedy decoding. At each timestep only $1 \pi$ is evaluated, leading to a greedy assignment:
+
+$$
+d e c o d e ( x ) = C ( \arg \operatorname* { m a x } _ { \pi } P r ( { y } ( { x } ) | \pi ) )
+$$
+
+Thus, our genetic algorithm will focus on creating perturbations to the most likely sequence (if greedily approximated).
+
+# 2 BLACK BOX ATTACK ALGORITHM
+
+<table><tr><td>Algorithm1 Black box algorithm for generating adversarial audio sample</td></tr><tr><td>Input: Original benign input x Target phrase t Output: Adversarial Audio Sample x&#x27; population ← [x] * populationSize while iter&lt;maxIters and Decode(best)!= t do scores ← -CTCLoss(population,t) best ← population[Argmax(scores)]</td></tr><tr><td>if EditDistance(t,Decode(best)) &gt;2 then / phase 1 - do genetic algorithm while populationSize children have not been made do</td></tr><tr><td>Select parent1 from topk(population) according to softmax(their score) Select parent2 from topk(population) according to softmax(their score) child ← Mutate(Crossover(parent1,parent2), p)</td></tr><tr><td>end while newScores ← -CTCLoss(newPopulation,t)</td></tr><tr><td>p ← MomentumUpdate(p,newScores, scores) else</td></tr><tr><td>/ phase 2 - do gradient estimation top-element ← top(population) grad-pop ← n copies of top-element, each mutated slightly at one index grad ←(-CTCLoss(grad-pop)- scores)/mutation-delta pop ← top-element + grad</td></tr></table>
+
+# 2.1 GENETIC ALGORITHM
+
+As mentioned previously, Alzantot et al. (2018) demonstrated the success of a black-box adversarial attack on speech-to-text systems using a standard genetic algorithm. The basic premise of our algorithm is that it takes in the benign audio sample and, through trial and error, adds noise to the sample such that the perturbed adversarial audio is similar to the benign input yet is decoded as the target, as shown in Figure 3. A genetic algorithm works well for a problem of this nature because it is completely independent of the gradients of the model. Alzantot et al. (2018) used a limited dataset consisting of audio samples with just one word and a classification with a predefined number of classes. In order to extend this algorithm to work with phrases and sentences, as well as with CTC Loss, we make modifications to the genetic algorithm and introduce our novel momentum mutation.
+
+The genetic algorithm works by improving on each iteration, or generation, through evolutionary methods such as Crossover and Mutation Holland (1992). For each iteration, we compute the score for each sample in the population to determine which samples are the best. Our scoring function was the CTC-Loss, which as mentioned previously, is used to determine the similarity between an input audio sequence and a given phrase. We then form our elite population by selecting the best scoring samples from our population. The elite population contains samples with desirable traits that we want to carry over into future generations. We then select parents from the elite population and perform Crossover, which creates a child by taking around half of the elements from parent1 and the other half from parent2. The probability that we select a sample as a parent is a function of the sample’s score. With some probability, we then add a mutation to our new child. Finally, we update our mutation probabilities according to our momentum update, and move to the next iteration. The population will continue to improve over time as only the best traits of the previous generations as well as the best mutations will remain. Eventually, either the algorithm will reach the max number of iterations, or one of the samples is exactly decoded as the target, and the best sample is returned.
+
+![](images/2059e59de774fa523712cc2081fa1bf0391f4f59372c42dbbd7ed4e23abdcb3b.jpg)  
+Figure 3: Diagram of our genetic algorithm
+
+![](images/d14bf5a129c3fd17d74d1e72d9ac3af24b1909a1d0705d938ec3ea5122f0bcd8.jpg)  
+Figure 4: Overlapping of adversarial (blue) and original (orange) audio sample waveforms. The perturbation is barely noticeable
+
+# 2.2 MOMENTUM MUTATION
+
+<table><tr><td>Algorithm 2 Mutation</td></tr><tr><td>Input: Audio Sample x</td></tr><tr><td>Mutation Probability p</td></tr><tr><td>Output: Mutated Audio Sample x&#x27;</td></tr><tr><td></td></tr><tr><td>for all e in x do</td></tr><tr><td>noise ← Sample(N(μ,σ²)) if Sample(Unif(O,1))&lt;p then</td></tr><tr><td>e&#x27; ←e+ filterhighpass(noise)</td></tr><tr><td>end if</td></tr><tr><td>end for</td></tr><tr><td>return x</td></tr></table>
+
+The mutation step is arguably the most crucial component of the genetic algorithm and is our only source of noise in the algorithm. In the mutation step, with some probability, we randomly add noise to our sample. Random mutations are critical because it may cause a trait to appear that is beneficial for the population, which can then be proliferated through crossover. Without mutation, very similar samples will start to appear across generations; thus, the way out of this local maximum is to nudge it in a different direction in order to reach higher scores.
+
+Furthermore, since this noise is perceived as background noise, we apply a filter to the noise before adding it onto the audio sample. The audio is sampled at a rate of $f _ { s } = 1 6 k H z$ , which means that the maximum frequency response $f _ { m a x } = 8 k H z$ . As seen by Reichenbach & Hudspeth (2012), given that the human ear is more sensitive to lower frequencies than higher ones, we apply a highpass filter at a cutoff frequency of $f _ { c u t o f f } = 7 k H z$ . This limits the noise to only being in the high-frequency range, which is less audible and thus less detectable by the human ear.
+
+While mutation helps the algorithm overcome local maxima, the effect of mutation is limited by the mutation probability. Much like the step size in SGD, a low mutation probability may not provide enough randomness to get past a local maximum. If mutations are rare, they are very unlikely to occur in sequence and add on to each other. Therefore, while a mutation might be beneficial when accumulated with other mutations, due to the low mutation probability, it is deemed as not beneficial by the algorithm in the short term, and will disappear within a few iterations. This parallels the step size in SGD, because a small step size will eventually converge back at the local minimum/maximum. However, too large of a mutation probability, or step size, will add an excess of variability and prevent the algorithm from finding the global maximum/minimum. To combat these issues, we propose Momentum Mutation, which is inspired by the Momentum Update for Gradient Descent. With this update, our mutation probability changes in each iteration according to the following exponentially weighted moving average update:
+
+$$
+p _ { n e w } = \alpha \times p _ { o l d } + \frac { \beta } { | c u r r S c o r e - p r e v S c o r e | }
+$$
+
+With this update equation, the probability of a mutation increases as our population fails to adapt meaning the current score is close to the previous score. The momentum update adds acceleration to the mutation probability, allowing mutations to accumulate and add onto each other by keeping the mutation probability high when the algorithm is stuck at a local maximum. By using a moving average, the mutation probability becomes a smooth function and is less susceptible to outliers in the population. While the momentum update may overshoot the target phrase by adding random noise, overall it converges faster than a constant mutation probability by allowing for more acceleration in the right directions.
+
+# Algorithm 3 Momentum Mutation Update
+
+<table><tr><td>Input: Mutation Probability p Scores for the new population new Scores Scores for the previous population scores Output: Updated mutation probability pnew currScore = max(newScores)</td></tr><tr><td>prevScore = max(scores) β</td></tr><tr><td>Pnew =αX Pold + lcurrScore-prevScorel return pnew</td></tr></table>
+
+# 2.3 GRADIENT ESTIMATION
+
+Genetic algorithms work well when the target space is large and a relatively large number of mutation directions are potentially beneficial; the strength of these algorithms lies in being able to search large amounts of space efficiently Godefroi & Khurshid (unkown). When an adversarial sample nears its target perturbation, this strength of genetic algorithms turn into a weakness, however. Close to the end, adversarial audio samples only need a few perturbations in a few key areas to get the correct decoding. In this case, gradient estimation techniques tend to be more effective. Specifically, when edit distance of the current decoding and the target decoding drops below some threshold, we switch to phase 2. When approximating the gradient of a black box system, we can use the technique proposed by Nitin Bhagoji et al. (2017):
+
+$$
+F D _ { x } ( x , \delta ) = \binom { \lceil { ( g ( x + \delta _ { 1 } ) - g ( x ) ) } / \delta } { \vdots }
+$$
+
+Here, $x$ refers to the vector of inputs representing the audio file. $\delta _ { i }$ refers to a vector of all zeros, except at the $i ^ { t h }$ position in which the value is a small $\delta$ . $g ( \cdot )$ represents the evaluation function, which in our case is CTCLoss. Essentially, we are performing a small perturbation at each index and individually seeing what the difference in CTCLoss would be, allowing us to compute a gradient estimate with respect to the input $x$ .
+
+However, performing this calculation in full would be prohibitively expensive, as the audio is sampled at $1 6 k H z$ and so a simple 5-second clip would require 80,000 queries to the model for just one gradient evaluation! Thus, we only randomly sample 100 indices to perturb each generation when using this method. When the adversarial example is already near the goal, gradient estimation makes the tradeoff for more informed perturbations in exchange for higher compute.
+
+# 3 EVALUATION
+
+# 3.1 METRICS
+
+We tested our algorithm by running it on a 100 sample subset of the Common Voice dataset. For each audio sample, we generated a single random target phrase by selecting two words uniformly without replacement from the set of 1000 most common words in the English language. The algorithm was then run for each audio sample and target phrase pair for 3000 generations to produce a single adversarial audio sample.
+
+We evaluated the performance of our algorithm in two primary ways. The first method is determining the accuracy with which the adversarial audio sample gets decoded to the desired target phrase. For this, we use the Levenshtein distance, or the minimum character edit distance, between the desired target phrase and the decoded phrase as the metric of choice. We then calculated the percent similarity between the desired target and the decoded phrase by calculating the ratio of the Levenshtein distance and the character length of the original input, ie. $\begin{array} { r } { \dot { 1 } - \frac { L e v e n s { \bar { h } } t e i n ( M ( x ^ { \prime } ) , t ) } { l e n ( M ( x ) ) } } \end{array}$ . The second method is determining the similarity between the original audio sample and the adversarial audio sample. For this, we use the accepted metric of the cross correlation coefficient between the two audio samples.
+
+![](images/656910746ad0201bc30ede92cf518b0aad14fb183b75004c9a113d0dac6a7194.jpg)  
+Figure 5: Histogram of levenshtein distances of attacks.
+
+# 3.2 RESULTS
+
+Of the audio samples for which we ran our algorithm on, we achieved a $8 9 . 2 5 \%$ similarity between the final decoded phrase and the target using Levenshtein distance, with an average of $9 4 . 6 \%$ correlation similarity between the final adversarial sample and the original sample. The average final Levenshtein distance after 3000 iterations is 2.3, with $3 5 \%$ of the adversarial samples achieving an exact decoding in less than 3000 generations, and $22 \%$ of the adversarial samples achieving an exact decoding in less than 1000 generations.
+
+One thing to note is that our algorithm was $3 5 \%$ successful in getting the decoded phrase to match the target exactly; however, noting from figure 5, the vast majority of failure cases are only a few edit distances away from the target. This suggests that running the algorithm for a few more iterations could produce a higher success rate, although at the cost of correlation similarity. Indeed, it becomes apparent that there is a tradeoff between success rate and audio similarity such that this threshold could be altered for the attacker’s needs.
+
+A comparison of white box targeted attacks, black box targeted attacks on single words (classification), and our method:
+
+<table><tr><td>Metric</td><td>WhiteBoxAttacks</td><td>Our Method</td><td>Single Word Black Box</td></tr><tr><td>Targeted attack success rate Average similarity score Similarity score method Loss used for attack Dataset tested on</td><td>100% 99.9% cross-correlation CTC</td><td>35% 94.6% cross-correlation CTC</td><td>87% 89% human study Softmax</td></tr></table>
+
+One helpful visualization of the similarity between the original audio sample and the adversarial audio sample through the overlapping of both waveforms, as shown in figure 4. As the visualization shows, the audio is largely unchanged, and the majority of the changes to the audio is in the relatively low volume noise applied uniformly around the audio sample. This results in an audio sample that still appears to transcribe to the original intended phrase when heard by humans, but is decoded as the target adversarial phrase by the DeepSpeech model.
+
+That $3 5 \%$ of random attacks were successful in this respect highlights the fact that black box adversarial attacks are definitely possible and highly effective at the same time.
+
+# 4 CONCLUSION
+
+In combining genetic algorithms and gradient estimation we are able to achieve a black box adversarial example for audio that produces better samples than each algorithm would produce individually. By initially using a genetic algorithm as a means of exploring more space through encouragement of random mutations and ending with a more guided search with gradient estimation, we are not only able to achieve perfect or near-perfect target transcriptions on most of the audio samples, we were able to do so while retaining a high degree of similarity. While this remains largely as a proof-of-concept demonstration, this paper shows that targeted adversarial attacks are achievable on black box models using straightforward methods.
+
+Furthermore, the inclusion of momentum mutation and adding noise exclusively to high frequencies improved the effectiveness of our approach. Momentum mutation exaggerated the exploration at the beginning of the algorithm and annealed it at the end, emphasizing the benefits intended by combining genetic algorithms and gradient estimation. Restricting noise to the high frequency domain improved upon our similarity both subjectively by keeping it from interfering with human voice as well as objectively in our audio sample correlations. By combining all of these methods, we are able to achieve our top results.
+
+In conclusion, we introduce a new domain for black box attacks, specifically on deep, nonlinear ASR systems that can output arbitrary length translations. Using a combination of existing and novel methods, we are able to exhibit the feasibility of our approach and open new doors for future research.
+
+# REFERENCES
+
+M. Alzantot, B. Balaji, and M. Srivastava. Did you hear that? Adversarial Examples Against Automatic Speech Recognition. ArXiv e-prints, January 2018.   
+N. Carlini and D. Wagner. Towards Evaluating the Robustness of Neural Networks. ArXiv e-prints, August 2016.   
+N. Carlini and D. Wagner. Audio Adversarial Examples: Targeted Attacks on Speech-to-Text. ArXiv e-prints, January 2018.   
+C.-C. Chiu, T. N. Sainath, Y. Wu, R. Prabhavalkar, P. Nguyen, Z. Chen, A. Kannan, R. J. Weiss, K. Rao, E. Gonina, N. Jaitly, B. Li, J. Chorowski, and M. Bacchiani. State-of-the-art Speech Recognition With Sequence-to-Sequence Models. ArXiv e-prints, December 2017.
+
+M. Cisse, Y. Adi, N. Neverova, and J. Keshet. Houdini: Fooling Deep Structured Prediction Models. ArXiv e-prints, July 2017.
+
+Patrice Godefroi and Sarfraz Khurshid. Exploring Very Large State Spaces Using Genetic Algorithm. MIT, unkown.
+
+I. J. Goodfellow, J. Shlens, and C. Szegedy. Explaining and Harnessing Adversarial Examples. ArXiv e-prints, December 2014.
+
+A. Hannun, C. Case, J. Casper, B. Catanzaro, G. Diamos, E. Elsen, R. Prenger, S. Satheesh, S. Sengupta, A. Coates, and A. Y. Ng. Deep Speech: Scaling up end-to-end speech recognition. ArXiv e-prints, December 2014.
+
+J. H. Holland. Genetic algorithms. Scientific american, 1992.
+
+Y. Liu, X. Chen, C. Liu, and D. Song. Delving into Transferable Adversarial Examples and Black-box Attacks. ArXiv e-prints, November 2016.
+
+S.-M. Moosavi-Dezfooli, A. Fawzi, and P. Frossard. DeepFool: a simple and accurate method to fool deep neural networks. ArXiv e-prints, November 2015.
+
+A. Nitin Bhagoji, W. He, B. Li, and D. Song. Exploring the Space of Black-box Attacks on Deep Neural Networks. ArXiv e-prints, December 2017.
+
+Nicolas Papernot, Patrick D. McDaniel, Ian J. Goodfellow, Somesh Jha, Z. Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. CoRR, abs/1602.02697, 2016. URL http://arxiv.org/abs/1602.02697.
+
+T. Reichenbach and A. J. Hudspeth. Discrimination of Low-Frequency Tones Employs Temporal Fine Structure. PLoS ONE, 7:e45579, September 2012. doi: 10.1371/journal.pone.0045579.

parse/train/HyGySsAct7/HyGySsAct7_content_list.json

@@ -0,0 +1,993 @@
+[
+    {
+        "type": "text",
+        "text": "TARGETED ADVERSARIAL EXAMPLES FOR BLACK BOX AUDIO SYSTEMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            383,
+            176,
+            616,
+            204
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            246,
+            544,
+            261
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The application of deep recurrent networks to audio transcription has led to impressive gains in automatic speech recognition (ASR) systems. Many have demonstrated that small adversarial perturbations can fool deep neural networks into incorrectly predicting a specified target with high confidence. Current work on fooling ASR systems have focused on white-box attacks, in which the model architecture and parameters are known. In this paper, we adopt a black-box approach to adversarial generation, combining the approaches of both genetic algorithms and gradient estimation to solve the task. We achieve a $8 9 . 2 5 \\%$ targeted attack similarity after 3000 generations while maintaining $9 4 . 6 \\%$ audio file similarity. ",
+        "bbox": [
+            233,
+            280,
+            766,
+            405
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            438,
+            336,
+            454
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Although neural networks have incredible expressive capacity, which allow them to be well suited for a variety of machine learning tasks, they have been shown to be vulnerable to adversarial attacks over multiple network architectures and datasets Goodfellow et al. (2014). These attacks can be done by adding small perturbations to the original input so that the network misclassifies the input but a human does not notice the difference. ",
+        "bbox": [
+            174,
+            470,
+            825,
+            540
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "So far, there has been much more work done in generating adversarial examples for image inputs than for other domains, such as audio. Voice control systems are widely used in many products from personal assistants, like Amazon Alexa and Apple Siri, to voice command technologies in cars. One main challenge for such systems is determining exactly what the user is saying and correctly interpreting the statement. As deep learning helps these systems better understand the user, one potential issue is targeted adversarial attacks on the system, which perturb the waveform of what the user says to the system to cause the system to behave in a predetermined inappropriate way. For example, a seemingly benign TV advertisement could be adversely perturbed to cause Alexa to interpret the audio as “Alexa, buy 100 headphones.” If the original user went back to listen to the audio clip that prompted the order, the noise would be almost undetectable to the human ear. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There are multiple different methods of performing adversarial attacks depending on what information the attacker has about the network. If given access to the parameters of a network, white box attacks are most successful, such as the Fast Gradient Sign Method Goodfellow et al. (2014) or DeepFool Moosavi-Dezfooli et al. (2015). However, assuming an attacker has access to all the parameters of a network is unrealistic in practice. In a black box setting, when an attacker only has access to the logits or outputs of a network, it is much harder to consistently create successful adversarial attacks. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            777
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In certain special black box settings, white box attack methods can be reused if an attacker creates a model that approximates the original targeted model. However, even though attacks can transfer across networks for some domains, this requires more knowledge of how to solve the task that the original model is solving than an attacker may have Liu et al. (2016); Papernot et al. (2016). Instead, we propose a novel combination of genetic algorithms and gradient estimation to solve this task. The first phase of the attack is carried out by genetic algorithms, which are a gradient-free method of optimization that iterate over populations of candidates until a suitable sample is produced. In order to limit excess mutations and thus excess noise, we improve the standard genetic algorithm with a new momentum mutation update. The second phase of the attack utilizes gradient estimation, where the gradients of individual audio points are estimated, thus allowing for more careful noise placement when the adversarial example is nearing its target. The combination of these two approaches provides a $8 9 . 2 5 \\%$ average targeted attack similarity with a $9 4 . 6 \\%$ audio file similarity after 3000 generations. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/702a79e13def8c6dba6e31287f0a41fee5a20c11dbb53617509b9193ada57cd8.jpg",
+        "image_caption": [
+            "Figure 1: Example of targeted adversarial attack on speech to text systems in practice "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            387,
+            99,
+            609,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            244,
+            826,
+            272
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 PROBLEM STATEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            290,
+            369,
+            304
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial attacks can be created given a variety of information about the neural network, such as the loss function or the output probabilities. However in a natural setting, usually the neural network behind such a voice control system will not be publicly released so an adversary will only have access to an API which provides the text the system interprets given a continuous waveform. Given this constraint, we use the open sourced Mozilla DeepSpeech implementation as a black box system, without using any information on how the transcription is done. ",
+        "bbox": [
+            174,
+            315,
+            825,
+            400
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We perform our black box targeted attack on a model $M$ given a benign input $x$ and a target $t$ by perturbing $x$ to form the adversarial input $x ^ { \\prime } = x + \\delta$ , such that $M ( x ^ { \\prime } ) = t$ . To minimize the audible noise added to the input, so a human cannot notice the target, we maximize the cross correlation between $x$ and $x ^ { \\prime }$ . A sufficient value of $\\delta$ is determined using our novel black box approach, so we do not need access to the gradients of $M$ to perform the attack. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            477
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.2 PRIOR WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            493,
+            305,
+            507
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Compared to images, audio presents a much more significant challenge for models to deal with. While convolutional networks can operate directly on the pixel values of images, ASR systems typically require heavy pre-processing of the input audio. Most commonly, the Mel-Frequency Cepstrum (MFC) transform, essentially a fourier transform of the sampled audio file, is used to convert the input audio into a spectogram which shows frequencies over time. Models such as DeepSpeech (Fig. 2) use this spectogram as the initial input. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            603
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In a foundational study for adversarial attacks, Cisse et al. (2017) developed a general attack framework to work across a wide variety of models including images and audio. When applying their method to audio samples, they ran into the roadblock of backpropagating through the MFC conversion layer. Thus, they were able to produce adversarial spectograms but not adversarial .wav files. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            665
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Carlini & Wagner (2018) overcame this challenge by developing a method of passing gradients through the MFC layer, a task which was previously proved to be difficult Cisse et al. (2017). They applied their method to the Mozilla DeepSpeech model, which is a complex, recurrent, character-level network that can decode translations at up to 50 characters per second. With a gradient connection all the way to the raw input, they were able to achieve impressive results, including generating samples over $9 9 . 9 \\%$ similar with a targeted attack accuracy of $100 \\%$ . While the success of this attack opens new doors for white box attacks, adversaries in a real-life setting commonly do not have knowledge of model architectures or parameters. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            784
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Alzantot et al. (2018) have demonstrated that black-box approaches for targeted attacks on ASR systems are possible. Using a genetic algorithm approach, they were able to iteratively apply noise to audio samples, pruning away poor performers at each generation, and ultimately end up with a perturbed version of the input that successfully fooled a classification system. This attack was conducted on the Speech Commands classification model Alzantot et al. (2018), which is a lightweight convolutional model for classifying up to 50 different single-word phrases. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Extending the research done by Alzantot et al. (2018), we propose a genetic algorithm and gradient estimation approach to create targeted adversarial audio, but on the more complex DeepSpeech system. The difficulty of this task comes in attempting to apply black-box optimization to a deeplylayered, highly nonlinear decoder model that has the ability to decode phrases of arbitrary length. Nevertheless, the combination of two differing approaches as well as the momentum mutation update bring new success to this task. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/73371a04dc01d589dedd50963db02395c3c1c2164f92a9725fef55d67d3744ff.jpg",
+        "image_caption": [
+            "Figure 2: Diagram of Baidu’s DeepSpeech model Hannun et al. (2014) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            408,
+            102,
+            584,
+            218
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            277,
+            825,
+            319
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1.3 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            338,
+            315,
+            352
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Dataset For the attack, we follow Carlini & Wagner (2018) and take the first 100 audio samples from the CommonVoice test set. For each, we randomly generate a 2-word target phrase and apply our black-box approach to construct an adversarial example. More details on evaluation can be found in section 3. Each sample in the dataset is a .wav file, which can easily be deserialized into a numpy array. Our algorithm operates directly on the numpy arrays, thus bypassing the difficulty of dealing with the MFC conversion. ",
+        "bbox": [
+            173,
+            364,
+            825,
+            448
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Victim model The model we attack is Baidu’s DeepSpeech model Hannun et al. (2014), implemented in Tensorflow and open-sourced by Mozilla.1 Though we have access to the full model, we treat it as if in a black box setting and only access the output logits of the model. In line with other speech to text systems Chiu et al. (2017); Cisse et al. (2017), DeepSpeech accepts a spectrogram of the audio file. After performing the MFC conversion, the model consists 3 layers of convolutions, followed by a bi-directional LSTM, followed by a fully connected layer. This layer is then fed into the decoder RNN, which outputs logits over the distribution of output characters, up to 50 characters per second of audio. The model is illustrated in figure 2. ",
+        "bbox": [
+            173,
+            464,
+            826,
+            577
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Connectionist temporal classication While the DeepSpeech model is designed to allow arbitrary length translations, there is no given labeled alignment of the output and input sequences during training time. Thus the connectionist temporal classication loss (CTC Loss) is introduced, as it allows computing a loss even when the position of a decoded word in the original audio is unknown Carlini & Wagner (2018). ",
+        "bbox": [
+            174,
+            593,
+            825,
+            662
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "DeepSpeech outputs a probability distribution over all characters at every frame, for 50 frames per second of audio. In addition to outputting the normal alphabet a-z and space, it can output special character $\\epsilon$ . Then CTC decoder $C ( \\cdot )$ decodes the logits as such: for every frame, take the character with the max logit. Then first, remove all adjacent duplicate characters, and then second, remove any special $\\epsilon$ characters. Thus aab\u000f\u000fb will decode to abb Carlini & Wagner (2018). ",
+        "bbox": [
+            174,
+            670,
+            825,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As we can see, multiple outputs can decode to the same phrase. Following the notation in Carlini & Wagner (2018), for any target phrase $p$ , we call $\\pi$ an alignment of $p$ if $C ( \\pi ) = p$ . Let us also call the output distribution of our model $y$ . Now, in order to find the likelihood of alignment $\\pi$ under $y$ : ",
+        "bbox": [
+            174,
+            747,
+            825,
+            789
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0c186411e689d3f9078d269f5673bb099d4a54d7f7766152c3f7edb521c5496f.jpg",
+        "text": "$$\nP r ( p | y ) = \\sum _ { \\pi | C ( \\pi ) = p } P r ( \\pi | y ) = \\sum _ { \\pi | C ( \\pi ) = p } \\prod _ { i } y _ { \\pi } ^ { i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            806,
+            658,
+            843
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "as noted by Carlini & Wagner (2018). This is the objective we use when scoring samples from the populations in each generation of our genetic algorithm as well as the score used in estimating gradients. ",
+        "bbox": [
+            176,
+            854,
+            823,
+            897
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Greedy decoding As in traditional recurrent decoder systems, DeepSpeech typically uses a beam search of beam width 500. At each frame of decoding, 500 of the most likely $\\pi$ will be evaluated, each producing another 500 candidates for a total of 2500, which are pruned back down to 500 for the next timestep. Evaluating multiple assignments this way increases the robustness of the model decoding. However, following work in Carlini & Wagner (2018), we set the model to use greedy decoding. At each timestep only $1 \\pi$ is evaluated, leading to a greedy assignment: ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6fb46dae308f8b2a2cc5d3ba1937ddca82b4ce42badf393284f45b8a330d3b62.jpg",
+        "text": "$$\nd e c o d e ( x ) = C ( \\arg \\operatorname* { m a x } _ { \\pi } P r ( { y } ( { x } ) | \\pi ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            207,
+            627,
+            232
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Thus, our genetic algorithm will focus on creating perturbations to the most likely sequence (if greedily approximated). ",
+        "bbox": [
+            173,
+            242,
+            825,
+            271
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2 BLACK BOX ATTACK ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            291,
+            483,
+            308
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/4a9f86fa45f8d6ae01b9e4d9fa9c535d790f43224090e2ead706a3c784d56609.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm1 Black box algorithm for generating adversarial audio sample</td></tr><tr><td>Input: Original benign input x Target phrase t Output: Adversarial Audio Sample x&#x27; population ← [x] * populationSize while iter&lt;maxIters and Decode(best)!= t do scores ← -CTCLoss(population,t) best ← population[Argmax(scores)]</td></tr><tr><td>if EditDistance(t,Decode(best)) &gt;2 then / phase 1 - do genetic algorithm while populationSize children have not been made do</td></tr><tr><td>Select parent1 from topk(population) according to softmax(their score) Select parent2 from topk(population) according to softmax(their score) child ← Mutate(Crossover(parent1,parent2), p)</td></tr><tr><td>end while newScores ← -CTCLoss(newPopulation,t)</td></tr><tr><td>p ← MomentumUpdate(p,newScores, scores) else</td></tr><tr><td>/ phase 2 - do gradient estimation top-element ← top(population) grad-pop ← n copies of top-element, each mutated slightly at one index grad ←(-CTCLoss(grad-pop)- scores)/mutation-delta pop ← top-element + grad</td></tr></table>",
+        "bbox": [
+            171,
+            328,
+            740,
+            710
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.1 GENETIC ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            737,
+            369,
+            752
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As mentioned previously, Alzantot et al. (2018) demonstrated the success of a black-box adversarial attack on speech-to-text systems using a standard genetic algorithm. The basic premise of our algorithm is that it takes in the benign audio sample and, through trial and error, adds noise to the sample such that the perturbed adversarial audio is similar to the benign input yet is decoded as the target, as shown in Figure 3. A genetic algorithm works well for a problem of this nature because it is completely independent of the gradients of the model. Alzantot et al. (2018) used a limited dataset consisting of audio samples with just one word and a classification with a predefined number of classes. In order to extend this algorithm to work with phrases and sentences, as well as with CTC Loss, we make modifications to the genetic algorithm and introduce our novel momentum mutation. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The genetic algorithm works by improving on each iteration, or generation, through evolutionary methods such as Crossover and Mutation Holland (1992). For each iteration, we compute the score for each sample in the population to determine which samples are the best. Our scoring function was the CTC-Loss, which as mentioned previously, is used to determine the similarity between an input audio sequence and a given phrase. We then form our elite population by selecting the best scoring samples from our population. The elite population contains samples with desirable traits that we want to carry over into future generations. We then select parents from the elite population and perform Crossover, which creates a child by taking around half of the elements from parent1 and the other half from parent2. The probability that we select a sample as a parent is a function of the sample’s score. With some probability, we then add a mutation to our new child. Finally, we update our mutation probabilities according to our momentum update, and move to the next iteration. The population will continue to improve over time as only the best traits of the previous generations as well as the best mutations will remain. Eventually, either the algorithm will reach the max number of iterations, or one of the samples is exactly decoded as the target, and the best sample is returned. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/2059e59de774fa523712cc2081fa1bf0391f4f59372c42dbbd7ed4e23abdcb3b.jpg",
+        "image_caption": [
+            "Figure 3: Diagram of our genetic algorithm "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            145,
+            485,
+            281
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/d14bf5a129c3fd17d74d1e72d9ac3af24b1909a1d0705d938ec3ea5122f0bcd8.jpg",
+        "image_caption": [
+            "Figure 4: Overlapping of adversarial (blue) and original (orange) audio sample waveforms. The perturbation is barely noticeable "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            565,
+            106,
+            813,
+            243
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            359,
+            825,
+            526
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.2 MOMENTUM MUTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            547,
+            380,
+            561
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/9d7976e786dc0d63013b39a37ae469f4b92ff09f0c7a7bbf063e382fcb5cc71d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm 2 Mutation</td></tr><tr><td>Input: Audio Sample x</td></tr><tr><td>Mutation Probability p</td></tr><tr><td>Output: Mutated Audio Sample x&#x27;</td></tr><tr><td></td></tr><tr><td>for all e in x do</td></tr><tr><td>noise ← Sample(N(μ,σ²)) if Sample(Unif(O,1))&lt;p then</td></tr><tr><td>e&#x27; ←e+ filterhighpass(noise)</td></tr><tr><td>end if</td></tr><tr><td>end for</td></tr><tr><td>return x</td></tr></table>",
+        "bbox": [
+            173,
+            582,
+            825,
+            757
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The mutation step is arguably the most crucial component of the genetic algorithm and is our only source of noise in the algorithm. In the mutation step, with some probability, we randomly add noise to our sample. Random mutations are critical because it may cause a trait to appear that is beneficial for the population, which can then be proliferated through crossover. Without mutation, very similar samples will start to appear across generations; thus, the way out of this local maximum is to nudge it in a different direction in order to reach higher scores. ",
+        "bbox": [
+            173,
+            776,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, since this noise is perceived as background noise, we apply a filter to the noise before adding it onto the audio sample. The audio is sampled at a rate of $f _ { s } = 1 6 k H z$ , which means that the maximum frequency response $f _ { m a x } = 8 k H z$ . As seen by Reichenbach & Hudspeth (2012), given that the human ear is more sensitive to lower frequencies than higher ones, we apply a highpass filter at a cutoff frequency of $f _ { c u t o f f } = 7 k H z$ . This limits the noise to only being in the high-frequency range, which is less audible and thus less detectable by the human ear. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While mutation helps the algorithm overcome local maxima, the effect of mutation is limited by the mutation probability. Much like the step size in SGD, a low mutation probability may not provide enough randomness to get past a local maximum. If mutations are rare, they are very unlikely to occur in sequence and add on to each other. Therefore, while a mutation might be beneficial when accumulated with other mutations, due to the low mutation probability, it is deemed as not beneficial by the algorithm in the short term, and will disappear within a few iterations. This parallels the step size in SGD, because a small step size will eventually converge back at the local minimum/maximum. However, too large of a mutation probability, or step size, will add an excess of variability and prevent the algorithm from finding the global maximum/minimum. To combat these issues, we propose Momentum Mutation, which is inspired by the Momentum Update for Gradient Descent. With this update, our mutation probability changes in each iteration according to the following exponentially weighted moving average update: ",
+        "bbox": [
+            173,
+            138,
+            826,
+            306
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ee6ffc52bace3a4c44f95198b3c050ae97a740e1b816076a94e00330c6a8be92.jpg",
+        "text": "$$\np _ { n e w } = \\alpha \\times p _ { o l d } + \\frac { \\beta } { | c u r r S c o r e - p r e v S c o r e | }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            321,
+            656,
+            356
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "With this update equation, the probability of a mutation increases as our population fails to adapt meaning the current score is close to the previous score. The momentum update adds acceleration to the mutation probability, allowing mutations to accumulate and add onto each other by keeping the mutation probability high when the algorithm is stuck at a local maximum. By using a moving average, the mutation probability becomes a smooth function and is less susceptible to outliers in the population. While the momentum update may overshoot the target phrase by adding random noise, overall it converges faster than a constant mutation probability by allowing for more acceleration in the right directions. ",
+        "bbox": [
+            173,
+            362,
+            825,
+            474
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 3 Momentum Mutation Update ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            489,
+            454,
+            503
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/8c6122a88db2dcefe101a33d3619580a3eac07f621d6ba72f356cdd967b32445.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Input: Mutation Probability p Scores for the new population new Scores Scores for the previous population scores Output: Updated mutation probability pnew currScore = max(newScores)</td></tr><tr><td>prevScore = max(scores) β</td></tr><tr><td>Pnew =αX Pold + lcurrScore-prevScorel return pnew</td></tr></table>",
+        "bbox": [
+            173,
+            506,
+            470,
+            638
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2.3 GRADIENT ESTIMATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            662,
+            380,
+            676
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Genetic algorithms work well when the target space is large and a relatively large number of mutation directions are potentially beneficial; the strength of these algorithms lies in being able to search large amounts of space efficiently Godefroi & Khurshid (unkown). When an adversarial sample nears its target perturbation, this strength of genetic algorithms turn into a weakness, however. Close to the end, adversarial audio samples only need a few perturbations in a few key areas to get the correct decoding. In this case, gradient estimation techniques tend to be more effective. Specifically, when edit distance of the current decoding and the target decoding drops below some threshold, we switch to phase 2. When approximating the gradient of a black box system, we can use the technique proposed by Nitin Bhagoji et al. (2017): ",
+        "bbox": [
+            173,
+            688,
+            825,
+            814
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/80048329b24ecc6daea8dd9975d7ef756926647b32dcd1da0388d76937134845.jpg",
+        "text": "$$\nF D _ { x } ( x , \\delta ) = \\binom { \\lceil { ( g ( x + \\delta _ { 1 } ) - g ( x ) ) } / \\delta } { \\vdots }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            829,
+            629,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here, $x$ refers to the vector of inputs representing the audio file. $\\delta _ { i }$ refers to a vector of all zeros, except at the $i ^ { t h }$ position in which the value is a small $\\delta$ . $g ( \\cdot )$ represents the evaluation function, which in our case is CTCLoss. Essentially, we are performing a small perturbation at each index and individually seeing what the difference in CTCLoss would be, allowing us to compute a gradient estimate with respect to the input $x$ . ",
+        "bbox": [
+            173,
+            895,
+            826,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "However, performing this calculation in full would be prohibitively expensive, as the audio is sampled at $1 6 k H z$ and so a simple 5-second clip would require 80,000 queries to the model for just one gradient evaluation! Thus, we only randomly sample 100 indices to perturb each generation when using this method. When the adversarial example is already near the goal, gradient estimation makes the tradeoff for more informed perturbations in exchange for higher compute. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            223
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            243,
+            315,
+            260
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.1 METRICS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            275,
+            281,
+            290
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We tested our algorithm by running it on a 100 sample subset of the Common Voice dataset. For each audio sample, we generated a single random target phrase by selecting two words uniformly without replacement from the set of 1000 most common words in the English language. The algorithm was then run for each audio sample and target phrase pair for 3000 generations to produce a single adversarial audio sample. ",
+        "bbox": [
+            174,
+            301,
+            825,
+            371
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluated the performance of our algorithm in two primary ways. The first method is determining the accuracy with which the adversarial audio sample gets decoded to the desired target phrase. For this, we use the Levenshtein distance, or the minimum character edit distance, between the desired target phrase and the decoded phrase as the metric of choice. We then calculated the percent similarity between the desired target and the decoded phrase by calculating the ratio of the Levenshtein distance and the character length of the original input, ie. $\\begin{array} { r } { \\dot { 1 } - \\frac { L e v e n s { \\bar { h } } t e i n ( M ( x ^ { \\prime } ) , t ) } { l e n ( M ( x ) ) } } \\end{array}$ . The second method is determining the similarity between the original audio sample and the adversarial audio sample. For this, we use the accepted metric of the cross correlation coefficient between the two audio samples. ",
+        "bbox": [
+            173,
+            378,
+            825,
+            496
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/656910746ad0201bc30ede92cf518b0aad14fb183b75004c9a113d0dac6a7194.jpg",
+        "image_caption": [
+            "Figure 5: Histogram of levenshtein distances of attacks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            369,
+            515,
+            620,
+            667
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            277,
+            737
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Of the audio samples for which we ran our algorithm on, we achieved a $8 9 . 2 5 \\%$ similarity between the final decoded phrase and the target using Levenshtein distance, with an average of $9 4 . 6 \\%$ correlation similarity between the final adversarial sample and the original sample. The average final Levenshtein distance after 3000 iterations is 2.3, with $3 5 \\%$ of the adversarial samples achieving an exact decoding in less than 3000 generations, and $22 \\%$ of the adversarial samples achieving an exact decoding in less than 1000 generations. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "One thing to note is that our algorithm was $3 5 \\%$ successful in getting the decoded phrase to match the target exactly; however, noting from figure 5, the vast majority of failure cases are only a few edit distances away from the target. This suggests that running the algorithm for a few more iterations could produce a higher success rate, although at the cost of correlation similarity. Indeed, it becomes apparent that there is a tradeoff between success rate and audio similarity such that this threshold could be altered for the attacker’s needs. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A comparison of white box targeted attacks, black box targeted attacks on single words (classification), and our method: ",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e8d0b09def98fd41837b2eed3da420825b7ea1dd39e0f5de32688811363e6393.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Metric</td><td>WhiteBoxAttacks</td><td>Our Method</td><td>Single Word Black Box</td></tr><tr><td>Targeted attack success rate Average similarity score Similarity score method Loss used for attack Dataset tested on</td><td>100% 99.9% cross-correlation CTC</td><td>35% 94.6% cross-correlation CTC</td><td>87% 89% human study Softmax</td></tr></table>",
+        "bbox": [
+            173,
+            155,
+            833,
+            260
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "One helpful visualization of the similarity between the original audio sample and the adversarial audio sample through the overlapping of both waveforms, as shown in figure 4. As the visualization shows, the audio is largely unchanged, and the majority of the changes to the audio is in the relatively low volume noise applied uniformly around the audio sample. This results in an audio sample that still appears to transcribe to the original intended phrase when heard by humans, but is decoded as the target adversarial phrase by the DeepSpeech model. ",
+        "bbox": [
+            173,
+            270,
+            826,
+            354
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "That $3 5 \\%$ of random attacks were successful in this respect highlights the fact that black box adversarial attacks are definitely possible and highly effective at the same time. ",
+        "bbox": [
+            173,
+            361,
+            823,
+            390
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            411,
+            318,
+            428
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In combining genetic algorithms and gradient estimation we are able to achieve a black box adversarial example for audio that produces better samples than each algorithm would produce individually. By initially using a genetic algorithm as a means of exploring more space through encouragement of random mutations and ending with a more guided search with gradient estimation, we are not only able to achieve perfect or near-perfect target transcriptions on most of the audio samples, we were able to do so while retaining a high degree of similarity. While this remains largely as a proof-of-concept demonstration, this paper shows that targeted adversarial attacks are achievable on black box models using straightforward methods. ",
+        "bbox": [
+            174,
+            444,
+            825,
+            556
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, the inclusion of momentum mutation and adding noise exclusively to high frequencies improved the effectiveness of our approach. Momentum mutation exaggerated the exploration at the beginning of the algorithm and annealed it at the end, emphasizing the benefits intended by combining genetic algorithms and gradient estimation. Restricting noise to the high frequency domain improved upon our similarity both subjectively by keeping it from interfering with human voice as well as objectively in our audio sample correlations. By combining all of these methods, we are able to achieve our top results. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            660
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In conclusion, we introduce a new domain for black box attacks, specifically on deep, nonlinear ASR systems that can output arbitrary length translations. Using a combination of existing and novel methods, we are able to exhibit the feasibility of our approach and open new doors for future research. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            710
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            733,
+            287,
+            747
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "M. Alzantot, B. Balaji, and M. Srivastava. Did you hear that? Adversarial Examples Against Automatic Speech Recognition. ArXiv e-prints, January 2018.   \nN. Carlini and D. Wagner. Towards Evaluating the Robustness of Neural Networks. ArXiv e-prints, August 2016.   \nN. Carlini and D. Wagner. Audio Adversarial Examples: Targeted Attacks on Speech-to-Text. ArXiv e-prints, January 2018.   \nC.-C. Chiu, T. N. Sainath, Y. Wu, R. Prabhavalkar, P. Nguyen, Z. Chen, A. Kannan, R. J. Weiss, K. Rao, E. Gonina, N. Jaitly, B. Li, J. Chorowski, and M. Bacchiani. State-of-the-art Speech Recognition With Sequence-to-Sequence Models. ArXiv e-prints, December 2017. ",
+        "bbox": [
+            171,
+            757,
+            826,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "M. Cisse, Y. Adi, N. Neverova, and J. Keshet. Houdini: Fooling Deep Structured Prediction Models. ArXiv e-prints, July 2017. ",
+        "bbox": [
+            169,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Patrice Godefroi and Sarfraz Khurshid. Exploring Very Large State Spaces Using Genetic Algorithm. MIT, unkown. ",
+        "bbox": [
+            171,
+            140,
+            825,
+            170
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "I. J. Goodfellow, J. Shlens, and C. Szegedy. Explaining and Harnessing Adversarial Examples. ArXiv e-prints, December 2014. ",
+        "bbox": [
+            169,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A. Hannun, C. Case, J. Casper, B. Catanzaro, G. Diamos, E. Elsen, R. Prenger, S. Satheesh, S. Sengupta, A. Coates, and A. Y. Ng. Deep Speech: Scaling up end-to-end speech recognition. ArXiv e-prints, December 2014. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            260
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "J. H. Holland. Genetic algorithms. Scientific american, 1992. ",
+        "bbox": [
+            173,
+            268,
+            576,
+            284
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Y. Liu, X. Chen, C. Liu, and D. Song. Delving into Transferable Adversarial Examples and Black-box Attacks. ArXiv e-prints, November 2016. ",
+        "bbox": [
+            171,
+            291,
+            825,
+            320
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "S.-M. Moosavi-Dezfooli, A. Fawzi, and P. Frossard. DeepFool: a simple and accurate method to fool deep neural networks. ArXiv e-prints, November 2015. ",
+        "bbox": [
+            169,
+            329,
+            825,
+            359
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A. Nitin Bhagoji, W. He, B. Li, and D. Song. Exploring the Space of Black-box Attacks on Deep Neural Networks. ArXiv e-prints, December 2017. ",
+        "bbox": [
+            169,
+            367,
+            823,
+            397
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick D. McDaniel, Ian J. Goodfellow, Somesh Jha, Z. Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. CoRR, abs/1602.02697, 2016. URL http://arxiv.org/abs/1602.02697. ",
+        "bbox": [
+            176,
+            405,
+            823,
+            449
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "T. Reichenbach and A. J. Hudspeth. Discrimination of Low-Frequency Tones Employs Temporal Fine Structure. PLoS ONE, 7:e45579, September 2012. doi: 10.1371/journal.pone.0045579. ",
+        "bbox": [
+            178,
+            457,
+            818,
+            486
+        ],
+        "page_idx": 8
+    }
+]

parse/train/SyxAb30cY7/SyxAb30cY7.md

@@ -0,0 +1,529 @@
+# ROBUSTNESS MAY BE AT ODDS WITH ACCURACY
+
+Dimitris Tsipras∗, Shibani Santurkar∗, Logan Engstrom∗, Alexander Turner, Aleksander M ˛adry   
+Massachusetts Institute of Technology   
+{tsipras,shibani,engstrom,turneram,madry}@mit.edu
+
+# ABSTRACT
+
+We show that there exists an inherent tension between the goal of adversarial robustness and that of standard generalization. Specifically, training robust models may not only be more resource-consuming, but also lead to a reduction of standard accuracy. We demonstrate that this trade-off between the standard accuracy of a model and its robustness to adversarial perturbations provably exists even in a fairly simple and natural setting. These findings also corroborate a similar phenomenon observed in practice. Further, we argue that this phenomenon is a consequence of robust classifiers learning fundamentally different feature representations than standard classifiers. These differences, in particular, seem to result in unexpected benefits: the features learned by robust models tend to align better with salient data characteristics and human perception.
+
+# 1 INTRODUCTION
+
+Deep learning models have achieved impressive performance on a number of challenging benchmarks in computer vision, speech recognition and competitive game playing (Krizhevsky et al., 2012; Graves et al., 2013; Mnih et al., 2015; Silver et al., 2016; He et al., 2015a). However, it turns out that these models are actually quite brittle. In particular, one can often synthesize small, imperceptible perturbations of the input data and cause the model to make highly-confident but erroneous predictions (Dalvi et al., 2004; Biggio & Roli, 2017; Szegedy et al., 2013).
+
+This problem of so-called adversarial examples has garnered significant attention recently and resulted in a number of approaches both to finding these perturbations, and to training models that are robust to them (Goodfellow et al., 2014b; Nguyen et al., 2015; Moosavi-Dezfooli et al., 2016; Carlini & Wagner, 2016; Sharif et al., 2016; Kurakin et al., 2016a; Evtimov et al., 2017; Athalye et al., 2017). However, building such adversarially robust models has proved to be quite challenging. In particular, many of the proposed robust training methods were subsequently shown to be ineffective (Carlini & Wagner, 2017; Athalye et al., 2018; Uesato et al., 2018). Only recently, has there been progress towards models that achieve robustness that can be demonstrated empirically and, in some cases, even formally verified (Madry et al., 2017; Kolter & Wong, 2017; Sinha et al., 2017; Tjeng & Tedrake, 2017; Raghunathan et al., 2018; Dvijotham et al., 2018a; Xiao et al., 2018b).
+
+The vulnerability of models trained using standard methods to adversarial perturbations makes it clear that the paradigm of adversarially robust learning is different from the classic learning setting. In particular, we already know that robustness comes at a cost. This cost takes the form of computationally expensive training methods (more training time), but also, as shown recently in Schmidt et al. (2018), the potential need for more training data. It is natural then to wonder: Are these the only costs of adversarial robustness? And, if so, once we choose to pay these costs, would it always be preferable to have a robust model instead of a standard one? The goal of this work is to explore these questions and thus, in turn, to bring us closer to understanding the phenomenon of adversarial robustness.
+
+Our contributions It might be natural to expect that training models to be adversarially robust, albeit more resource-consuming, can only improve performance in the standard classification setting. In this work, we show, however, that the picture here is much more nuanced: these two goals might be fundamentally at odds. Specifically, even though applying adversarial training, the leading method for training robust models, can be beneficial in some regimes of training data size, in general, there is a trade-off between the standard accuracy and adversarially robust accuracy of a model. In fact, we show that this trade-off provably exists even in a fairly simple and natural setting.
+
+At the root of this trade-off is the fact that features learned by the optimal standard and optimal robust classifiers are fundamentally different and, interestingly, this phenomenon persists even in the limit of infinite data. This thus also goes against the natural expectation that given sufficient data, classic machine learning tools would be sufficient to learn robust models and emphasizes the need for techniques specifically tailored to training robust models.
+
+Our exploration also uncovers certain unexpected benefit of adversarially robust models. In particular, adversarially robust learning tends to equip the resulting models with invariances that we would expect to be also present in human vision. This, in turn, leads to features that align better with human perception, and could also pave the way towards building models that are easier to understand. Consequently, the feature embeddings learnt by robust models yield also clean inter-class interpolations, similar to those found by generative adversarial networks (GANs) (Goodfellow et al., 2014b) and other generative models. This hints at the existence of a stronger connection between GANs and adversarial robustness.
+
+# 2 ON THE PRICE OF ADVERSARIAL ROBUSTNESS
+
+Recall that in the canonical classification setting, the primary focus is on maximizing standard accuracy, i.e. the performance on (yet) unseen samples from the underlying distribution. Specifically, the goal is to train models that have low expected loss (also known as population risk):
+
+$$
+\underset { ( x , y ) \sim \mathcal { D } } { \mathbb { E } } [ \mathcal { L } ( x , y ; \theta ) ] .
+$$
+
+Adversarial robustness The existence of adversarial examples largely changed this picture. In particular, there has been a lot of interest in developing models that are resistant to them, or, in other words, models that are adversarially robust. In this context, the goal is to train models that have low expected adversarial loss:
+
+$$
+\underset { ( x , y ) \sim \mathcal { D } } { \mathbb { E } } \left[ \underset { \delta \in \Delta } { \operatorname* { m a x } } \mathcal { L } ( x + \delta , y ; \theta ) \right] .
+$$
+
+Here, $\Delta$ represents the set of perturbations that the adversary can apply to induce misclassification. In this work, we focus on the case when $\Delta$ is the set of $\ell _ { p }$ -bounded perturbations, i.e. $\Delta = \{ \delta \in$ $\mathbb { R } ^ { d } \mid \| \delta \| _ { p } \leq \varepsilon \}$ . This choice is the most common one in the context of adversarial examples and serves as a standard benchmark. It is worth noting though that several other notions of adversarial perturbations have been studied. These include rotations and translations (Fawzi & Frossard, 2015; Engstrom et al., 2017), and smooth spatial deformations (Xiao et al., 2018a). In general, determining the “right” $\Delta$ to use is a domain specific question.
+
+Adversarial training The most successful approach to building adversarially robust models so far (Madry et al., 2017; Kolter & Wong, 2017; Sinha et al., 2017; Raghunathan et al., 2018) was socalled adversarial training (Goodfellow et al., 2014b). Adversarial training is motivated by viewing (2) as a statistical learning question, for which we need to solve the corresponding (adversarial) empirical risk minimization problem:
+
+$$
+\operatorname* { m i n } _ { \theta } \operatorname* { \mathbb { E } } _ { ( x , y ) \sim \widehat { \mathcal { D } } } \left[ \operatorname* { m a x } _ { \delta \in S } \mathcal { L } ( x + \delta , y ; \theta ) \right] .
+$$
+
+The resulting saddle point problem can be hard to solve in general. However, it turns out to be often tractable in practice, at least in the context of $\ell _ { p }$ -bounded perturbations (Madry et al., 2017). Specifically, adversarial training corresponds to a natural robust optimization approach to solving this problem (Ben-Tal et al., 2009). In this approach, we repeatedly find the worst-case input perturbations $\delta$ (solving the inner maximization problem), and then update the model parameters to reduce the loss on these perturbed inputs.
+
+Though adversarial training is effective, this success comes with certain drawbacks. The most obvious one is an increase in the training time (we need to compute new perturbations each parameter update step). Another one is the potential need for more training data as shown recently in (Schmidt et al., 2018). These costs make training more demanding, but is that the whole price of being adversarially robust? In particular, if we are willing to pay these costs: Are robust classifiers better than standard ones in every other aspect? This is the key question that motivates our work.
+
+![](images/ba82e0eabc53cb632fccc9b71da16c108a2c986b05d764d2a04eb1c3e2ff408b.jpg)  
+Figure 1: Comparison of the standard accuracy of models trained against an $\ell _ { 2 }$ -bounded adversary as a function of size of the training dataset. We observe that when training with few samples, adversarial training has a positive effect on model generalization (especially on MNIST). However, as training data increase, the standard accuracy of robust models drops below that of the standard model $( \varepsilon _ { t r a i n } = 0 )$ ). Similar results for $\ell _ { \infty }$ trained networks are shown in Figure 6 of Appendix G.
+
+Adversarial Training as a Form of Data Augmentation Our point of start is a popular view of adversarial training as the “ultimate” form of data augmentation. According to this view, the adversarial perturbation set $\Delta$ is seen as the set of invariants that a good model should satisfy (regardless of the adversarial robustness considerations). Thus, finding the worst-case $\delta$ corresponds to augmenting the training data in the “most confusing” and thus also “most helpful” manner. A key implication of this view is that adversarial training should be beneficial for the standard accuracy of a model (Torkamani & Lowd, 2013; 2014; Goodfellow et al., 2014b; Miyato et al., 2018).
+
+Indeed, in Figure 1, we see this effect, when classifiers are trained with relatively few samples (particularly on MNIST). In this setting, the amount of training data available is insufficient to learn a good standard classifier and the set of adversarial perturbations used is “compatible” with the learning task. (That is, good standard models for this task need to be also somewhat invariant to these perturbations.) In such regime, robust training does indeed act as data augmentation, regularizing the model and leading to a better solution (from standard accuracy point of view). (Note that this effect seems less pronounced for CIFAR-10, possibly because $\ell _ { p }$ -invariance is not as important for a good standard CIFAR-10 classifier.)
+
+Surprisingly however, in Figure 6 we see that as we include more samples in the training set, this positive effect becomes less significant. In fact, after some point adversarial training actually decreases the standard accuracy. In Figure 7 in Appendix G we study the behaviour of models trained using adversarial training with different $\ell _ { p }$ -bounded adversaries. We observe a steady decline in standard accuracy as the strength of the adversary increases. (Note that this still holds if we train on batches that also contain natural examples, as in Kurakin et al. (2016a). See Appendix B.) Similar effects were also observed in prior work (Kurakin et al., 2016b; Madry et al., 2017; Dvijotham et al., 2018b; Wong et al., 2018; Xiao et al., 2018b; Su et al., 2018; Babbar & Schölkopf, 2018).
+
+The goal of this work is to illustrate and explain the roots of this phenomenon. In particular, we would like to understand:
+
+# Why does there seem to be a trade-off between standard and adversarially robust accuracy?
+
+As we will show, this effect is not an artifact of our adversarial training methods but in fact is inevitable consequence of different goals of adversarial robustness and standard generalization.
+
+As we discussed above, we often observe that employing adversarial training leads to a decrease in a model’s standard accuracy. In what follows, we show that this phenomenon is a manifestation of an inherent tension between standard accuracy and adversarially robust accuracy. In particular, we present a theoretical model that demonstrates it. In fact, this phenomenon can be illustrated in a fairly simple setting which suggests that it is quite prevalent.
+
+Our binary classification task Our data model consists of input-label pairs $( x , y )$ sampled from a distribution $\mathcal { D }$ as follows:
+
+$$
+y \overset { u . a . r } { \sim } \{ - 1 , + 1 \} , \qquad x _ { 1 } = \left\{ \begin{array} { l l } { { + y , } } & { { \mathrm { w . p . ~ } p } } \\ { { - y , } } & { { \mathrm { w . p . ~ } 1 - p } } \end{array} , \right. \qquad x _ { 2 } , \ldots , x _ { d + 1 } \overset { i . i . d } { \sim } \mathcal { N } ( \eta y , 1 ) ,
+$$
+
+where ${ \mathcal { N } } ( \mu , \sigma ^ { 2 } )$ is a normal distribution with mean $\mu$ and variance $\sigma ^ { 2 }$ , and $p \geq 0 . 5$ . We chose $\eta$ to be large enough so that a simple classifier attains high standard accuracy $( > 9 9 \% )$ ) – e.g. $\eta = \Theta ( 1 / \sqrt { d } )$ will suffice. The parameter $p$ quantifies how correlated the feature $x _ { 1 }$ is with the label. For the sake of example, we can think of $p$ as being 0.95. This choice is fairly arbitrary; the trade-off between standard and robust accuracy will be qualitatively similar for any $p < 1$ .
+
+Standard classification is easy Note that samples from $\mathcal { D }$ consist of a single feature that is moderately correlated with the label and $d$ other features that are only very weakly correlated with it. Despite the fact that each one of the latter type of features individually is hardly predictive of the correct label, this distribution turns out to be fairly simple to classify from a standard accuracy perspective. Specifically, a natural (linear) classifier
+
+$$
+f _ { \mathrm { a v g } } ( x ) : = \mathrm { s i g n } ( w _ { \mathrm { u n i f } } ^ { \top } x ) , \quad \mathrm { ~ w h e r e ~ } w _ { \mathrm { u n i f } } : = \left[ 0 , \frac { 1 } { d } , \ldots , \frac { 1 } { d } \right] ,
+$$
+
+achieves standard accuracy arbitrarily close to $1 0 0 \%$ , for $d$ large enough. Indeed, observe that
+
+$$
+\operatorname* { P r } [ f _ { \mathrm { a v g } } ( x ) = y ] = \operatorname* { P r } [ \mathrm { s i g n } ( w _ { \mathrm { u n i f } } x ) = y ] = \operatorname* { P r } \left[ { \frac { y } { d } } \sum _ { i = 1 } ^ { d } { \mathcal { N } } ( \eta y , 1 ) > 0 \right] = \operatorname* { P r } \left[ { \mathcal { N } } \left( \eta , { \frac { 1 } { d } } \right) > 0 \right] ,
+$$
+
+which is $> 9 9 \%$ when $\eta \geq 3 / \sqrt { d }$ .
+
+Adversarially robust classification Note that in our discussion so far, we effectively viewed the average of $x _ { 2 } , \ldots , x _ { d + 1 }$ as a single “meta-feature” that is highly correlated with the correct label. For a standard classifier, any feature that is even slightly correlated with the label is useful. As a result, a standard classifier will take advantage (and thus rely on) the weakly correlated features $x _ { 2 } , \ldots , x _ { d + 1 }$ (by implicitly pooling information) to achieve almost perfect standard accuracy.
+
+However, this analogy breaks completely in the adversarial setting. In particular, an $\ell _ { \infty }$ -bounded adversary that is only allowed to perturb each feature by a moderate $\varepsilon$ can effectively override the effect of the aforementioned meta-feature. For instance, if $\varepsilon = 2 \eta$ , an adversary can shift each weaklycorrelated feature towards $- y$ . The classifier would now see a perturbed input $x ^ { \prime }$ such that each of the features $x _ { 2 } ^ { \prime } , \ldots , x _ { d + 1 } ^ { \prime }$ are sampled i.i.d. from $\mathcal { N } ( - \eta y , 1 )$ (i.e., now becoming anti-correlated with the correct label). Thus, when $\varepsilon \geq 2 \eta$ , the adversary can essentially simulate the distribution of the weakly-correlated features as if belonging to the wrong class.
+
+Formally, the probability of the meta-feature correctly predicting $y$ in this setting (4) is
+
+$$
+\operatorname* { m i n } _ { \lVert \delta \rVert _ { \infty } \leq \varepsilon } \operatorname* { P r } [ \mathrm { s i g n } ( x + \delta ) = y ] = \operatorname* { P r } \left[ \mathcal { N } ( \eta , 1 ) - \varepsilon > 0 \right] = \operatorname* { P r } \left[ \mathcal { N } \left( - \eta , 1 \right) > 0 \right] .
+$$
+
+As a result, the simple classifier in (4) that relies solely on these features cannot get adversarial accuracy better than $\mathrm { \bar { 1 \% } }$ .
+
+Intriguingly, this discussion draws a distinction between robust features $( x _ { 1 } )$ and non-robust features $( x _ { 2 } , \ldots , x _ { d + 1 } )$ that arises in the adversarial setting. While the meta-feature is far more predictive of the true label, it is extremely unreliable in the presence of an adversary. Hence, a tension between standard and adversarial accuracy arises. Any classifier that aims for high accuracy (say $> 9 9 \%$ ) will have to heavily rely on non-robust features (the robust feature provides only, say, $9 5 \%$ accuracy). However, since the non-robust features can be arbitrarily manipulated, this classifier will inevitably have low adversarial accuracy. We make this formal in the following theorem proved in Appendix C.
+
+Theorem 2.1 (Robustness-accuracy trade-off). Any classifier that attains at least $1 - \delta$ standard accuracy on $\mathcal { D }$ has robust accuracy at most $\textstyle { \frac { p } { 1 - p } } \delta$ against an $\ell _ { \infty }$ -bounded adversary with $\varepsilon \geq 2 \eta$ .
+
+This bound implies that if $p < 1$ , as standard accuracy approaches $1 0 0 \%$ $\delta  0 ,$ ), adversarial accuracy falls to $0 \%$ . As a concrete example, consider $p = 0 . 9 5$ , then any classifier with standard accuracy more than $1 - \delta$ will have robust accuracy at most $1 9 \delta ^ { 1 }$ . Also it is worth noting that the theorem is tight. If $\delta = 1 - p$ , both the standard and adversarial accuracies are bounded by $p$ which is attained by the classifier that relies solely on the first feature. Additionally, note that compared to the scale of the features $\pm 1$ , the value of √ $\varepsilon$ required to manipulate the standard classifier is very small $( \varepsilon = O ( \eta )$ , where $\eta = O ( 1 / { \sqrt { d } } ) ;$ .
+
+On the (non-)existence of an accurate and robust classifier It might be natural to expect that in the regime of infinite data, the standard classifier itself acts as a robust classifier. Note however, that this is not true for the setting we analyze above. Here, the trade-off between standard and adversarial accuracy is an inherent trait of the data distribution itself and not due to having insufficient samples. In this particular classification task, we (implicitly) assumed that there does not exist a classifier that is both robust and very accurate (i.e. $> 9 9 \%$ standard and robust accuracy). Thus, for this task, any classifier that is very accurate (including the Bayes classifier – the classifier minimizing classification error having full-information about the distribution) will necessarily be non-robust.
+
+This seemingly goes against the common assumption in adversarial ML that humans are such perfect robust and accurate classifiers for standard datasets. However, note that there is no concrete evidence supporting this assumption. In fact, humans often have far from perfect performance in vision benchmarks (Karpathy, 2011; 2014; Russakovsky et al., 2015) and are outperformed by ML models in certain tasks (He et al., 2015b; Gastaldi, 2017). It is plausible that standard ML models are able to outperform humans in these tasks by relying on brittle features that humans are naturally invariant to and the observed decrease in performance might be the manifestation of that.
+
+# 2.2 THE IMPORTANCE OF ADVERSARIAL TRAINING
+
+As we have seen in the distributional model $\mathcal { D }$ (3), a classifier that achieves very high standard accuracy (1) will inevitably have near-zero adversarial accuracy. This is true even when a classifier with reasonable standard and robust accuracy exists. Hence, in an adversarial setting (2), where the goal is to achieve high adversarial accuracy, the training procedure needs to be modified. We now make this phenomenon concrete for linear classifiers trained using the soft-margin SVM loss. Specifically, in Appendix D we prove the following theorem.
+
+Theorem 2.2 (Adversarial training matters). For $\eta \geq 4 / \sqrt { d }$ and $p \leq 0 . 9 7 5$ (the first feature is not perfect), a soft-margin SVM classifier of unit weight norm minimizing the distributional loss achieves a standard accuracy of $> 9 9 \%$ and adversarial accuracy of $\textless 1 \%$ against an $\ell _ { \infty }$ -bounded adversary of $\varepsilon \geq 2 \eta$ . Minimizing the distributional adversarial loss instead leads to a robust classifier that has standard and adversarial accuracy of p against any $\varepsilon < 1$ .
+
+This theorem shows that if our focus is on robust models, adversarial training is crucial to achieve non-trivial adversarial accuracy in this setting. Simply optimizing the standard accuracy of the model (i.e. standard training) leads to poor robust accuracy. Soft-margin SVM classifiers and the constant 0.975 are chosen for mathematical convenience. Our proofs do not depend on them in a crucial way and can be adapted, in a straightforward manner, to other natural settings, e.g. logistic regression.
+
+Transferability An interesting implication of our analysis is that standard training produces classifiers that rely on features that are weakly correlated with the correct label. This will be true for any classifier trained on the same distribution. Hence, the adversarial examples that are created by perturbing each feature in the direction of $- y$ will transfer across classifiers trained on independent samples from the distribution. This constitutes an interesting manifestation of the generally observed phenomenon of transferability (Szegedy et al., 2013) and might hint at its origin.
+
+![](images/a606cea45104d344c4fdc44fcb80fc5e9792a314e798173bdd8bdf396b64bd69.jpg)  
+Figure 2: Visualization of the loss gradient with respect to input pixels. Recall that these gradients highlight the input features which affect the loss most strongly, and thus are important for the classifier’s prediction. We observe that the gradients are significantly more interpretable for adversarially trained networks – they align well with perceptually relevant features. In contrast, for standard networks they appear very noisy. We observe that gradients of $\ell _ { \infty }$ -trained models tend to be sparser than those of $\ell _ { 2 }$ -trained models. (For MNIST, blue and red pixels denote positive and negative gradient regions respectively. For CIFAR-10 and ImageNet, we clip gradients to within $\pm 3 \sigma$ and rescale them to lie in the [0, 1] range.) Additional visualizations are in Figure 10 of Appendix G.
+
+Empirical examination In Section 2.1, we showed that the trade-off between standard accuracy and robustness might be inevitable. To examine how representative our theoretical model is of real-world datasets, we also experimentally investigate this issue on MNIST (LeCun et al., 1998) as it is amenable to linear classifiers. Interestingly, we observe a qualitatively similar behavior. For instance, in Figure 5(b) in Appendix E, we see that the standard classifier assigns weight to even weakly-correlated features. (Note that in settings with finite training data, such brittle features could arise even from noise – see Appendix E.) The robust classifier on the other hand does not assign any weight beyond a certain threshold. Further, we find that it is possible to obtain a robust classifier by directly training a standard model using only features that are relatively well-correlated with the label (without adversarial training). As expected, as more features are incorporated into the training, the standard accuracy is improved at the cost of robustness (see Appendix E Figure 5(c)).
+
+# 3 UNEXPECTED BENEFITS OF ADVERSARIAL ROBUSTNESS
+
+In Section 2, we established that robust and standard models might depend on very different sets of features. We demonstrated how this can lead to a decrease in standard accuracy for robust models. In this section, we will argue that the features learned by robust models can also be beneficial.
+
+At a high level, robustness to adversarial perturbations can be viewed as an invariance property of a model. A model that achieves small loss for all perturbations in the set $\Delta$ , will necessarily have learned features that are invariant to such perturbations. Thus, robust training can be viewed as a method to embed certain invariances in a model. Since we also expect humans to be invariant to these perturbations (e.g. small $\ell _ { p }$ -bounded changes of the pixels), robust models will be more aligned with human vision than standard models. In this section, we present evidence supporting the view.
+
+Loss gradients in the input space align well with human perception As a starting point, we want to investigate which features of the input most strongly affect the prediction of the classifier both for standard and robust models. To this end, we visualize the gradients of the loss with respect to individual features (pixels) of the input in Figure 2. We observe that gradients for adversarially trained networks align well with perceptually relevant features (such as edges) of the input image. In contrast, for standard networks, these gradients have no coherent patterns and appear very noisy to humans. We want to emphasize that no preprocessing was applied to the gradients (other than scaling and clipping for visualization). On the other hand, extraction of interpretable information from the gradients of standard networks has so far only been possible using additional sophisticated techniques (Simonyan et al., 2013; Yosinski et al., 2015; Olah et al., 2017).
+
+![](images/339002471b054e95c8d1749c22777fc38cd56bddaa6d4e22f0dbd0be1c96a5e8.jpg)  
+Figure 3: Visualizing large- $\varepsilon$ adversarial examples for standard and robust $( \ell _ { 2 } / \ell _ { \infty }$ -adversarial training) models. We construct these examples by iteratively following the (negative) loss gradient while staying with $\ell _ { 2 }$ -distance of $\varepsilon$ from the original image. We observe that the images produced for robust models effectively capture salient data characteristics and appear similar to examples of a different class. (The value of $\varepsilon$ is equal for all models and much larger than the one used for training.) Additional examples are visualized in Figure 8 and 9 of Appendix G.
+
+This observation effectively outlines an approach to train models that align better with human perception by design. By encoding the correct prior into the set of perturbations $\Delta$ , adversarial training alone might be sufficient to yield interpretable gradients. We believe that this phenomenon warrants an in-depth investigation and we view our experiments as only exploratory.
+
+Adversarial examples exhibit salient data characteristics Given how the gradients of standard and robust models are concentrated on qualitatively different input features, we want to investigate how the adversarial examples of these models appear visually. To find adversarial examples, we start from a given test image and apply Projected Gradient Descent (PGD; a standard first-order optimization method) to find the image of highest loss within an $\ell _ { p }$ -ball of radius $\varepsilon$ around the original image 2. This procedure will change the pixels that are most influential for a particular model’s predictions and thus hint towards how the model is making its predictions.
+
+The resulting visualizations are presented in Figure 3 (details in Appendix A). Surprisingly, we can observe that adversarial perturbations for robust models tend to produce salient characteristics of another class. In fact, the corresponding adversarial examples for robust models can often be perceived as samples from that class. This behavior is in stark contrast to standard models, for which adversarial examples appear as noisy variants of the input image.
+
+These findings provide additional evidence that adversarial training does not necessarily lead to gradient obfuscation (Athalye et al., 2018). Following the gradient changes the image in a meaningful way and (eventually) leads to images of different classes. Hence, the robustness of these models does not stem from having gradients that are ill-suited for first-order methods.
+
+Smooth cross-class interpolations via gradient descent By linearly interpolating between the original image and the image produced by PGD we can produce a smooth, “perceptually plausible” interpolation between classes (Figure 4). Such interpolation have thus far been restricted to generative models such as GANs (Goodfellow et al., 2014a) and VAEs (Kingma & Welling, 2013), involved manipulation of learned representations (Upchurch et al., 2016), and hand-designed methods (Suwajanakorn et al., 2015; Kemelmacher-Shlizerman, 2016). In fact, we conjecture that the similarity of these inter-class trajectories to GAN interpolations is not a coincidence. We postulate that the saddle point problem that is key in both these approaches may be at the root of this effect. We hope that future research will investigate this connection further and explore how to utilize the loss landscape of robust models as an alternative method to smoothly interpolate between classes.
+
+![](images/2597fe143c29a132037adead882a1a1016e5b9d9bcb60c2dff641c5d7cb82e9c.jpg)  
+Figure 4: Interpolation between original image and large- $\varepsilon$ adversarial example as in Figure 3.
+
+# 4 RELATED WORK
+
+Due to the large body of related work, we will only focus on the most relevant studies here and defer the full discussion to Appendix F. Fawzi et al. (2018b) prove upper bounds on the robust of classifiers and exhibit a standard vs. robust accuracy trade-off for a specific classifier families on a synthetic task. Their setting also (implicitly) utilizes the notion of robust and non-robust features, however these features have small magnitude rather than weak correlation. Ross & Doshi-Velez (2017) propose regularizing the gradient of the classifier with respect to its input. They find that the resulting classifiers have more interpretable gradients and targeted adversarial examples resemble the target class for digit and character recognition tasks. There has been recent of work proving upper bounds on classifier robustness (Gilmer et al., 2018; Schmidt et al., 2018; Fawzi et al., 2018a). However, this work is orthogonal to ours as in these settings there exist classifiers that are both robust and accurate.
+
+# 5 CONCLUSIONS AND FUTURE DIRECTIONS
+
+In this work, we show that the goal of adversarially robust generalization might fundamentally be at odds with that of standard generalization. Specifically, we identify an inherent trade-off between the standard accuracy and adversarial robustness of a model, that provably manifests in a concrete, simple setting. This trade-off stems from intrinsic differences between the feature learned by standard and robust models. Our analysis also explains the drop in standard accuracy observed when employing adversarial training in practice. Moreover, it emphasizes the need to develop robust training methods, since robustness is unlikely to arise as a consequence of standard training.
+
+We discover that even though adversarial robustness comes at a price, it has some unexpected benefits. Robust models learn features that align well with salient data characteristics. The root of this phenomenon is that the set of adversarial perturbations encodes some prior for human perception. Thus, classifiers that are robust to these perturbations are also necessarily invariant to input modifications that we expect humans to be invariant to. We demonstrate a striking consequence of this phenomenon: robust models yield clean feature interpolations similar to those obtained from generative models such as GANs (Goodfellow et al., 2014b). This emphasizes the possibility of a stronger connection between GANs and adversarial robustness.
+
+Finally, our findings show that the interplay between adversarial robustness and standard classification might be more nuanced that one might expect. This motivates further work to fully undertand the relative costs and benefits of each of these notions.
+
+# ACKNOWLEDGEMENTS
+
+Shibani Santurkar was supported by the National Science Foundation (NSF) under grants IIS-1447786, IIS-1607189, and CCF-1563880, and the Intel Corporation. Dimitris Tsipras was supported in part by the NSF grant CCF-1553428. Aleksander M ˛adry was supported in part by an Alfred P. Sloan Research Fellowship, a Google Research Award, and the NSF grant CCF-1553428.
+
+# REFERENCES
+
+Tensor flow models repository. https://github.com/tensorflow/models/tree/master/ resnet, 2017.   
+Anish Athalye, Logan Engstrom, Andrew Ilyas, and Kevin Kwok. Synthesizing robust adversarial examples. arXiv preprint arXiv:1707.07397, 2017.   
+Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. arXiv preprint arXiv:1802.00420, 2018.   
+Rohit Babbar and Bernhard Schölkopf. Adversarial extreme multi-label classification. arXiv preprint arXiv:1803.01570, 2018.   
+Aharon Ben-Tal, Laurent El Ghaoui, and Arkadi Nemirovski. Robust optimization. Princeton University Press, 2009.   
+Battista Biggio and Fabio Roli. Wild patterns: Ten years after the rise of adversarial machine learning. arXiv preprint arXiv:1712.03141, 2017.   
+Sébastien Bubeck, Eric Price, and Ilya Razenshteyn. Adversarial examples from computational constraints. arXiv preprint arXiv:1805.10204, 2018.   
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. arXiv preprint arXiv:1608.04644, 2016.   
+Nicholas Carlini and David Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. arXiv preprint arXiv:1705.07263, 2017.   
+Nilesh Dalvi, Pedro Domingos, Mausam, Sumit Sanghai, and Deepak Verma. Adversarial classification. In International Conference on Knowledge Discovery and Data Mining (KDD), 2004.   
+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.   
+Krishnamurthy Dvijotham, Sven Gowal, Robert Stanforth, Relja Arandjelovic, Brendan O’Donoghue, Jonathan Uesato, and Pushmeet Kohli. Training verified learners with learned verifiers. arXiv preprint arXiv:1805.10265, 2018a.   
+Krishnamurthy Dvijotham, Robert Stanforth, Sven Gowal, Timothy Mann, and Pushmeet Kohli. A dual approach to scalable verification of deep networks. arXiv preprint arXiv:1803.06567, 2018b.   
+Logan Engstrom, Dimitris Tsipras, Ludwig Schmidt, and Aleksander Madry. A rotation and a translation suffice: Fooling cnns with simple transformations. arXiv preprint arXiv:1712.02779, 2017.   
+Ivan Evtimov, Kevin Eykholt, Earlence Fernandes, Tadayoshi Kohno, Bo Li, Atul Prakash, Amir Rahmati, and Dawn Song. Robust physical-world attacks on machine learning models. arXiv preprint arXiv:1707.08945, 2017.
+
+Alhussein Fawzi and Pascal Frossard. Manitest: Are classifiers really invariant? In British Machine Vision Conference (BMVC), number EPFL-CONF-210209, 2015.
+
+Alhussein Fawzi, Seyed-Mohsen Moosavi-Dezfooli, and Pascal Frossard. Robustness of classifiers: from adversarial to random noise. In Advances in Neural Information Processing Systems, pp. 1632–1640, 2016.
+
+Alhussein Fawzi, Hamza Fawzi, and Omar Fawzi. Adversarial vulnerability for any classifier. arXiv preprint arXiv:1802.08686, 2018a.
+
+Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Analysis of classifiers’ robustness to adversarial perturbations. Machine Learning, 107(3):481–508, 2018b.
+
+Xavier Gastaldi. Shake-shake regularization. arXiv preprint arXiv:1705.07485, 2017.
+
+Justin Gilmer, Luke Metz, Fartash Faghri, Samuel S Schoenholz, Maithra Raghu, Martin Wattenberg, and Ian Goodfellow. Adversarial spheres. arXiv preprint arXiv:1801.02774, 2018.
+
+Ian Goodfellow. Adversarial examples. Presentation at Deep Learning Summer School, 2015. http:// videolectures.net/deeplearning2015_goodfellow_adversarial_examples/.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014a.
+
+Ian J. Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014b.
+
+Alex Graves, Abdel-rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In Acoustics, speech and signal processing (icassp), 2013 ieee international conference on, pp. 6645–6649. IEEE, 2013.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. corr abs/1512.03385 (2015), 2015a.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE international conference on computer vision, pp. 1026–1034, 2015b.
+
+Andrej Karpathy. Lessons learned from manually classifying cifar-10. http://karpathy.github.io/ 2011/04/27/manually-classifying-cifar10/, 2011. Accessed: 2018-09-23.
+
+Andrej Karpathy. What I learned from competing against a ConvNet on ImageNet. http://karpathy.github.io/2014/09/02/ what-i-learned-from-competing-against-a-convnet-on-imagenet/, 2014. Accessed: 2018-09-23.
+
+Ira Kemelmacher-Shlizerman. Transfiguring portraits. ACM Transactions on Graphics (TOG), 35(4):94, 2016.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+J Zico Kolter and Eric Wong. Provable defenses against adversarial examples via the convex outer adversarial polytope. arXiv preprint arXiv:1711.00851, 2017.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016a.
+
+Alexey Kurakin, Ian J. Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016b.
+
+Yann LeCun, Corinna Cortes, and Christopher J.C. Burges. The mnist database of handwritten digits. Website, 1998. URL http://yann.lecun.com/exdb/mnist/.
+
+Yann LeCun, Corinna Cortes, and CJ Burges. Mnist handwritten digit database. AT&T Labs [Online]. Available: http://yann. lecun. com/exdb/mnist, 2, 2010.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Takeru Miyato, Shin-ichi Maeda, Shin Ishii, and Masanori Koyama. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence, 2018.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: A simple and accurate method to fool deep neural networks. In 2016 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2016, Las Vegas, NV, USA, June 27-30, 2016, pp. 2574–2582, 2016.
+
+Anh Mai Nguyen, Jason Yosinski, and Jeff Clune. Deep neural networks are easily fooled: High confidence predictions for unrecognizable images. In IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2015, Boston, MA, USA, June 7-12, 2015, pp. 427–436, 2015.
+
+Chris Olah, Alexander Mordvintsev, and Ludwig Schubert. Feature visualization. Distill, 2017. doi: 10.23915/ distill.00007. https://distill.pub/2017/feature-visualization.
+
+Aditi Raghunathan, Jacob Steinhardt, and Percy Liang. Certified defenses against adversarial examples. arXiv preprint arXiv:1801.09344, 2018.
+
+Andrew Slavin Ross and Finale Doshi-Velez. Improving the adversarial robustness and interpretability of deep neural networks by regularizing their input gradients. arXiv preprint arXiv:1711.09404, 2017.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115(3):211–252, 2015. doi: 10.1007/s11263-015-0816-y.
+
+Ludwig Schmidt, Shibani Santurkar, Dimitris Tsipras, Kunal Talwar, and Aleksander M ˛adry. Adversarially robust generalization requires more data. arXiv preprint arXiv:1804.11285, 2018.
+
+Mahmood Sharif, Sruti Bhagavatula, Lujo Bauer, and Michael K. Reiter. Accessorize to a crime: Real and stealthy attacks on state-of-the-art face recognition. In Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, Vienna, Austria, October 24-28, 2016, pp. 1528–1540, 2016.
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484–489, 2016.
+
+Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. arXiv preprint arXiv:1312.6034, 2013.
+
+Aman Sinha, Hongseok Namkoong, and John Duchi. Certifiable distributional robustness with principled adversarial training. arXiv preprint arXiv:1710.10571, 2017.
+
+Dong Su, Huan Zhang, Hongge Chen, Jinfeng Yi, Pin-Yu Chen, and Yupeng Gao. Is robustness the cost of accuracy?–a comprehensive study on the robustness of 18 deep image classification models. arXiv preprint arXiv:1808.01688, 2018.
+
+Supasorn Suwajanakorn, Steven M Seitz, and Ira Kemelmacher-Shlizerman. What makes tom hanks look like tom hanks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3952–3960, 2015.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian J. Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Vincent Tjeng and Russ Tedrake. Verifying neural networks with mixed integer programming. arXiv preprint arXiv:1711.07356, 2017.
+
+Mohamad Ali Torkamani and Daniel Lowd. On robustness and regularization of structural support vector machines. In International Conference on Machine Learning, pp. 577–585, 2014.
+
+MohamadAli Torkamani and Daniel Lowd. Convex adversarial collective classification. In International Conference on Machine Learning, pp. 642–650, 2013.
+
+Jonathan Uesato, Brendan O’Donoghue, Aaron van den Oord, and Pushmeet Kohli. Adversarial risk and the dangers of evaluating against weak attacks. arXiv preprint arXiv:1802.05666, 2018.   
+Paul Upchurch, Jacob Gardner, Geoff Pleiss, Robert Pless, Noah Snavely, Kavita Bala, and Kilian Weinberger. Deep feature interpolation for image content changes. arXiv preprint arXiv:1611.05507, 2016.   
+Yizhen Wang, Somesh Jha, and Kamalika Chaudhuri. Analyzing the robustness of nearest neighbors to adversarial examples. arXiv preprint arXiv:1706.03922, 2017.   
+Eric Wong, Frank Schmidt, Jan Hendrik Metzen, and J Zico Kolter. Scaling provable adversarial defenses. arXiv preprint arXiv:1805.12514, 2018.   
+Yuxin Wu et al. Tensorpack. https://github.com/tensorpack/, 2016.   
+Chaowei Xiao, Jun-Yan Zhu, Bo Li, Warren He, Mingyan Liu, and Dawn Song. Spatially transformed adversarial examples. arXiv preprint arXiv:1801.02612, 2018a.   
+Kai Y Xiao, Vincent Tjeng, Nur Muhammad Shafiullah, and Aleksander Madry. Training for faster adversarial robustness verification via inducing relu stability. arXiv preprint arXiv:1809.03008, 2018b.   
+Huan Xu and Shie Mannor. Robustness and generalization. Machine learning, 86(3):391–423, 2012.   
+Jason Yosinski, Jeff Clune, Anh Nguyen, Thomas Fuchs, and Hod Lipson. Understanding neural networks through deep visualization. arXiv preprint arXiv:1506.06579, 2015.
+
+# A EXPERIMENTAL SETUP
+
+# A.1 DATASETS
+
+We perform our experimental analysis on the MNIST (LeCun et al., 2010), CIFAR-10 (Krizhevsky & Hinton, 2009) and (restricted) ImageNet (Deng et al., 2009) datasets. For binary classification, we filter out all the images from the MNIST dataset other than the “5” and “7” labelled examples. For the ImageNet dataset, adversarial training is significantly harder since the classification problem is challenging by itself and standard classifiers are already computationally expensive to train. We thus restrict our focus to a smaller subset of the dataset. We group together a subset of existing, semantically similar ImageNet classes into 8 different super-classes, as shown in Table 1. We train and evaluate only on examples corresponding to these classes.
+
+Table 1: Classes used in the Restricted ImageNet model. The class ranges are inclusive.   
+
+<table><tr><td>Class</td><td>Corresponding ImageNet Classes</td></tr><tr><td>“Dog”</td><td>151 to 268</td></tr><tr><td>“Cat”</td><td>281 to 285</td></tr><tr><td>“Frog”</td><td>30 to 32</td></tr><tr><td>“Turtle”</td><td>33 to 37</td></tr><tr><td>“Bird”</td><td>80 to 100</td></tr><tr><td>&quot;Primate”</td><td>365 to 382</td></tr><tr><td>“Fish”</td><td>389 to 397</td></tr><tr><td>“Crab”</td><td>118 to 121</td></tr><tr><td>&quot;Insect”</td><td>300 to 319</td></tr></table>
+
+# A.2 MODELS
+
+• Binary MNIST (Section 2.2): We train a linear classifier with parameters $w \in \mathbb { R } ^ { 7 8 4 } , b \in \mathbb { R }$ on the dataset described in Section A.1 (labels $- 1$ and $+ 1$ correspond to images labelled as “5” and “7” respectively). We use the cross-entropy loss and perform 100 epochs of gradient descent in training.
+
+• MNIST: We use the simple convolution architecture from the TensorFlow tutorial (TFM, 2017) 3.   
+• CIFAR-10: We consider a standard ResNet model (He et al., 2015a). It has 4 groups of residual layers with filter sizes (16, 16, 32, 64) and 5 residual units each 4.   
+• Restricted ImageNet: We use a ResNet-50 (He et al., 2015a) architecture using the code from the tensorpack repository (Wu et al., 2016). We do not modify the model architecture, and change the training procedure only by changing the number of examples per “epoch” from 1,280,000 images to 76,800 images.
+
+# A.3 ADVERSARIAL TRAINING
+
+We perform adversarial training to train robust classifiers following Madry et al. (2017). Specifically, we train against a projected gradient descent (PGD) adversary, starting from a random initial perturbation of the training data. We consider adversarial perturbations in $\ell _ { p }$ norm where $p = \{ 2 , \infty \}$ . Unless otherwise specified, we use the values of $\varepsilon$ provided in Table 2 to train/evaluate our models.
+
+Table 2: Value of $\varepsilon$ used for adversarial training/evaluation of each dataset and $\ell _ { p }$ -norm.   
+
+<table><tr><td>Adversary</td><td>Binary MNIST</td><td>MNIST</td><td>CIFAR-10</td><td>Restricted Imagenet</td></tr><tr><td>l8</td><td>0.2</td><td>0.3</td><td>4/255</td><td>0.005</td></tr><tr><td>l</td><td>1</td><td>1.5</td><td>0.314</td><td>1</td></tr></table>
+
+# A.4 ADVERSARIAL EXAMPLES FOR LARGE ε
+
+The images we generated for Figure 3 were allowed a much larger perturbation from the original sample in order to produce visible changes to the images. These values are listed in Table 3. Since
+
+Table 3: Value of $\varepsilon$ used for large- $\varepsilon$ adversarial examples of Figure 3.   
+
+<table><tr><td>Adversary</td><td>MNIST</td><td>CIFAR-10</td><td>Restricted Imagenet</td></tr><tr><td>l8</td><td>0.3</td><td>0.125</td><td>0.25</td></tr><tr><td>l</td><td>4</td><td>4.7</td><td>40</td></tr></table>
+
+these levels of perturbations would allow to truly change the class of the image, training against such strong adversaries would be impossible. Still, we observe that smaller values of $\varepsilon$ suffices to ensure that the models rely on the most robust (and hence interpretable) features.
+
+# B MIXING NATURAL AND ADVERSARIAL EXAMPLES IN EACH BATCH
+
+In order to make sure that the standard accuracy drop in Figure 7 is not an artifact of only training on adversarial examples, we experimented with including unperturbed examples in each training batch, following the recommendation of (Kurakin et al., 2016a). We found that while this slightly improves the standard accuracy of the classifier, it decreases it’s robust accuracy by a roughly proportional amount, see Table 4.
+
+# C PROOF OF THEOREM 2.1
+
+The main idea of the proof is that an adversary with $\varepsilon = 2 \eta$ is able to change the distribution of features $x _ { 2 } , \ldots , x _ { d + 1 }$ to reflect a label of $- y$ instead of $y$ by subtracting $\varepsilon y$ from each variable. Hence any information that is used from these features to achieve better standard accuracy can be used by the adversary to reduce adversarial accuracy. We define $G _ { + }$ to be the distribution of $x _ { 2 } , \ldots , x _ { d + 1 }$ when $y = + 1$ and $G _ { - }$ to be that distribution when $y = - 1$ . We will consider the setting where $\varepsilon = 2 \eta$ and fix the adversary that replaces $x _ { i }$ by $x _ { i } - y \varepsilon$ for each $i \geq 2$ . This adversary is able to change $G _ { + }$ to $G _ { - }$ in the adversarial setting and vice-versa.
+
+Table 4: Standard and robust accuracy corresponding to robust training with half natural and half adversarial samples. The accuracies correspond to standard, robust and half-half training.   
+
+<table><tr><td></td><td></td><td colspan="3">Standard Accuracy</td><td colspan="3">Robust Accuracy</td></tr><tr><td>Norm</td><td>m</td><td>Standard</td><td>Half-half</td><td>Robust</td><td>Standard</td><td>Half-half</td><td>Robust</td></tr><tr><td rowspan="7">lo LSINN</td><td></td><td>99.31%</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>0.1</td><td>99.31%</td><td>99.43%</td><td>99.36%</td><td>29.45%</td><td>95.29%</td><td>95.05%</td></tr><tr><td>0.2</td><td>99.31%</td><td>99.22%</td><td>98.99%</td><td>0.05%</td><td>90.79%</td><td>92.86%</td></tr><tr><td>0.3</td><td>99.31%</td><td>99.17%</td><td>97.37%</td><td>0.00%</td><td>89.51%</td><td>89.92%</td></tr><tr><td></td><td>99.31%</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>0.5</td><td>99.31%</td><td>99.35%</td><td>99.41%</td><td>94.67%</td><td>97.60%</td><td>97.70%</td></tr><tr><td>1.5</td><td>99.31%</td><td>99.29%</td><td>99.24%</td><td>56.42%</td><td>87.71%</td><td>88.59%</td></tr><tr><td rowspan="5"></td><td>2.5</td><td>99.31%</td><td>99.12%</td><td>97.79%</td><td>46.36%</td><td>60.27%</td><td>63.73%</td></tr><tr><td>0</td><td>92.20%</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>2/255</td><td>92.20%</td><td>90.13%</td><td>89.64%</td><td>0.99%</td><td>69.10%</td><td>69.92%</td></tr><tr><td>4/255</td><td>92.20%</td><td>88.27%</td><td>86.54%</td><td>0.08%</td><td>55.60%</td><td>57.79%</td></tr><tr><td>8/255 0</td><td>92.20%</td><td>84.72%</td><td>79.57%</td><td>0.00%</td><td>37.56%</td><td>41.93%</td></tr><tr><td rowspan="4">l2</td><td></td><td>92.20%</td><td>=</td><td>-</td><td>1</td><td>1</td><td>=</td></tr><tr><td>20/255</td><td>92.20%</td><td>92.04%</td><td>91.77%</td><td>45.60%</td><td>83.94%</td><td>84.70%</td></tr><tr><td>255</td><td>92.20%</td><td>88.95%</td><td>88.38%</td><td>8.80%</td><td>67.29%</td><td>68.69%</td></tr><tr><td>320 /255</td><td>92.20%</td><td>81.74%</td><td>75.75%</td><td>3.30%</td><td>34.45%</td><td>39.76%</td></tr></table>
+
+Consider any classifier $f ( x )$ that maps an input $x$ to a class in $\{ - 1 , + 1 \}$ . Let us fix the probability that this classifier predicts class $+ 1$ for some fixed value of $x _ { 1 }$ and distribution of $x _ { 2 } , \ldots , x _ { d + 1 }$ Concretely, we define $p _ { i j }$ to be the probability of predicting $+ 1$ given that the first feature has sign $i$ and the rest of the features are distributed according to $G _ { j }$ . Formally,
+
+$$
+\begin{array} { l } { { p _ { + + } = \displaystyle \operatorname* { P r } _ { x _ { 2 } , \ldots , d + 1 } \sim G _ { + } ( f ( x ) = + 1 \mid x _ { 1 } = + 1 ) , } } \\ { { p _ { + - } = \displaystyle \operatorname* { P r } _ { x _ { 2 } , \ldots , d + 1 } \sim G _ { - } ( f ( x ) = + 1 \mid x _ { 1 } = + 1 ) , } } \\ { { p _ { - + } = \displaystyle \operatorname* { P r } _ { x _ { 2 } , \ldots , d + 1 } \sim G _ { + } ( f ( x ) = + 1 \mid x _ { 1 } = - 1 ) , } } \\ { { p _ { -- } = \displaystyle \operatorname* { P r } _ { x _ { 2 } , \ldots , d + 1 } \sim G _ { - } ( f ( x ) = + 1 \mid x _ { 1 } = - 1 ) . } } \end{array}
+$$
+
+Using these definitions, we can express the standard accuracy of the classifier as
+
+$$
+\begin{array} { l } { \operatorname* { P r } ( f ( x ) = y ) = \operatorname* { P r } ( y = + 1 ) \left( p \cdot p _ { + + } + ( 1 - p ) \cdot p _ { - + } \right) } \\ { \qquad + \operatorname* { P r } ( y = - 1 ) \left( p \cdot ( 1 - p _ { -- } ) + ( 1 - p ) \cdot ( 1 - p _ { + - } ) \right) } \\ { \qquad = \displaystyle \frac { 1 } { 2 } \left( p \cdot p _ { + + } + ( 1 - p ) \cdot p _ { - + } + p \cdot ( 1 - p _ { -- } ) + ( 1 - p ) \cdot ( 1 - p _ { + - } ) \right) } \\ { \qquad = \displaystyle \frac { 1 } { 2 } \left( p \cdot ( 1 + p _ { + + } - p _ { -- } ) + ( 1 - p ) \cdot ( 1 + p _ { - + } - p _ { + - } ) ) \right) . } \end{array}
+$$
+
+Similarly, we can express the accuracy of this classifier against the adversary that replaces $G _ { + }$ with $G _ { - }$ (and vice-versa) as
+
+$$
+\begin{array} { r l } & { \operatorname* { P r } ( f ( x _ { \mathrm { a d v } } ) = y ) = \operatorname* { P r } ( y = + 1 ) ( p \cdot p _ { + - } + ( 1 - p ) \cdot p _ { -- } ) } \\ & { \qquad + \operatorname* { P r } ( y = - 1 ) ( p \cdot ( 1 - p _ { - + } ) + ( 1 - p ) \cdot ( 1 - p _ { + + } ) ) } \\ & { = \cfrac { 1 } { 2 } ( p \cdot p _ { + - } + ( 1 - p ) \cdot p _ { -- } + p \cdot ( 1 - p _ { - + } ) + ( 1 - p ) \cdot ( 1 - p _ { + + } ) ) } \\ & { = \cfrac { 1 } { 2 } ( p \cdot ( 1 + p _ { + - } - p _ { - + } ) + ( 1 - p ) \cdot ( 1 + p _ { -- } - p _ { + + } ) ) ) . } \end{array}
+$$
+
+For convenience we will define $a = 1 - p _ { + + } + p _ { -- }$ and $b = 1 - p _ { - + } + p _ { + - }$ . Then we can rewrite
+
+$$
+\begin{array} { r l } { { \mathrm { s t a n d a r d ~ a c c u r a c y : ~ } } } & { { \displaystyle \frac { 1 } { 2 } ( p ( 2 - a ) + ( 1 - p ) ( 2 - b ) ) } } \\ { { } } & { { = 1 - \displaystyle \frac { 1 } { 2 } ( p a + ( 1 - p ) b ) , } } \\ { { \mathrm { } } } & { { } } \\ { { \mathrm { ~ d v e r s a r i a l ~ a c c u r a c y : ~ } } } & { { \displaystyle \frac { 1 } { 2 } ( ( 1 - p ) a + p b ) . } } \end{array}
+$$
+
+We are assuming that the standard accuracy of the classifier is at least $1 - \delta$ for some small $\delta$ . This implies that
+
+$$
+1 - \frac 1 2 ( p a + ( 1 - p ) b ) \geq 1 - \delta \implies p a + ( 1 - p ) b \leq 2 \delta .
+$$
+
+Since $p _ { i j }$ are probabilities, we can guarantee that $a \ge 0$ . Moreover, since $p \geq 0 . 5$ , we have $p / ( 1 - \bar { p } ) \geq 1$ . We use these to upper bound the adversarial accuracy by
+
+$$
+\begin{array} { c } { \displaystyle \frac 1 2 ( ( 1 - p ) a + p b ) \leq \frac 1 2 \left( ( 1 - p ) \frac { p ^ { 2 } } { ( 1 - p ) ^ { 2 } } a + p b \right) } \\ { = \displaystyle \frac { p } { 2 ( 1 - p ) } ( p a + ( 1 - p ) b ) } \\ { \leq \displaystyle \frac { p } { 1 - p } \delta . } \end{array}
+$$
+
+# D PROOF OF THEOREM 2.2
+
+We consider the problem of fitting the distribution $\mathcal { D }$ of (3) by using a standard soft-margin SVM classifier. Specifically, this can be formulated as:
+
+$$
+\operatorname* { m i n } _ { w } \mathbb { E } \big [ \operatorname* { m a x } ( 0 , 1 - y w ^ { \top } x ) \big ] + \frac { 1 } { 2 } \lambda \| w \| _ { 2 } ^ { 2 }
+$$
+
+for some value of $\lambda$ . We will assume that we tune $\lambda$ such that the optimal solution $w ^ { * }$ has $\ell _ { 2 }$ -norm of 1. This is without much loss of generality since our proofs can be adapted to the general case. We will refer to the first term of (5) as the margin term and the second term as the regularization term.
+
+First we will argue that, due to symmetry, the optimal solution will assign equal weight to all the features $x _ { i }$ for $i = 2 , \ldots , d + 1$ .
+
+Lemma D.1. Consider an optimal solution $w ^ { * }$ to the optimization problem (5). Then,
+
+$$
+w _ { i } ^ { * } = w _ { j } ^ { * } \forall i , j \in \{ 2 , . . . , d + 1 \} .
+$$
+
+Proof. Assume that $\exists i , j \in \{ 2 , . . . , d + 1 \}$ such that $w _ { i } ^ { * } \neq w _ { j } ^ { * }$ . Since the distribution of $x _ { i }$ and $x _ { j }$ are identical, we can swap the value of $w _ { i }$ and $w _ { j }$ , to get an alternative set of parameters $\hat { w }$ that has the same loss function value ( $\hat { w } _ { j } = w _ { i }$ , $\hat { w } _ { i } = w _ { j }$ , $\hat { w } _ { k } = w _ { k }$ for $k \neq i , j )$ .
+
+Moreover, since the margin term of the loss is convex in $w$ , using Jensen’s inequality, we get that averaging $w ^ { * }$ and $\hat { w }$ will not increase the value of that margin term. Note, however, that $\lVert \frac { w ^ { * } + \hat { w } } { 2 } \rVert _ { 2 } < \lVert w ^ { * } \rVert _ { 2 }$ , hence the regularization loss is strictly smaller for the average point. This contradicts the optimality of $w ^ { * }$ . □
+
+Since every optimal solution will assign equal weight to all √ $x _ { i }$ for $k \geq 2$ , we can replace these features by their sum (and divide by $\sqrt { d }$ for convenience). We will define
+
+$$
+z = \frac { 1 } { \sqrt { d } } \sum _ { i = 2 } ^ { d + 1 } x _ { i } ,
+$$
+
+which, by the properties of the normal distribution, is distributed as
+
+$$
+z \sim \mathcal { N } ( y \eta \sqrt { d } , 1 ) .
+$$
+
+By assigning a weight of $v$ to that combined feature the optimal solutions can be parametrized as
+
+$$
+w ^ { \top } x = w _ { 1 } x _ { 1 } + v z ,
+$$
+
+where the regularization term of the loss is $\lambda ( w _ { 1 } ^ { 2 } + v ^ { 2 } ) / 2$ .
+
+Recall that our chosen value of $\eta$ is $4 / \sqrt { d }$ , which implies that the contribution of $v z$ is distributed normally with mean 4yv and variance $v ^ { 2 }$ . By the concentration of the normal distribution, the probability of $v z$ being larger than $v$ is large. We will use this fact to show that the optimal classifier will assign on $v$ at least as much weight as it assigns on $w _ { 1 }$ .
+
+Lemma D.2. Consider the optimal solution $( w _ { 1 } ^ { * } , v ^ { * } )$ of the problem (5). Then
+
+$$
+v ^ { * } \geq \frac { 1 } { \sqrt { 2 } } .
+$$
+
+Proof. Assume for the sake of contradiction that $v ^ { * } < 1 / \sqrt { 2 }$ . Then, with probability at least $1 - p$ the first feature predicts the wrong label and without enough weight, the remaining features cannot compensate for it. Concretely,
+
+$$
+\begin{array} { r l } & { \mathbb E [ \operatorname* { m a x } ( 0 , 1 - y w ^ { \top } x ) ] \geq ( 1 - p ) \mathbb E \left[ \operatorname* { m a x } \left( 0 , 1 + w _ { 1 } - \mathcal N \left( 4 v , v ^ { 2 } \right) \right) \right] } \\ & { \qquad \geq ( 1 - p ) \mathbb E \left[ \operatorname* { m a x } \left( 0 , 1 + \frac 1 { \sqrt 2 } - \mathcal N \left( \frac 4 { \sqrt 2 } , \frac 1 2 \right) \right) \right] } \\ & { \qquad > ( 1 - p ) \cdot 0 . 0 1 6 . } \end{array}
+$$
+
+We will now show that a solution that assigns zero weight on the first feature $\mathbf { \nabla } _ { v } = 1$ and $w _ { 1 } = 0$ ), achieves a better margin loss.
+
+$$
+\begin{array} { r l } & { \mathbb { E } { [ \operatorname* { m a x } ( 0 , 1 - y w ^ { \top } x ) ] } = \mathbb { E } \left[ \operatorname* { m a x } \left( 0 , 1 - \mathcal { N } \left( 4 , 1 \right) \right) \right] } \\ & { \qquad < 0 . 0 0 0 4 . } \end{array}
+$$
+
+Hence, as long as $p \leq 0 . 9 7 5$ , this solution has a smaller margin loss than the original solution. Since both solutions have the same norm, the solution that assigns weight only on $v$ is better than the original solution $( w _ { 1 } ^ { * } , v ^ { * } )$ , contradicting its optimality. □
+
+We have established that the learned classifier will assign more weight to $v$ than $w _ { 1 }$ . Since $z$ will be at least $y$ with large probability, we will show that the behavior of the classifier depends entirely on $z$
+
+Lemma D.3. The standard accuracy of the soft-margin SVM learned for problem (5) is at least $9 9 \%$
+
+Proof. By Lemma D.2, the classifier predicts the sign of √ $w _ { 1 } x _ { 1 } + v z$ where $v z \sim \mathcal { N } ( 4 y v , v ^ { 2 } )$ and $v \geq 1 / \sqrt { 2 }$ . Hence with probability at least $9 9 \%$ , $v z y > 1 / \sqrt 2 \geq w _ { 1 }$ and thus the predicted class is $y$ (the correct class) independent of $x _ { 1 }$ . □
+
+We can utilize the same argument to show that an adversary that changes the distribution of $z$ has essentially full control over the classifier prediction.
+
+Lemma D.4. The adversarial accuracy of the soft-margin SVM learned for (5) is at most $1 \%$ against an $\ell _ { \infty }$ -bounded adversary of $\varepsilon = 2 \eta$ .
+
+Proof. Observe that the adversary can shift each feature $x _ { i }$ towards $y$ by $2 \eta$ . This will cause $z$ to be distributed as
+
+$$
+z _ { \mathrm { a d v } } \sim \mathcal { N } ( - y \eta \sqrt { d } , 1 ) .
+$$
+
+Therefore with probability at least $9 9 \%$ , $v y z < - y \le - w _ { 1 }$ and the predicted class will be $- y$ (wrong class) independent of $x _ { 1 }$ .
+
+It remains to show that adversarial training for this classification task with $\varepsilon > 2 \eta$ will results in a classifier that has relies solely on the first feature.
+
+Lemma D.5. Minimizing the adversarial variant of the loss (5) results in a classifier that assigns 0 weight to features $x _ { i }$ for $i \geq 2$ .
+
+Proof. The optimization problem that adversarial training solves is
+
+$$
+\operatorname* { m i n } _ { w } \operatorname* { m a x } _ { \| \delta \| _ { \infty } \leq \varepsilon } \mathbb { E } \big [ \operatorname* { m a x } ( 0 , 1 - y w ^ { \top } ( x + \delta ) ) \big ] + \frac { 1 } { 2 } \lambda \| w \| _ { 2 } ^ { 2 } ,
+$$
+
+which is equivalent to
+
+$$
+\operatorname* { m i n } _ { \boldsymbol { w } } \mathbb { E } \big [ \operatorname* { m a x } ( 0 , 1 - { y \boldsymbol { w } } ^ { \top } { \boldsymbol { x } } + \varepsilon \| { \boldsymbol { w } } \| _ { 1 } ) \big ] + \frac { 1 } { 2 } \lambda \| { \boldsymbol { w } } \| _ { 2 } ^ { 2 } .
+$$
+
+Consider any optimal solution $w$ for which $w _ { i } > 0$ for some $i > 2$ . The contribution of terms depending on $w _ { i }$ to $1 - y w ^ { \top } x + \varepsilon \| w \| _ { 1 }$ is a normally-distributed random variable with mean $2 \eta - \varepsilon \leq 0$ . Since the mean is non-positive, setting $w _ { i }$ to zero can only decrease the margin term of the loss. At the same time, setting $w _ { i }$ to zero strictly decreases the regularization term, contradicting the optimality of $w$ . □
+
+Clearly, such a classifier will have standard and adversarial accuracy of $p$ against any $\varepsilon < 1$ since such a value of $\varepsilon$ is not sufficient to change the sign of the first feature. This concludes the proof of the theorem.
+
+# E ROBUSTNESS-ACCURACY TRADE-OFF: AN EMPIRICAL EXAMINATION
+
+Our theoretical analysis shows that there is an inherent tension between standard accuracy and adversarial robustness. At the core of this trade-off is the concept of robust and non-robust features. The robustness of a feature is characterized by the strength of its correlation with the correct label. It is natural to wonder whether this concept of robust features is an artifact of our theoretical analysis or if it manifests more broadly. We thus investigate this issue experimentally on a dataset that is amenable to linear classifiers, MNIST (LeCun et al., 1998) (details in Appendix A).
+
+Recall the goal of standard classification for linear classifiers is to predict accurately, i.e. $y =$ $\mathrm { s i g n } ( w ^ { \top } x )$ . Hence the correlation of a feature $i$ with the true label, computed as $| \mathbb { E } [ y x _ { i } ] |$ , quantifies how useful this feature is for classification. In the adversarial setting, against an $\varepsilon \ell _ { \infty }$ -bounded adversary we need to ensure that $y = \mathrm { s i g n } ( w ^ { \top } x - \varepsilon y \| w \| _ { 1 } )$ . In that case we expect a feature $i$ to be helpful if $| \mathbb { E } [ y x _ { i } ] | \ge \varepsilon$ .
+
+This calculation suggests that in the adversarial setting, there is an implicit threshold on feature correlations imposed by the threat model (the perturbation allowed to the adversary). While standard models may utilize all features with non-zero correlations, a robust model cannot rely on features with correlation below this threshold. In Figure 5(b), we visualize the correlation of each pixel (feature) in the MNIST dataset along with the learned weights of the standard and robust classifiers. As expected, we see that the standard classifier assigns weights even to weakly-correlated pixels so as to maximize prediction confidence. On the other hand, the robust classifier does not assign any weight below a certain correlation threshold which is dictated by the adversary’s strength $\left( \varepsilon \right)$ (Figures 5(a, b))
+
+Interestingly, the standard model assigns non-zero weight even to very weakly correlated pixels (Figure 5(a)). In settings with finite training data, such non-robust features could arise from noise. (For instance, in $N$ tosses of an unbiased coin, the expected imbalance between heads and tails is $O ( { \sqrt { N } } )$ with high probability.) A standard classifier would try to take advantage of even this “hallucinated” information by assigning non-zero weights to these features.
+
+![](images/8a9c400c1bfa1022ac650417e4dbcdce13a0cbfbcbf0c5d3b7c785cd2335f20f.jpg)  
+Figure 5: Analysis of linear classifier trained on a binary MNIST task (5 vs. 7). (Details in Appendix Table 5.) (a) Visualization of network weights per input feature. (b) Comparison of feature-label correlation to the weight assigned to the feature by each network. Adversarially trained networks put weights only on a small number of strongly-correlated or “robust” features. (c) Performance of a model trained using standard training only on the most robust features. Specifically, we sort features based on decreasing correlation with the label and train using only the most correlated ones. Beyond a certain threshold, we observe that as more non-robust or (weakly correlated) features are available to the model, the standard accuracy increases at the cost of robustness.
+
+# E.1 AN ALTERNATIVE PATH TO ROBUSTNESS?
+
+The analysis above highlights an interesting trade-off between the predictive power of a feature and its vulnerability to adversarial perturbations. This brings forth the question – Could we use these insights to train robust classifiers with standard methods (i.e. without performing adversarial training)? As a first step, we train a (standard) linear classifier on MNIST utilizing input features (pixels) that lie above a given correlation threshold (see Figure 5(c)). As expected, as more non robust features are incorporated in training, the standard accuracy increases at the cost of robustness. Further, we observe that a standard classifier trained in this manner using few robust features attains better robustness than even adversarial training. This results suggest a more direct (and potentially better) method of training robust networks in certain settings.
+
+# F ADDITIONAL RELATED WORK
+
+Fawzi et al. (2016) derive parameter-dependent bounds on the robustness of any fixed classifier. Our results focus on the statistical setting itself and provide lower bounds for all classifiers learned in this setting.
+
+Wang et al. (2017) analyze the adversarial robustness of nearest neighbor classifiers. Instead we focus on lower bounds that are inherent to the statistical setting itself and apply to all classifiers.
+
+Schmidt et al. (2018) study the generalization aspect of adversarially robustness. They show that the number of samples needed to achieve adversarially robust generalization is polynomially larger in the dimension than the number of samples needed to ensure standard generalization. However, in the limit of infinite data, one can learn classifiers that are both robust and accurate.
+
+Gilmer et al. (2018) demonstrate a setting where even a small amount of standard error implies that most points provably have a misclassified point close to them. In this setting, achieving perfect standard accuracy (easily achieved by a simple classifier) is sufficient to achieve perfect adversarial robustness. In contrast, our work focuses on a setting where adversarial training (provably) matters and there exists a trade-off between standard and adversarial accuracy.
+
+Xu & Mannor (2012) explore the connection between robustness and generalization, showing that, in a certain sense, robustness can imply generalization. This direction is orthogonal to our, since we work in the limit of infinite data, optimizing the distributional loss directly.
+
+Fawzi et al. (2018a) prove lower bounds on the robustness of any classifier based on certain generative assumptions. Since these bounds apply to all classifiers, independent of architecture and training procedure, they fail to capture the situation we face in practice where robust optimization can significantly improve the adversarial robustness of standard classifiers (Madry et al., 2017; Kolter & Wong, 2017; Raghunathan et al., 2018; Sinha et al., 2017).
+
+A recent work (Bubeck et al., 2018) turns out to (implicitly) rely on the distinction between robust and non-robust features in constructing a distribution for which adversarial robustness is hard from a different, computational point of view.
+
+Goodfellow et al. (2014b) observed that adversarial training results in feature weights that depend on fewer input features (similar to Figure 5(a)). Additionally, it has been observed that for naturally trained RBF classifiers on MNIST, targeted adversarial attacks resemble images of the target class (Goodfellow, 2015).
+
+Su et al. (2018) empirically observe a similar trade-off between the accuracy and robustness of standard models across different deep architectures on ImageNet.
+
+Babbar & Schölkopf (2018) study an extreme multi-label problem and observe that for classes with relatively few examples, $\ell _ { 1 }$ -regularization (which corresponds to adversarial training for linear models) is helpful, while for classes with more samples, it is harmful to the model accuracy.
+
+# G OMITTED FIGURES
+
+Table 5: Comparison of performance of linear classifiers trained on a binary MNIST dataset with standard and adversarial training. The performance of both models is evaluated in terms of standard and adversarial accuracy. Adversarial accuracy refers to the percentage of examples that are correctly classified after being perturbed by the adversary. Here, we use an $\ell _ { \infty }$ threat model with $\varepsilon = 0 . 2 0$ (with images scaled to have coordinates in the range $[ 0 , 1 ] \rangle$ ).   
+
+<table><tr><td></td><td colspan="2">Standard Accuracy (%)</td><td colspan="2">Adversarial Accuracy (%)</td><td>|u|1</td></tr><tr><td></td><td>Train</td><td>Test</td><td>Train</td><td>Test</td><td></td></tr><tr><td>Standard Training</td><td>98.38</td><td>92.10</td><td>13.69</td><td>14.95</td><td>41.08</td></tr><tr><td>Adversarial Training</td><td>94.05</td><td>70.05</td><td>76.05</td><td>74.65</td><td>13.69</td></tr></table>
+
+![](images/957d354e16c984f65b1516ea4b7c51a19fd7f34ade8d87ec8694ca7af3d1a289.jpg)  
+Figure 6: Comparison of standard accuracies of models trained against an $\ell _ { \infty }$ -bounded adversary as a function of the size of the training dataset. We observe that in the low-data regime, adversarial training has an effect similar to data augmentation and helps with generalization in certain cases (particularly on MNIST). However, in the limit of sufficient training data, we see that the standard accuracy of robust models is less than that of the standard model $\mathbf { \bar { \varepsilon } } _ { t r a i n } = 0 ,$ ), which supports the theoretical analysis in Section 2.1.
+
+![](images/0b2b7e56751329b86afd6f10fbc987ae1bfd0803cf303833a4151fe8e5073018.jpg)  
+Figure 7: Standard test accuracy of adversarially trained classifiers. The adversary used during training is constrained within some $\ell _ { p }$ -ball of radius $\varepsilon _ { \mathrm { t r a i n } }$ (details in Appendix A). We observe a consistent decrease in accuracy as the strength of the adversary increases.
+
+![](images/62b5df1c0531806f62241c7a17145fabc1de421e611aed619e37c7b5937ec01f.jpg)  
+Figure 8: Large- $\varepsilon$ adversarial examples, bounded in $\ell _ { \infty }$ -norm, similar to those in Figure 3.
+
+![](images/d93d899be693fdae96a56a4cbb6b5b4ad944a055268d8b29ec27abbed2f30281.jpg)  
+Figure 9: Large- $\varepsilon$ adversarial examples, bounded in $\ell _ { 2 }$ -norm, similar to those in Figure 3.
+
+![](images/82c35561a11b73c421fe67a23906c4628bbd4989ff5ac0435fed6d38118eb9a9.jpg)
+
+# (c) Restricted ImageNet
+
+![](images/d72a28db71bafa5f68d5a906a30b14e090a3c1daf9ba84209bf2a528abfc74ce.jpg)  
+Figure 10: Visualization of the gradient of the loss with respect to input features (pixels) for standard and adversarially trained networks for 10 randomly chosen samples, similar to those in Figure 2. Gradients are significantly more interpretable for adversarially trained networks – they align almost perfectly with perceptually relevant features. For MNIST, blue and red pixels denote positive and negative gradient regions respectively. For CIFAR10 and Restricted ImageNet we clip pixel to 3 standard deviations and scale to [0, 1].

parse/train/_X_4Akcd8Re/_X_4Akcd8Re.md

@@ -0,0 +1,398 @@
+# LEARNING LONG-TERM VISUAL DYNAMICS WITH REGION PROPOSAL INTERACTION NETWORKS
+
+Haozhi Qi UC Berkeley
+
+Xiaolong Wang UC San Diego
+
+Deepak Pathak CMU
+
+Yi Ma UC Berkeley
+
+Jitendra Malik UC Berkeley
+
+# ABSTRACT
+
+Learning long-term dynamics models is the key to understanding physical common sense. Most existing approaches on learning dynamics from visual input sidestep long-term predictions by resorting to rapid re-planning with short-term models. This not only requires such models to be super accurate but also limits them only to tasks where an agent can continuously obtain feedback and take action at each step until completion. In this paper, we aim to leverage the ideas from success stories in visual recognition tasks to build object representations that can capture inter-object and object-environment interactions over a long-range. To this end, we propose Region Proposal Interaction Networks (RPIN), which reason about each object’s trajectory in a latent region-proposal feature space. Thanks to the simple yet effective object representation, our approach outperforms prior methods by a significant margin both in terms of prediction quality and their ability to plan for downstream tasks, and also generalize well to novel environments. Code, pre-trained models, and more visualization results are available at our Website.
+
+# 1 INTRODUCTION
+
+As argued by Kenneth Craik, if an organism carries a model of external reality and its own possible actions within its head, it is able to react in a much fuller, safer and more competent manner to emergencies which face it (Craik, 1952). Indeed, building prediction models has been long studied in computer vision and intuitive physics. In computer vision, most approaches make predictions in pixel-space (Denton & Fergus, 2018; Lee et al., 2018; Ebert et al., 2018b; Jayaraman et al., 2019; Walker et al., 2016), which ends up capturing the optical flow (Walker et al., 2016) and is difficult to generalize to long-horizon. In intuitive physics, a common approach is to learn the dynamics directly in an abstracted state space of objects to capture Newtonian physics (Battaglia et al., 2016; Chang et al., 2016; Sanchez-Gonzalez et al., 2020). However, the states end up being detached from raw sensory perception. Unfortunately, these two extremes have barely been connected. In this paper, we argue for a middle-ground to treat images as a window into the world, i.e., objects exist but can only be accessed via images. Images are neither to be used for predicting pixels nor to be isolated from dynamics. We operationalize it by learning to extract a rich state representation directly from images and build dynamics models using the extracted state representations.
+
+# It is difficult to make predictions, especially about the future — Niels Bohr
+
+Contrary to Niels Bohr, predictions are, in fact, easy if made only for the short-term. Predictions that are indeed difficult to make and actually matter are the ones made over the long-term. Consider the example of “Three-cushion Billiards” in Figure 1. The goal is to hit the cue ball in such a way that it touches the other two balls and contacts the wall thrice before hitting the last ball. This task is extremely challenging even for human experts because the number of successful trajectories is very sparse. Do players perform classical Newtonian physics calculations to obtain the best action before each shot, or do they just memorize the solution by practicing through exponentially many configurations? Both extremes are not impossible, but often impractical. Players rather build a physical understanding by experience (McCloskey, 1983; Kubricht et al., 2017) and plan by making intuitive, yet accurate predictions in the long-term.
+
+Learning such a long-term prediction model is arguably the “Achilles’ heel” of modern machine learning methods. Current approaches on learning physical dynamics of the world cleverly side-step the long-term dependency by re-planning at each step via model-predictive control (MPC) (Allgöwer & Zheng, 2012; Camacho & Alba, 2013). The common practice is to train short-term dynamical models (usually 1-step) in a simulator. However, small errors in short-term predictions can accumulate over time in MPC. Hence, in this work, we focus primarily on the long-term aspect of prediction by just considering environments, such as the three-cushion billiards example or the PHYRE (Bakhtin et al., 2019) in Figure 1, where an agent is allowed to take only one action in the beginning so as to preclude any scope of re-planning.
+
+![](images/5625a4aae9c47f60c1232de28cfa80e4a0cfdaaf5b122056b2355f22deb483f0.jpg)  
+Figure 1: Two example of long-term dynamics prediction tasks. Left: three-cushion billiards. Right: PHYRE intuitive-physics dataset (Bakhtin et al., 2019). Our proposed approach makes accurate long-term predictions that do not necessarily align with the ground truth but provide strong signal for planning.
+
+How to learn an accurate dynamics model has been a popular research topic for years. Recently, there are a series of work trying to represent video frames using object-centric representations (Battaglia et al., 2016; Watters et al., 2017; Chang et al., 2016; Janner et al., 2019; Ye et al., 2019; Kipf et al., 2020). However, those methods either operate in the state space, or ignore the environment information, both of which are not practical in real-world scenarios. In contrast, our objective is to build a data-driven prediction model that can both: (a) model long-term interactions over time to plan successfully for new instances, and (b) work from raw visual input in complex real-world environments. Therefore, the question we ask is: how to extract such an effective and flexible object representation and perform long-term predictions?
+
+We propose Region Proposal Interaction Network (RPIN) which contains two key components. Firstly, we leverage the region of interests pooling (RoIPooling) operator (Girshick, 2015) to extract object features maps from the frame-level feature. Object feature extraction based on region proposals has achieved huge success in computer vision (Girshick, 2015; He et al., 2017; Dai et al., 2017; Gkioxari et al., 2019), and yet, surprisingly under-explored in the field of intuitive physics. By using RoIPooling, each object feature contains not only its own information but also the context of the environment. Secondly, we extend the Interaction Network and propose Convolutional Interaction Networks that perform interaction reasoning on the extracted RoI features. Interaction Networks is originally proposed in (Battaglia et al., 2016), where the interaction reasoning is conducted via MLPs. By changing MLPs to convolutions, we can effectively utilize the spatial information of an object and make accurate future prediction of object location and shapes changes.
+
+Notably, our approach is simple, yet outperforms the state-of-the-art methods in both simulation and real datasets. In Section 5, we thoroughly evaluate our approach across four datasets to study scientific questions related to a) prediction quality, b) generalization to time horizons longer than training, c) generalization to unseen configurations, d) planning ability for downstream tasks. Our method reduces the prediction error by $7 5 \%$ in the complex PHYRE environment and achieves state-of-the-art performance on the PHYRE reasoning benchmark.
+
+# 2 RELATED WORK
+
+Physical Reasoning and Intuitive Physics. Learning models that can predict the changing dynamics of the scene is the key to building physical common-sense. Such models date back to “NeuroAnimator” (Grzeszczuk et al., 1998) for simulating articulated objects. Several methods in recent years have leveraged deep networks to build data-driven models of intuitive physics (Bhattacharyya et al., 2016; Ehrhardt et al., 2017; Fragkiadaki et al., 2015; Chang et al., 2016; Stewart & Ermon, 2017). However, these methods either require access to the underlying ground-truth state-space or do not scale to long-range due to absence of interaction reasoning. A more generic yet explicit approach has been to leverage graph neural networks (Scarselli et al., 2009) to capture interactions between entities in a scene (Battaglia et al., 2018; Chang et al., 2016). Closest to our approach are interaction models that scale to pixels and reason about object interaction (Watters et al., 2017; Ye et al., 2019). However, these approaches either reason about object crops with no context around or can only deal with a predetermined number and order of objects. A concurrent work (Girdhar et al., 2020) studies using prediction for physical reasoning, but their prediction model is either in the state space or in the pixel space.
+
+Other common ways to measure physical understanding are to predict future judgments given a scene image, e.g., predicting the stability of a configuration (Groth et al., 2018; Jia et al., 2015; Lerer et al., 2016; Li et al., 2016a;b). Several hybrid methods take a data-driven approach to estimate Newtonian parameters from raw images (Brubaker et al., 2009; Wu et al., 2016; Bhat et al., 2002; Wu et al., 2015), or model Newtonian physics via latent variable to predict motion trajectory in images (Mottaghi et al., 2016a;b; Ye et al., 2018). An extreme example is to use an actual simulator to do inference over objects (Hamrick et al., 2011). The reliance on explicit Newtonian physics makes them infeasible on real-world data and un-instrumented settings. In contrast, we take into account the context around each object via RoIPooling and explicitly model their interaction with each other or with the environment without relying on Newtonian physics, and hence, easily scalable to real videos for long-range predictions.
+
+Video Prediction. Instead of modeling physics from raw images, an alternative is to treat visual reasoning as an image translation problem. This approach has been adopted in the line of work that falls under video prediction. The most common theme is to leverage latent-variable models for predicting future (Lee et al., 2018; Denton & Fergus, 2018; Babaeizadeh et al., 2017). Predicting pixels is difficult so several methods leverage auxiliary information like back/fore-ground (Villegas et al., 2017a; Tulyakov et al., 2017; Vondrick et al., 2016), optical flow (Walker et al., 2016; Liu et al., 2017), appearance transformation (Jia et al., 2016; Finn et al., 2016; Chen et al., 2017; Xue et al., 2016), etc. These inductive biases help in a short interval but do not capture long-range behavior as needed in several scenarios, like playing billiards, due to lack of explicit reasoning. Some approaches can scale to relative longer term but are domain-specific, e.g., pre-defined human-pose space (Villegas et al., 2017b; Walker et al., 2017). However, our goal is to model long-term interactions not only for prediction but also to facilitate planning for downstream tasks.
+
+Learning Dynamics Models. Unlike video prediction, dynamics models take actions into account for predicting the future, also known as forward models (Jordan & Rumelhart, 1992). Learning these forward dynamics models from images has recently become popular in robotics for both specific tasks (Wahlström et al., 2015; Agrawal et al., 2016; Oh et al., 2015; Finn et al., 2016) and exploration (Pathak et al., 2017; Burda et al., 2019). In contrast to these methods where a deep network directly predicts the whole outcome, we leverage our proposed region-proposal interaction module to capture each object trajectories explicitly to learn long-range forward dynamics as well as video prediction models.
+
+Planning via Learned Models. Leveraging models to plan is the standard approach in control for obtaining task-specific behavior. Common approach is to re-plan after each action via Model Predictive Control (Allgöwer & Zheng, 2012; Camacho & Alba, 2013; Deisenroth & Rasmussen, 2011). Scaling the models and planning in a high dimensional space is a challenging problem. With deep learning, several approaches shown promising results on real-world robotic tasks (Finn et al., 2016; Finn & Levine, 2017; Agrawal et al., 2016; Pathak et al., 2018). However, the horizon of these approaches is still very short, and replanning in long-term drifts away in practice. Some methods try to alleviate this issue via object modeling (Janner et al., 2019; Li et al., 2019) or skip connections (Ebert et al., 2018a) but assume the models are trained with state-action pairs. In contrast to prior works where a short-range dynamic model is unrolled in time, we learn our long-range models from passive data and then couple them with short-range forward models to infer actions during planning.
+
+# 3 REGION PROPOSAL INTERACTION NETWORKS
+
+Our model takes $N$ video frames and the corresponding object bounding boxes as inputs, and outputs the objects’ bounding boxes and masks for the future $T$ timesteps. The overall model structure is illustrated in Figure 2.
+
+![](images/19d566559141436db945d2174916ecbf1ddaefb8284bcb860135b0361e2e770c.jpg)  
+Figure 2: Our Region Proposal Interaction Network. Given $N$ frames as inputs, we forward them to an encoder network, and then extract the foreground object features with RoIPooling (different colors represent different instances). We then perform interaction reasoning on top of the region proposal features (gray box on the bottom right). We predict each future object feature based on the previous $k$ time steps. We then estimate the object location from each object feature.
+
+For each frame, we first extract the image features using a ConvNet. Then we apply RoIPooling (Girshick, 2015; He et al., 2017) to obtain the object-centric visual features. These features are then forwarded to our Convolutional Interaction Networks (CIN) to perform objects’ interaction reasoning and used to predict future object bounding boxes and masks. The whole pipeline is trained end-to-end by minimizing the loss between the predicted outputs and the ground-truth.
+
+# 3.1 OBJECT-CENTRIC REPRESENTATION
+
+We apply the houglass network (Newell et al., 2016) to extract the image features. Given an input RGB image $I \in \breve { \mathbb { R } } ^ { 3 \times H \times W }$ , the hourglass network firstly downsample the input via one 2-strided convolution and 2-strided max pooling layers, and then refine the representation by a U-Net-like encoder-decoder modules (Ronneberger et al., 2015). The hourglass network provides features with a large receptive field and a fine spatial resolution (4 times smaller than the input image), both of which are crucial to accurately model object-object and object-environment interactions. We denote the number of output channels of the feature map as $d$ .
+
+On top of this feature map, we use RoIPooling (Girshick, 2015) to extract a $d \times h \times w$ objectcentric features. RoIPooling takes the feature map and a object bounding box as input. The region corresponding to the bounding box on the feature map is cropped and resize to a fixed spatial size (denoted as $h \times w$ ). We use $\boldsymbol { x } _ { i } ^ { t }$ to represent the feature at $t$ -th timestep for the $i$ -th object. Such feature representation differs from previous method in two perspectives: 1) It is extracted from image features with a large receptive field, which gives plenty of context information around the object. 2) The feature representation is a 3-dimensional feature map rather than a single vector representation. It can represent the objects’ shapes while the vector representation cannot because the spatial dimension is flattened.
+
+# 3.2 CONVOLUTIONAL INTERACTION NETWORKS
+
+To better utilize the spatial information of our object feature map, we propose Convolutional Interaction Networks, an extension of Interaction Network operators on 3-dimensional tensors. In this section, we first briefly review the original Interaction Network (IN) (Battaglia et al., 2016; Watters et al., 2017) and introduce the proposed Convolutional Interaction Networks (CIN).
+
+The original interaction network is a general-purpose data-driven method to model and predict physical dynamics. It takes the feature vectors of $m$ objects at timestep $t$ : $X = \{ x _ { 1 } ^ { t } , x _ { 2 } ^ { t } , . . . , x _ { m } ^ { \hat { t } } \mid x _ { i } ^ { t } \in \bar { \mathbb { R } } ^ { d } \}$ and performs object reasoning $f _ { O }$ as well as relational reasoning $f _ { R }$ on these features. Specifically, the updated rule of object features can be described as:
+
+$$
+\begin{array} { r l } & { e _ { i } ^ { t } = f _ { A } \big ( f _ { O } ( x _ { i } ^ { t } ) + \sum _ { j \neq i } f _ { R } ( x _ { i } ^ { t } , x _ { j } ^ { t } ) \big ) , } \\ & { z _ { i } ^ { t } = f _ { Z } ( x _ { i } ^ { t } , e _ { i } ^ { t } ) , } \\ & { x _ { i } ^ { t + 1 } = f _ { P } \big ( z _ { i } ^ { t } , z _ { i } ^ { t - 1 } , \dots , z _ { i } ^ { t - k } \big ) . } \end{array}
+$$
+
+In the above equation, $f _ { A }$ is the function to calculate the effect of both of object reasoning and relational reasoning results. And $f _ { Z }$ is used to combine the original object state and the reasoning effect. Finally, $f _ { P }$ is used to do future state predictions based on one or more previous object states. In IN, $f _ { O , R , A , Z , P }$ are instantiated by a fully-connected layer with learnable weights.
+
+Convolutional Interaction Networks. The input of CIN is $m$ object feature maps at timestep $t$ : $X = \{ x _ { 1 } ^ { t } , x _ { 2 } ^ { t } , . . . , x _ { m } ^ { t } | x _ { i } ^ { t } \in \mathbb { R } ^ { d \times h \times w } \}$ . The high-level update rule is the same as IN, but the key difference is that we use convolution to instantiate $f _ { O , R , A , Z , P }$ . Such instantiation is crucial to utilize the spatial information encoded in our object feature map and to effectively reason future object states. Specifically, we have
+
+$$
+\begin{array} { c c } { f _ { R } ( x _ { i } ^ { t } , x _ { j } ^ { t } ) = W _ { R } * [ x _ { i } ^ { t } , x _ { j } ^ { t } ] } & { f _ { O } ( x _ { i } ^ { t } ) = W _ { O } * x _ { i } ^ { t } } \\ { f _ { A } ( x _ { i } ^ { t } ) = W _ { A } ^ { T } * x _ { i } ^ { t } } & { f _ { Z } ( x _ { i } ^ { t } , e _ { i } ^ { t } ) = W _ { Z } * [ x _ { i } ^ { t } , e _ { i } ^ { t } ] } \\ { f _ { P } ( z _ { i } ^ { t } , z _ { i } ^ { t - 1 } , . . . , z _ { i } ^ { t - k } ) = W _ { P } * [ z _ { i } ^ { t } , z _ { i } ^ { t - 1 } , . . . , z _ { i } ^ { t - k } ] } \end{array}
+$$
+
+One can plug the functions in Equation 1 for better understanding the operations. In the above equations, $^ *$ denotes the convolution operator, and $[ \cdot , \cdot ]$ denotes concatenation along the channel dimension. $W _ { R } , W _ { Z } \in \mathbb { R } ^ { d \times 2 d \times 3 \times 3 }$ , $W _ { O } , W _ { A } \in \mathbb { R } ^ { d \times d \times 3 \times 3 }$ , $W _ { P } \in \mathbb { R } ^ { d \times ( k d ) \times 3 \times 3 }$ are learnable weights of the convolution kernels with kernel size $3 \times 3$ . We also add ReLU activation after each of the convolutional operators.
+
+# 3.3 LEARNING REGION PROPOSAL INTERACTION NETWORKS (RPIN)
+
+Our model predicts the future bounding box and (optionally) masks of each object. Given the predicted feature $\boldsymbol { x } _ { i } ^ { t + 1 }$ , we use a simple two layer MLP decoder to estimate its bounding boxes coordinates and masks. The bounding box decoder takes a flattened object feature map as input. It firstly projects it to $d$ dimensional vector, and outputs 4-d vector, representing the center location and size of the box. The mask decoder is of the same architecture but has $2 1 \times 2 1$ output channels, representing a $2 1 \times 2 1$ binary masks inside the corresponding bounding boxes. We use the $\ell ^ { 2 }$ loss for bounding box predictions. For mask prediction, we use spatial cross-entropy loss which sums the cross-entropy values of a $2 1 \times 2 1$ predicted positions. The objective can be written as:
+
+$$
+L _ { p } = \sum _ { t = 1 } ^ { T } \lambda _ { t } \sum _ { i = 1 } ^ { n } \Big ( \| \hat { B } _ { i } ^ { t + 1 } - B _ { i } ^ { t + 1 } \| _ { 2 } ^ { 2 } + C E ( \hat { M } _ { i } ^ { t + 1 } , M _ { i } ^ { t + 1 } ) \Big ) .
+$$
+
+We use discounted loss during training (Watters et al., 2017) to mitigate the effect of inaccurate prediction at early training stage and $\lambda _ { t }$ is the discounted factor.
+
+# 4 EXPERIMENTAL SETUP
+
+Datasets. We evaluate our method’s prediction performance on four different datasets, and demonstrate the ability to perform downstream physical reasoning and planning tasks on two of them. We briefly introduce the four datasets below. The full dataset details are in the appendix.
+
+PHYRE: We use the BALL-tier of the PHYRE benchmark (Bakhtin et al., 2019). In this dataset, we set $T = 5$ . We treat all of the moving balls or jars as objects and other static bodies as background. The benchmark provides two evaluation settings: 1) within task generalization (PHYRE-W), where the testing environments contain the same object category but different sizes and positions; 2) cross task generalization (PHYRE-C), where environments containing objects and context never present during training. We report prediction using the official fold 0 and the physical reasoning performance averaged on 10 folds.
+
+ShapeStacks (SS): This dataset contains multiple stacked objects (cubes, cylinders, or balls) (Ye et al., 2019). In this dataset, we set $T = 1 5$ . We evaluate all baselines and our methods follow the protocol of (Ye et al., 2019) with uncertainty estimation incorporated (see Appendix for detail).
+
+Real World Billiards (RealB): We collect “Three-cushion Billiards” videos from professional games with different viewpoints downloaded from YouTube. There are 62 training videos with 18, 306 frames, and 5 testing videos with 1, 995 frames. The bounding box annotations are from an offthe-shelf ResNet-101 FPN detector (Lin et al., 2017) pretrained on COCO (Lin et al., 2014) and fine-tuned on a subset of 30 images from our dataset. We manually filtered out wrong detections. In this dataset, we set $T = 2 0$ .
+
+Simulation Billiards (SimB): We create a simulated billiard environment with three different colored balls with a radius 2 are randomly placed in a $6 4 \times 6 4$ image. At starting point, one ball is moving with a randomly sampled velocity. We generate 1,000 video sequences for training and 1,000 video sequences for testing, with 100 frames per sequence. We will also evaluate the ability to generalize to more balls and different sized balls in the experiment section. In this dataset, we set $T = 2 0$ .
+
+For PHYRE and SS, it is possible to infer the future from just the initial configuration. So we set $N = 1$ in these two datasets. For SimB and RealB, the objects are moving in a flat table so we cannot infer the future trajectories based on a single image. Therefore in this setting, we set $N = 4$ to infer the velocity/acceleration of objects. We set $k = N$ in all the dataset because we only have access to $N$ features when we make prediction at $t = N + 1$ . We predict object masks for PHYRE and ShapeStacks, and only predict bounding boxes for Billiard datasets.
+
+Baselines. There are a large amount of work studying how to estimate objects’ states and predict their dynamics from raw image inputs. They fall into the following categories:
+
+VIN: Instead of using object-centric spatial pooling to extract object features, it use a ConvNet to globally encode an image to a fixed $d \times m$ dimensional vector. Different channels of the vector is assigned to different objects (Kipf et al., 2020; Watters et al., 2017). This approach requires specifying a fixed number of objects and a fixed mapping between feature channels and object identity, which make it impossible to generalize to different number of objects and different appearances.
+
+Object Masking (OM): This approach takes one image and $m$ object bounding boxes or masks as input (Wu et al., 2017; Veerapaneni et al., 2019; Janner et al., 2019). For each proposal, only the pixels inside object proposals are kept while others are set to 0, leading to $m$ masked images. This approach assumes no background information is needed thus fails to predict accurate trajectories in complex environments such as PHYRE. And it also cost $m$ times computational resources.
+
+CVP: The object feature is extracted by cropping the object image patch and forwarding it to an encoder (Ye et al., 2019; Yi et al., 2020). Since the object features are directly extracted from the raw image patches, the context information is also ignored. We re-implement CVP’s feature extraction method within our framework. We show we can reproduce their results in Section A.2.
+
+5 EVALUATION RESULTS: PREDICTION, GENERALIZATION, AND PLANNING
+
+We organize this section and analyze our results by discussing four scientific questions related to the prediction quality, generalization ability across time & environment configurations, and the ability to plan actions for downstream tasks.
+
+# 5.1 HOW ACCURATE IS THE PREDICTED DYNAMICS?
+
+To evaluate how well the world dynamics is modeled, we first report the average prediction errors on the test split, over the same time-horizon as which model is trained on, i.e., $t \in [ 0 , T _ { \mathrm { t r a i n } } ]$ . The prediction error is calculated by the squared $\ell _ { 2 }$ distance between predicted object center location and the ground-truth object centers. The results are shown in Table 1 (left half).
+
+Firstly, we show the effectiveness of our proposed RoI Feature by comparing Table 1 VIN, OM, CVP, and Ours (IN). These four entries use the same backbone network and interaction network modules and only visual encoder is changed. Among them, VIN cannot even be trained on PHYRE-W since it cannot handle varying number of objects. The OM method performs slightly better than other baselines since it also explicitly models objects by instance masking. For CVP, it cannot produce reasonable results on all of the datasets except on the SS dataset. The reason is that in PHYRE and billiard environments, cropped images are unaware of environment information and the relative position and pose of different objects, making it impossible to make accurate predictions. In SS, since the object size is large and objects are very close to each other, the cropped image regions already provide enough context. In contrast, our RoI Feature can implicitly encode the context and environment information and it performs much better than all baselines. In the very challenging PHYRE dataset, the prediction error is only $1 / 4$ of the best baseline. In the other three easier datasets, the gap is not as large since the environment is less complicated, but our method still achieves
+
+Table 1: We compare our method with different baselines on all four datasets. The left part shows the prediction error when rollout timesteps is the same as training time. The right part shows the generalization ability to longer horizon unseen during training. The error is scaled by 1,000. Our method has significantly improvements on all of the datasets   
+
+<table><tr><td rowspan="2">method</td><td rowspan="2">visual encoder</td><td colspan="3">t ∈ [0,Ttrain]</td><td rowspan="2"></td><td colspan="3">t ∈[Ttrain,2 × Ttrain]</td></tr><tr><td>PHYRE-W</td><td>sS RealB</td><td>SimB</td><td>PHYRE-W ss</td><td>RealB</td><td>SimB</td></tr><tr><td>VIN</td><td>Global Encoding</td><td>N.A.</td><td>2.47</td><td>1.02</td><td>3.89</td><td>N.A.</td><td>7.77 5.11</td><td>29.51</td></tr><tr><td>OM</td><td>Masked Image</td><td>6.45</td><td>3.01</td><td>0.59 3.48</td><td>25.72</td><td>9.51</td><td>3.23</td><td>28.87</td></tr><tr><td>CVP</td><td>Cropped Image</td><td>60.12</td><td>2.84</td><td>3.57</td><td>80.01</td><td>79.11 7.72</td><td>6.63</td><td>108.56</td></tr><tr><td>Ours (IN)</td><td>RoI Feature</td><td>1.50</td><td>1.85</td><td>0.37</td><td>3.01</td><td>12.45 4.89</td><td>2.72</td><td>27.88</td></tr><tr><td>Ours (CIN)</td><td>RoI Feature</td><td>1.31</td><td>1.03</td><td>0.30</td><td>2.55</td><td>11.10 4.73</td><td>2.34</td><td>25.77</td></tr></table>
+
+<table><tr><td>method</td><td>visual encoder</td><td>PHYRE-C SS-4 SimB-5</td></tr><tr><td>VIN</td><td>Global Encoding</td><td>N.A. N.A. N.A.</td></tr><tr><td>OM</td><td>Masked Image</td><td>50.28 17.02 59.70</td></tr><tr><td>CVP</td><td>Cropped Image</td><td>99.26 16.88 113.39</td></tr><tr><td>Ours (IN)</td><td>RoI Feature</td><td>10.98 15.02 24.42</td></tr><tr><td>Ours (CIN)</td><td>RoI Feature</td><td>9.22 14.61 22.38</td></tr></table>
+
+Table 2: The ability to generalize to novel environments. We show the average prediction error for $t \in [ 0 , 2 \times T _ { \mathrm { t r a i n } } ]$ . Our method achieves significantly better results compared to previous methods. The error is scaled by 1,000. Our method generalizes much better than other baselines.
+
+more than $10 \%$ improvements. These results clearly demonstrates the advantage of using rich state representations.
+
+Secondly, we show that the effectiveness of our proposed Convolutional Interaction Network by comparing Table 1 Ours (IN) and Ours (CIN). With every other components the same, changing the vector-form representation to spatial feature maps and use convolution to model the interactions can further improve the performance by $10 \% { \sim } 4 0 \%$ . This result shows our convolutional interaction network could better utilize the spatial information encoded in the object feature map.
+
+# 5.2 DOES LEARNED MODEL GENERALIZE TO LONGER HORIZON THAN TRAINING?
+
+Generalize to longer horizons is a challenging task. In this section we compare the performance of predicting trajectories longer than training time. In Table 1 (right half), we report the prediction error for $t \in [ \bar { T } _ { \mathrm { t r a i n } } , 2 \times T _ { \mathrm { t r a i n } } ]$ . The results in this setting are consistent with what we found in Section 5.1. Our method still achieves the best performance against all baselines. Specifically, for all datasets except SimB, we reduce the error by more than $30 \%$ percent. In SimB, the improvement is not as significant because the interaction with environment only includes bouncing off the boundaries (see Figure 4 (c) and (d)). Meanwhile, changing IN to CIN further improve the performance. This again validates our hypothesis that the key to making accurate long-term feature prediction is the rich state representation extracted from an image.
+
+# 5.3 DOES LEARNED MODEL GENERALIZE TO UNSEEN CONFIGURATIONS?
+
+The general applicability of RoI Feature has been extensively verified in the computer vision community. As one of the benefits, our method can generalize to novel environments configurations without any modifications or online training. We test such a claim by testing on several novel environments unseen during training. Specifically, we construct 1) simulation billiard dataset contains 5 balls with radius 2 (SimB-5); 2) PHYRE-C where the test tasks are not seen during training; 3) ShapeStacks with 4 stacked blocks (SS-4). The results are shown in Table 2.
+
+Since VIN needs a fixed number of objects as input, it cannot generalize to a different number of objects, thus we don’t report its performance on SimB-5, PHYRE-C, and SS-4. In the SimB-5 and PHYRE-C setting, where generalization ability to different numbers and different appearances is required, our method reduce the prediction error by $7 5 \%$ . In SS-4, the improvement is not as significant as the previous two because cropped image may be enough on this simpler dataset as mentioned above.
+
+Table 3: PHYRE Planning results. RAND stands for a score function with random policy. We show that our method achieves state-ofthe-art on both within-task generalization as well as cross-task generalization.   
+
+<table><tr><td></td><td>Within</td><td>Cross</td></tr><tr><td>RAND</td><td>13.7±0.5</td><td>13.0±5.0</td></tr><tr><td>DQN</td><td>77.6±1.1</td><td>36.8±9.7</td></tr><tr><td>Ours</td><td>85.2±0.7</td><td>42.2±7.1</td></tr></table>
+
+Table 4: Simulation Billiards planning results. To make a fair comparison, all of baselines and our methods are using the original interaction network and only the visual encoding method is changing. RAND stands for a policy taking random actions.   
+
+<table><tr><td></td><td>Target State Error</td><td>Hitting Accuracy</td></tr><tr><td>RAND</td><td>36.91</td><td>9.50%</td></tr><tr><td>CVP</td><td>29.84</td><td>20.3%</td></tr><tr><td>VIN</td><td>9.11</td><td>51.2%</td></tr><tr><td>OM</td><td>8.75</td><td>54.5%</td></tr><tr><td>Ours</td><td>7.62</td><td>57.2%</td></tr></table>
+
+# 5.4 HOW WELL CAN THE LEARNED MODEL BE USED FOR PLANNING ACTIONS?
+
+The advantage of using a general purpose task-agnostic prediction model is that it can help us do downstream planning and reasoning tasks. In this section, we evaluate our prediction model in the recently proposed challenging PHYRE benchmark (Bakhtin et al., 2019) and simulation billiards planning tasks.
+
+PHYRE. We use the B-tier of the environment. In this task, we need to place one red ball at a certain location such that the green ball touches another blue/purple object (see figure 1 right for an example). Bakhtin et al. (2019) trains a classification network whose inputs are the first image and a candidate action, and outputs whether the action leads to success. Such a method does not utilize the dynamics information. In contrast, we can train a classifier on top of the predicted objects’ features so that it can utilize dynamics information and makes more accurate classification.
+
+During training, we use the same prediction model as described in previous sections except for $T _ { \mathrm { t r a i n } } = 1 0$ , and then attach an extra classifier on the objects’ features. Specifically, we concatenate each object’s features at the 0th, 3rd, 6th, and 9th timestep and then pass it through two fullyconnected layers to get a feature trajectory for each object. Then we take the average of all the objects’ features and pass it through one fully-connected layer to get a score indicating whether this placement solve the task. We minimize the cross-entropy loss between the score and the ground-truth label indicating whether the action is a success. Note that different from previous work (Bakhtin et al., 2019; Girdhar et al., 2020), our model does not need to convert the input image to the 7-channel segmentation map since object information is already utilized by our object-centric representation. During testing, We enumerate the first 10,000 actions from the pre-computed action set in Bakhtin et al. (2019) and render the red ball on the initial image as our prediction model’s input. Our final output is an sorted action list according to the model’s output score.
+
+We report the AUCCESS metric on the official 10 folds of train/test splits for both within-task generalization and cross-task generalization setting. The results are in Table 3. Our method achieves about 8 points improvement over the strong DQN baseline (Bakhtin et al., 2019) in the withintask generalization setting. On the more challenging setting of cross-task generalization where the environments may not be seen during training, our method is 6 points higher than DQN.
+
+SimB Planning. We consider two tasks in the SimB environment: 1) Billiard Target State. Given an initial and final configuration after 40 timesteps, the goal is to find one action that will lead to the target configuration. We report the smallest distances between the trajectory between timestep 35-45 and the final position. 2) Billiard Hitting. Given the initial configurations, the goal is to find an action that can hit the other two balls within 50 timesteps.
+
+We firstly train a forward model taken image and action as input, to predict the first 4 object positions and render it to image. After that the rendered images are passed in our prediction model. We score each action according to the similarity between the generated trajectory and the goal state. Then the action with the highest score is selected. The results are shown in Table 4. Our results achieves best performance on all tasks. The full planning algorithm and implementation details are included in the appendix.
+
+![](images/d2f7e576d8d7fe742bce84281066ea6d0abae4d18ceb29d317b44eab945243b3.jpg)  
+Figure 3: We show the qualitative comparisons between our method and other baselines in the PHYRE benchmark. Our model can accurately infer objects’ interactions and collisions with the environment over a long-range (10s), while the baseline methods cannot (the balls sometimes penetrates other objects). In this visualization, only the moving objects’ location and masks are predicted (the color is taken from the simulator). Static environment parts (with black color) are rendered from the initial image.
+
+![](images/0b41d50c27cc9b6937b35a3119bc78bc8cf402bfc6746959eea4c38dcc388422.jpg)  
+Figure 4: We show the qualitative results of our predicted trajectories in the other three (RealB, SimB, and SS) datasets. Our model could produce accurate and plausible predictions on different scenarios.
+
+# 5.5 QUALITATIVE RESULTS
+
+In figure 3, we show the qualitative prediction results both for our method as well as the OM and CVP baselines. In figure 4, we compare our prediction and ground-truth on the other three datasets. More results and videos are available at our Website.
+
+# 6 CONCLUSIONS
+
+In this paper, we leverage the modern computer vision techniques to propose Region Proposal Interaction Networks for physical interaction reasoning with visual inputs. We show that our general, yet simple method achieves a significant improvement and can generalize across both simulation and real-world environments for long-range prediction and planning. We believe this method may serve as a good benchmark for developing future methods in the field of learning intuitive physics, as well as their application to real-world robotics.
+
+# ACKNOWLEDGEMENT
+
+This work is supported in part by DARPA MCS and DARPA LwLL. We would like to thank the members of BAIR for fruitful discussions and comments.
+
+REFERENCES   
+Pulkit Agrawal, Ashvin V Nair, Pieter Abbeel, Jitendra Malik, and Sergey Levine. Learning to poke by poking: Experiential learning of intuitive physics. In NeurIPS, 2016. 3   
+Frank Allgöwer and Alex Zheng. Nonlinear model predictive control. Birkhäuser, 2012. 1, 3   
+Mohammad Babaeizadeh, Chelsea Finn, Dumitru Erhan, Roy H Campbell, and Sergey Levine. Stochastic variational video prediction. ICLR, 2017. 3   
+Anton Bakhtin, Laurens van der Maaten, Justin Johnson, Laura Gustafson, and Ross Girshick. Phyre: A new benchmark for physical reasoning. In NeurIPS, 2019. 2, 5, 8, 15, 16   
+Peter Battaglia, Razvan Pascanu, Matthew Lai, Danilo Jimenez Rezende, et al. Interaction networks for learning about objects, relations and physics. In NeurIPS, 2016. 1, 2, 4   
+Peter W Battaglia, Jessica B Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, et al. Relational inductive biases, deep learning, and graph networks. arXiv, 2018. 3   
+Kiran S Bhat, Steven M Seitz, Jovan Popovic, and Pradeep K Khosla. Computing the physical ´ parameters of rigid-body motion from video. In ECCV, 2002. 3   
+Apratim Bhattacharyya, Mateusz Malinowski, Bernt Schiele, and Mario Fritz. Long-term image boundary extrapolation. arXiv, 2016. 2   
+Marcus A Brubaker, Leonid Sigal, and David J Fleet. Estimating contact dynamics. In ICCV. IEEE, 2009. 3   
+Yuri Burda, Harri Edwards, Deepak Pathak, Amos Storkey, Trevor Darrell, and Alexei A. Efros. Large-scale study of curiosity-driven learning. In ICLR, 2019. 3   
+Eduardo F Camacho and Carlos Bordons Alba. Model predictive control. Springer Science & Business Media, 2013. 1, 3   
+Michael B Chang, Tomer Ullman, Antonio Torralba, and Joshua B Tenenbaum. A compositional object-based approach to learning physical dynamics. ICLR, 2016. 1, 2, 3   
+Baoyang Chen, Wenmin Wang, and Jinzhuo Wang. Video imagination from a single image with transformation generation. In ACMMM Workshop, 2017. 3   
+Kenneth James Williams Craik. The nature of explanation. CUP Archive, 1952. 1   
+Jifeng Dai, Haozhi Qi, Yuwen Xiong, Yi Li, Guodong Zhang, Han Hu, and Yichen Wei. Deformable convolutional networks. In ICCV, 2017. 2   
+Marc Deisenroth and Carl E Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In ICML, 2011. 3   
+Emily Denton and Rob Fergus. Stochastic video generation with a learned prior. In ICML, 2018. 1, 3   
+Frederik Ebert, Sudeep Dasari, Alex X Lee, Sergey Levine, and Chelsea Finn. Robustness via retrying: Closed-loop robotic manipulation with self-supervised learning. arXiv, 2018a. 3   
+Frederik Ebert, Chelsea Finn, Sudeep Dasari, Annie Xie, Alex Lee, and Sergey Levine. Visual foresight: Model-based deep reinforcement learning for vision-based robotic control. arXiv, 2018b. 1
+
+Sebastien Ehrhardt, Aron Monszpart, Niloy J Mitra, and Andrea Vedaldi. Learning a physical long-term predictor. arXiv, 2017. 2
+
+Chelsea Finn and Sergey Levine. Deep visual foresight for planning robot motion. In ICRA, 2017. 3
+
+Chelsea Finn, Ian Goodfellow, and Sergey Levine. Unsupervised learning for physical interaction through video prediction. In NeurIPS, 2016. 3
+
+Katerina Fragkiadaki, Pulkit Agrawal, Sergey Levine, and Jitendra Malik. Learning visual predictive models of physics for playing billiards. ICLR, 2015. 2, 15
+
+Rohit Girdhar, Laura Gustafson, Aaron Adcock, and Laurens van der Maaten. Forward prediction for physical reasoning. arXiv, 2020. 3, 8
+
+Ross Girshick. Fast R-CNN. In ICCV, 2015. 2, 4
+
+Georgia Gkioxari, Jitendra Malik, and Justin Johnson. Mesh R-CNN. In ICCV, 2019. 2
+
+Oliver Groth, Fabian Fuchs, Ingmar Posner, and Andrea Vedaldi. Shapestacks: Learning vision-based physical intuition for generalised object stacking. In ECCV, 2018. 3
+
+Radek Grzeszczuk, Demetri Terzopoulos, and Geoffrey Hinton. Neuroanimator: Fast neural network emulation and control of physics-based models. In SIGGRAPH, 1998. 2
+
+Jessica Hamrick, Peter Battaglia, and Joshua B Tenenbaum. Internal physics models guide probabilistic judgments about object dynamics. In COGSCI, 2011. 3
+
+Kaiming He, Georgia Gkioxari, Piotr Dollár, and Ross Girshick. Mask R-CNN. In ICCV, 2017. 2, 4
+
+Michael Janner, Sergey Levine, William T Freeman, Joshua B Tenenbaum, Chelsea Finn, and Jiajun Wu. Reasoning about physical interactions with object-oriented prediction and planning. ICLR, 2019. 2, 3, 6
+
+Dinesh Jayaraman, Frederik Ebert, Alexei A Efros, and Sergey Levine. Time-agnostic prediction: Predicting predictable video frames. In ICLR, 2019. 1
+
+Xu Jia, Bert De Brabandere, Tinne Tuytelaars, and Luc V Gool. Dynamic filter networks. In NeurIPS, 2016. 3
+
+Zhaoyin Jia, Andrew C Gallagher, Ashutosh Saxena, and Tsuhan Chen. 3d reasoning from blocks to stability. PAMI, 2015. 3
+
+Michael I Jordan and David E Rumelhart. Forward models: Supervised learning with a distal teacher. Cognitive science, 1992. 3
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv, 2014. 15
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. ICLR, 2014. 14
+
+Thomas Kipf, Elise van der Pol, and Max Welling. Contrastive learning of structured world models. ICLR, 2020. 2, 6
+
+James R Kubricht, Keith J Holyoak, and Hongjing Lu. Intuitive physics: Current research and controversies. Trends in cognitive sciences, 2017. 1
+
+Alex X Lee, Richard Zhang, Frederik Ebert, Pieter Abbeel, Chelsea Finn, and Sergey Levine. Stochastic adversarial video prediction. arXiv, 2018. 1, 3
+
+Adam Lerer, Sam Gross, and Rob Fergus. Learning physical intuition of block towers by example. In ICML, 2016. 3
+
+Wenbin Li, Seyedmajid Azimi, Aleš Leonardis, and Mario Fritz. To fall or not to fall: A visual approach to physical stability prediction. arXiv, 2016a. 3
+
+Wenbin Li, Aleš Leonardis, and Mario Fritz. Visual stability prediction and its application to manipulation. AAAI, 2016b. 3
+
+Yunzhu Li, Jiajun Wu, Jun-Yan Zhu, Joshua B Tenenbaum, Antonio Torralba, and Russ Tedrake. Propagation networks for model-based control under partial observation. In ICRA, 2019. 3
+
+Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ECCV, 2014. 5
+
+Tsung-Yi Lin, Piotr Dollár, Ross Girshick, Kaiming He, Bharath Hariharan, and Serge Belongie. Feature pyramid networks for object detection. In CVPR, 2017. 5
+
+Ziwei Liu, Raymond A Yeh, Xiaoou Tang, Yiming Liu, and Aseem Agarwala. Video frame synthesis using deep voxel flow. In ICCV, 2017. 3
+
+Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv, 2016. 15
+
+Michael McCloskey. Intuitive physics. Scientific american, 1983. 1
+
+Roozbeh Mottaghi, Hessam Bagherinezhad, Mohammad Rastegari, and Ali Farhadi. Newtonian scene understanding: Unfolding the dynamics of objects in static images. In CVPR, 2016a. 3
+
+Roozbeh Mottaghi, Mohammad Rastegari, Abhinav Gupta, and Ali Farhadi. “what happens if...” learning to predict the effect of forces in images. In ECCV, 2016b. 3
+
+Alejandro Newell, Kaiyu Yang, and Jia Deng. Stacked hourglass networks for human pose estimation. In ECCV, 2016. 4, 14
+
+Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-conditional video prediction using deep networks in atari games. In NeurIPS, 2015. 3
+
+Deepak Pathak, Pulkit Agrawal, Alexei A Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. ICML, 2017. 3
+
+Deepak Pathak, Parsa Mahmoudieh, Guanghao Luo, Pulkit Agrawal, Dian Chen, Yide Shentu, Evan Shelhamer, Jitendra Malik, Alexei A Efros, and Trevor Darrell. Zero-shot visual imitation. In ICLR, 2018. 3
+
+Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In MICCAI, 2015. 4
+
+Alvaro Sanchez-Gonzalez, Jonathan Godwin, Tobias Pfaff, Rex Ying, Jure Leskovec, and Peter W Battaglia. Learning to simulate complex physics with graph networks. arXiv, 2020. 1
+
+Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Network, 2009. 3
+
+Russell Stewart and Stefano Ermon. Label-free supervision of neural networks with physics and domain knowledge. In AAAI, 2017. 2
+
+Sergey Tulyakov, Ming-Yu Liu, Xiaodong Yang, and Jan Kautz. Mocogan: Decomposing motion and content for video generation. CVPR, 2017. 3
+
+Rishi Veerapaneni, John D Co-Reyes, Michael Chang, Michael Janner, Chelsea Finn, Jiajun Wu, Joshua B Tenenbaum, and Sergey Levine. Entity abstraction in visual model-based reinforcement learning. In CoRL, 2019. 6
+
+Ruben Villegas, Jimei Yang, Seunghoon Hong, Xunyu Lin, and Honglak Lee. Decomposing motion and content for natural video sequence prediction. ICLR, 2017a. 3
+
+Ruben Villegas, Jimei Yang, Yuliang Zou, Sungryull Sohn, Xunyu Lin, and Honglak Lee. Learning to generate long-term future via hierarchical prediction. ICML, 2017b. 3
+
+Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. In NeurIPS, 2016. 3
+
+Niklas Wahlström, Thomas B Schön, and Marc Peter Deisenroth. From pixels to torques: Policy learning with deep dynamical models. ICML, 2015. 3   
+Jacob Walker, Carl Doersch, Abhinav Gupta, and Martial Hebert. An uncertain future: Forecasting from static images using variational autoencoders. In ECCV, 2016. 1, 3   
+Jacob Walker, Kenneth Marino, Abhinav Gupta, and Martial Hebert. The pose knows: Video forecasting by generating pose futures. In ICCV, 2017. 3   
+Nicholas Watters, Daniel Zoran, Theophane Weber, Peter Battaglia, Razvan Pascanu, and Andrea Tacchetti. Visual interaction networks: Learning a physics simulator from video. In NeurIPS, 2017. 2, 3, 4, 5, 6   
+Jiajun Wu, Ilker Yildirim, Joseph J Lim, Bill Freeman, and Josh Tenenbaum. Galileo: Perceiving physical object properties by integrating a physics engine with deep learning. In NeurIPS, 2015. 3   
+Jiajun Wu, Joseph J Lim, Hongyi Zhang, Joshua B Tenenbaum, and William T Freeman. Physics 101: Learning physical object properties from unlabeled videos. In BMVC, 2016. 3   
+Jiajun Wu, Erika Lu, Pushmeet Kohli, Bill Freeman, and Josh Tenenbaum. Learning to see physics via visual de-animation. In NeurIPS, 2017. 6   
+Tianfan Xue, Jiajun Wu, Katherine Bouman, and Bill Freeman. Visual dynamics: Probabilistic future frame synthesis via cross convolutional networks. In NeurIPS, 2016. 3   
+Tian Ye, Xiaolong Wang, James Davidson, and Abhinav Gupta. Interpretable intuitive physics model. ECCV, 2018. 3   
+Yufei Ye, Maneesh Singh, Abhinav Gupta, and Shubham Tulsiani. Compositional video prediction. ICCV, 2019. 2, 3, 5, 6, 14, 15   
+Kexin Yi, Chuang Gan, Yunzhu Li, Pushmeet Kohli, Jiajun Wu, Antonio Torralba, and Joshua B Tenenbaum. Clevrer: Collision events for video representation and reasoning. In ICLR, 2020. 6
+
+# A IMPLEMENTATION DETAILS
+
+# A.1 NETWORK ARCHITECTURE DETAILS
+
+Backbone Networks: We use the same backbone network for our method and all the baselines (VIN, OM, CVP). We choose the hourglass network (Newell et al., 2016) as the image feature extractor. Given an input image, the hourglass network firstly applies a $7 \times 7$ stride-2 convolution, three residual blocks with channel dimension $d / 4$ , and a stride-2 max pooling on it. Then this intermediate feature representation is fed into one hourglass modules. In the hourglass module, the feature maps are downsampled with 3 stride-2 residual blocks and then up-sampled with nearest neighbor interpolation. The dimensions of both the input channel and the output channel of each residual block are $d$ . For SimB, we use $d = 6 4$ since the visual information in this environment is relatively simple. For RealB, PHYRE, and ShapeStacks, $d = 2 5 6$ . We use batch normalization before each convolutional layer in the backbone network. The resulting feature map size is $d \times \frac { H } { 4 } \times \frac { W } { 4 }$ , where $H$ , $W$ is the input image size and 4 is the spatial feature stride of the hourglass network.
+
+The output features are transformed to object-centric representations differently for our method and each of the baseline methods:
+
+VIN: The resulting feature map is forwarded to 4 convolutional layers with stride 2 and a spatial global average pooling layer to get a $d$ dimensional feature vector. This feature vector is transformed to $d \times m$ by one fully-connected layer. This feature will be reshaped to $m$ vectors with $d$ channel dimensional to represent each object. This representation is refined by two $d \times d$ fully-connected layers and passed to the (convolutional) interaction network.
+
+M and CVP: The output feature map is of shape $m \times d \times \textstyle { \frac { H } { 4 } } \times \frac { W } { 4 }$ because this method produce $m$ masked (or cropped) images as input. The resulting feature map is forwarded to 4 convolutional layers with stride 2 and a spatial global average pooling layer to get a $d$ dimensional feature vector and the output feature is of size $m \times d$ , representing the features of $m$ objects. This representation is refined by two $d \times d$ fully-connected layers and passed to the (convolutional) interaction network.
+
+# A.2 UNCERTAINTY MODELING.
+
+Only in the shapestack datasets, we also incorporate uncertainty estimation follows (Ye et al., 2019), by modeling the latent distribution using a variational auto-encoder (Kingma & Welling, 2014). For the complete details, we refer the reader to (Ye et al., 2019). Here we only give a summary: we build an encoder $h$ which takes the image feature from first $\mathcal { F } ^ { 0 }$ and last frame $\check { \mathcal { F } } ^ { T }$ of a video sequence as the input. The output of $h$ is a distribution parameter, denoted by $h ( \mathbf { u } | \mathcal { F } ^ { 0 } , \mathcal { F } ^ { T } )$ . Given a particular sample from such distribution, we recover the latent variable by feeding them into a one-layer LSTM and merge into the object feature $\ v x _ { i } ^ { t }$ . In this case, our pipeline is trained with an additional loss that minimize the KL divergence between the predicted distribution and normal distribution (Kingma & Welling, 2014).
+
+During inference, we sample 100 trajectories for each test image and report the minimum of them. This setting is the same as the original CVP paper $\mathrm { Y e }$ et al. (2019). Our implementation gets $5 . 2 8 \times 1 0 ^ { - 3 }$ squared $\ell _ { 2 }$ distance for $T \in [ 0 , T _ { \mathrm { t r a i n } } ]$ while the original paper report $6 . 6 9 \times 1 0 ^ { - 3 }$ .
+
+# A.3 DATASET DETAILS
+
+SimB: To get the initial velocity, the magnitude (number of pixels moved per timestep) is sampled from [2, 3, 4, 5, 6] and the direction is sampled from $\{ 6 i \pi , i = 0 , 1 , \ldots , 1 1 \}$ .
+
+RealB: We found that the bounding box prediction results are accurate enough to serve as the groundtruth. After running the detector, we also manually go through the dataset and filter out images with incorrect detections.
+
+ShapeStacks: There are 1,320 training videos and 296 testing videos, with 32 frames per video. Only objects’ center positions provided. Following (Ye et al., 2019), we assume the object bounding box is square and of size $7 0 \times 7 0$ .
+
+PHYRE: For within task generalization (PHYRE-W), the training set contains 80 templates for each of the 25 task. The testing set contains the remaining 20 templates from each task. For cross task generalization (PHYRE-C), the training set contains 100 templates from 20 tasks while the test set contains 100 templates from the remaining 5 tasks. For each template, we randomly sample a maximum 100 success and 400 failure actions to collect the trajectories to train our model. The image sequence is temporally downsampled by 60.
+
+For our physical reasoning experiments in section 5.4, we train the model using 400 successful actions and 1600 failure actions per template. We use the validation set to select hyper-parameters first, and then do training on the union of train and validation sets and report the final results in the test set.
+
+# A.4 HYPERPARAMETERS
+
+We use Adam optimizer Kingma & Ba (2014) with cosine decay Loshchilov & Hutter (2016) to train our networks. The default input frames is $N = 4$ except $N = 1$ for ShapeStacks and PHYRE. We set $d$ to be 256 except for simulation billiard $d$ is 64. During training, $T$ (denoted as $T _ { \mathrm { t r a i n . } }$ ) is set to be 20 for SimB and RealB, 5 for PHYRE, and 15 for fair comparison with Ye et al. (2019). The discounted factor $\lambda _ { t }$ is set to be $\begin{array} { r } { \big ( \frac { \mathrm { c u r r e n t \_ i t e r } } { \mathrm { m a x \_ i t e r } } \big ) ^ { t } } \end{array}$ .
+
+Simulation Billiards. The image size is $6 4 \times 6 4$ . We train the model for 100K iterations with a learning rate $2 \times 1 0 ^ { - 3 }$ , weight decay $\mathrm { 1 \check { \times } 1 0 ^ { - 6 } }$ , and batch size 200.
+
+Real World Billiards. The image is resized to $1 9 2 \times 6 4$ . We train the model for 240K iterations with a learning rate $1 \times 1 0 ^ { - 4 }$ , weight decay $1 \times 1 0 ^ { - 6 }$ , and batch size 20.
+
+PHYRE. The image is resized to $1 2 8 \times 1 2 8$ . We train the model for 150K iterations with a learning rate $2 \times 1 0 ^ { - 4 }$ , weight decay $3 \times 1 0 ^ { - 7 }$ , and batch size 20.
+
+ShapeStacks. The image is resized to $2 2 4 \times 2 2 4$ . We train the model for 25K iterations with a learning rate $2 \times 1 0 ^ { - 4 }$ , no weight decay (the same as Ye et al. (2019)), and batch size 40. In this dataset, we apply uncertainty modeling. The loss weight of KL-divergence is $3 \times 1 0 ^ { - 5 }$ . During inference, following Ye et al. (2019), we randomly sample 100 outputs from our model, and select the best (in terms of the distance to ground-truth) of them as our model’s output.
+
+# B PLANNING DETAILS
+
+Given an initial state (represented by an image) and a goal, we aim to produce an action that can lead to the goal from the initial state. Our planning algorithm works in a similar way as visual imagination Fragkiadaki et al. (2015): Firstly, we select a candidate action a from a candidate action set $\mathcal { A }$ . Then we generate the input images $\mathcal { T }$ . For SimB, we train a forward model take the initial image and the action embedding to generate object positions for the next 3 steps. Then we use the simulator to generate the 3 images. For PHYRE, we convert the action to the red ball using the simulator and get the initial image. After that, we run our model described in section 5.4 and the score of each action is simply the classifier’s output. We then select the action with the max score.
+
+We introduce the action set for each task in section B.1, and how to design distance function in B.2.   
+A summary of our algorithm is in Algorithm 1.
+
+# B.1 CANDIDATE ACTION SETS
+
+For simulation billiard, the action is 3 dimensional. The first two dimensions stand for the direction of the force. The last dimension stands for the magnitude of the force. During doing planning, we enumerate over 5 different magnitudes and 12 different angles, leading to 60 possible actions. All of the initial condition is guaranteed to have a solution.
+
+For PHYRE, the action is also 3 dimensional. The first two dimensions stand for the location placing the red ball. The last dimension stands for the radius of the ball. Following (Bakhtin et al., 2019), we use the first 10k actions provided by the benchmark.
+
+# B.2 DISTANCE FUNCTION
+
+Init-End State Error. Denote the given target location of $m$ objects as $y \in R ^ { m \times 2 }$ . We use the following distance function, which measures the distance between the final rollout location and the
+
+target location:
+
+$$
+D = \sum _ { i = 1 } ^ { m } \sum _ { j = 1 } ^ { 2 } ( \hat { p } _ { T , i , j } - y _ { i , j } ) ^ { 2 }
+$$
+
+Hitting Accuracy. Denote the given initial location of $m$ objects as $x \in R ^ { m \times 2 }$ . We apply force at the object $i ^ { \prime }$ . We use the following distance function, which prefer the larger moving distance for objects other than $i ^ { \prime }$ :
+
+$$
+D = - \operatorname* { m i n } _ { i } \sum _ { \substack { i = 1 , i \neq i ^ { \prime } } } ^ { m } \sum _ { j = 1 } ^ { 2 } ( \hat { p } _ { T , i , j } - x _ { i , j } ) ^ { 2 }
+$$
+
+PHYRE task. Since we already train a classifier to classify whether the predicted trajectory will lead to a successful solution of the current task, during test time we can directly use it to classify whether the current action will lead to a successful solution. The distance function is just the negative output score.
+
+# B.3 PLANNING ALGORITHM
+
+# Algorithm 1: Planning Algorithm for Simulated Billiard and PHYRE
+
+Input: candidate actions $\begin{array} { r } { \boldsymbol { \mathcal { A } } = \{ \mathbf { a } _ { i } \} } \end{array}$ , initial state $x$ , end state $y$ (optional)   
+Output: action $\mathbf { a } ^ { * }$   
+for a in $\mathcal { A }$ do $\mathcal { T } = \mathrm { S i m u l a t i o n } ( x , \mathbf { a } )$ ; $\hat { p } =$ PredictionModel $( \mathcal { T } )$ ; calculate $D$ according to task as in B.2; if $D < D ^ { * }$ then $D ^ { * } = D$ ; $a ^ { * } = a$ ; end   
+end
+
+# C PHYRE 10 FOLD RESULTS
+
+To enable future work to compare with our method, we provide AUCCESS scores for all folds in Table 5. The number of RAND and DQN is taken from Bakhtin et al. (2019).
+
+Table 5: The AUCCESS scores for each of evaluated fold.   
+
+<table><tr><td rowspan="2">setting</td><td rowspan="2">method</td><td colspan="10">fold id</td></tr><tr><td>0</td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td></tr><tr><td rowspan="3">B (within)</td><td>RAND</td><td>13.44</td><td>14.01</td><td>13.79</td><td>13.80</td><td>12.75</td><td>13.34</td><td>13.95</td><td>14.30</td><td>13.36</td><td>14.33</td></tr><tr><td>DQN</td><td>76.82 79.72</td><td></td><td>78.22</td><td>75.86</td><td>77.03</td><td>78.42</td><td>78.01</td><td>77.34</td><td>78.04</td><td>76.87</td></tr><tr><td>Ours</td><td>85.49</td><td>86.57</td><td>85.58</td><td>84.11</td><td>85.30</td><td>85.18</td><td>84.78</td><td>84.32</td><td>85.71</td><td>85.17</td></tr><tr><td rowspan="3">B (cross)</td><td>RAND</td><td>11.78</td><td>12.42</td><td>18.18</td><td>12.42</td><td>3.81</td><td>22.50</td><td>11.73</td><td>13.29</td><td>8.94</td><td>14.60</td></tr><tr><td>DQN</td><td>43.69 30.96 43.05 43.91 22.77</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>44.40 34.53 39.20 18.98 46.46</td></tr><tr><td>Ours</td><td>50.86 36.58 55.44 38.34 37.11 47.23 3.23 47.19 32.23 38.76</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>

parse/train/_X_4Akcd8Re/_X_4Akcd8Re_content_list.json

@@ -0,0 +1,2026 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING LONG-TERM VISUAL DYNAMICS WITH REGION PROPOSAL INTERACTION NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            776,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Haozhi Qi UC Berkeley ",
+        "bbox": [
+            178,
+            170,
+            264,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xiaolong Wang UC San Diego ",
+        "bbox": [
+            297,
+            170,
+            405,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak CMU ",
+        "bbox": [
+            436,
+            170,
+            544,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yi Ma UC Berkeley ",
+        "bbox": [
+            575,
+            170,
+            661,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jitendra Malik UC Berkeley ",
+        "bbox": [
+            692,
+            170,
+            799,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            222,
+            544,
+            237
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning long-term dynamics models is the key to understanding physical common sense. Most existing approaches on learning dynamics from visual input sidestep long-term predictions by resorting to rapid re-planning with short-term models. This not only requires such models to be super accurate but also limits them only to tasks where an agent can continuously obtain feedback and take action at each step until completion. In this paper, we aim to leverage the ideas from success stories in visual recognition tasks to build object representations that can capture inter-object and object-environment interactions over a long-range. To this end, we propose Region Proposal Interaction Networks (RPIN), which reason about each object’s trajectory in a latent region-proposal feature space. Thanks to the simple yet effective object representation, our approach outperforms prior methods by a significant margin both in terms of prediction quality and their ability to plan for downstream tasks, and also generalize well to novel environments. Code, pre-trained models, and more visualization results are available at our Website. ",
+        "bbox": [
+            233,
+            247,
+            766,
+            440
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            460,
+            336,
+            476
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As argued by Kenneth Craik, if an organism carries a model of external reality and its own possible actions within its head, it is able to react in a much fuller, safer and more competent manner to emergencies which face it (Craik, 1952). Indeed, building prediction models has been long studied in computer vision and intuitive physics. In computer vision, most approaches make predictions in pixel-space (Denton & Fergus, 2018; Lee et al., 2018; Ebert et al., 2018b; Jayaraman et al., 2019; Walker et al., 2016), which ends up capturing the optical flow (Walker et al., 2016) and is difficult to generalize to long-horizon. In intuitive physics, a common approach is to learn the dynamics directly in an abstracted state space of objects to capture Newtonian physics (Battaglia et al., 2016; Chang et al., 2016; Sanchez-Gonzalez et al., 2020). However, the states end up being detached from raw sensory perception. Unfortunately, these two extremes have barely been connected. In this paper, we argue for a middle-ground to treat images as a window into the world, i.e., objects exist but can only be accessed via images. Images are neither to be used for predicting pixels nor to be isolated from dynamics. We operationalize it by learning to extract a rich state representation directly from images and build dynamics models using the extracted state representations. ",
+        "bbox": [
+            173,
+            486,
+            825,
+            679
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "It is difficult to make predictions, especially about the future — Niels Bohr ",
+        "text_level": 1,
+        "bbox": [
+            336,
+            686,
+            821,
+            702
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Contrary to Niels Bohr, predictions are, in fact, easy if made only for the short-term. Predictions that are indeed difficult to make and actually matter are the ones made over the long-term. Consider the example of “Three-cushion Billiards” in Figure 1. The goal is to hit the cue ball in such a way that it touches the other two balls and contacts the wall thrice before hitting the last ball. This task is extremely challenging even for human experts because the number of successful trajectories is very sparse. Do players perform classical Newtonian physics calculations to obtain the best action before each shot, or do they just memorize the solution by practicing through exponentially many configurations? Both extremes are not impossible, but often impractical. Players rather build a physical understanding by experience (McCloskey, 1983; Kubricht et al., 2017) and plan by making intuitive, yet accurate predictions in the long-term. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning such a long-term prediction model is arguably the “Achilles’ heel” of modern machine learning methods. Current approaches on learning physical dynamics of the world cleverly side-step the long-term dependency by re-planning at each step via model-predictive control (MPC) (Allgöwer & Zheng, 2012; Camacho & Alba, 2013). The common practice is to train short-term dynamical models (usually 1-step) in a simulator. However, small errors in short-term predictions can accumulate over time in MPC. Hence, in this work, we focus primarily on the long-term aspect of prediction by just considering environments, such as the three-cushion billiards example or the PHYRE (Bakhtin et al., 2019) in Figure 1, where an agent is allowed to take only one action in the beginning so as to preclude any scope of re-planning. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/5625a4aae9c47f60c1232de28cfa80e4a0cfdaaf5b122056b2355f22deb483f0.jpg",
+        "image_caption": [
+            "Figure 1: Two example of long-term dynamics prediction tasks. Left: three-cushion billiards. Right: PHYRE intuitive-physics dataset (Bakhtin et al., 2019). Our proposed approach makes accurate long-term predictions that do not necessarily align with the ground truth but provide strong signal for planning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            101,
+            790,
+            256
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            340,
+            825,
+            397
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "How to learn an accurate dynamics model has been a popular research topic for years. Recently, there are a series of work trying to represent video frames using object-centric representations (Battaglia et al., 2016; Watters et al., 2017; Chang et al., 2016; Janner et al., 2019; Ye et al., 2019; Kipf et al., 2020). However, those methods either operate in the state space, or ignore the environment information, both of which are not practical in real-world scenarios. In contrast, our objective is to build a data-driven prediction model that can both: (a) model long-term interactions over time to plan successfully for new instances, and (b) work from raw visual input in complex real-world environments. Therefore, the question we ask is: how to extract such an effective and flexible object representation and perform long-term predictions? ",
+        "bbox": [
+            173,
+            404,
+            825,
+            529
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose Region Proposal Interaction Network (RPIN) which contains two key components. Firstly, we leverage the region of interests pooling (RoIPooling) operator (Girshick, 2015) to extract object features maps from the frame-level feature. Object feature extraction based on region proposals has achieved huge success in computer vision (Girshick, 2015; He et al., 2017; Dai et al., 2017; Gkioxari et al., 2019), and yet, surprisingly under-explored in the field of intuitive physics. By using RoIPooling, each object feature contains not only its own information but also the context of the environment. Secondly, we extend the Interaction Network and propose Convolutional Interaction Networks that perform interaction reasoning on the extracted RoI features. Interaction Networks is originally proposed in (Battaglia et al., 2016), where the interaction reasoning is conducted via MLPs. By changing MLPs to convolutions, we can effectively utilize the spatial information of an object and make accurate future prediction of object location and shapes changes. ",
+        "bbox": [
+            173,
+            535,
+            825,
+            689
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Notably, our approach is simple, yet outperforms the state-of-the-art methods in both simulation and real datasets. In Section 5, we thoroughly evaluate our approach across four datasets to study scientific questions related to a) prediction quality, b) generalization to time horizons longer than training, c) generalization to unseen configurations, d) planning ability for downstream tasks. Our method reduces the prediction error by $7 5 \\%$ in the complex PHYRE environment and achieves state-of-the-art performance on the PHYRE reasoning benchmark. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            780
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            791,
+            344,
+            808
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Physical Reasoning and Intuitive Physics. Learning models that can predict the changing dynamics of the scene is the key to building physical common-sense. Such models date back to “NeuroAnimator” (Grzeszczuk et al., 1998) for simulating articulated objects. Several methods in recent years have leveraged deep networks to build data-driven models of intuitive physics (Bhattacharyya et al., 2016; Ehrhardt et al., 2017; Fragkiadaki et al., 2015; Chang et al., 2016; Stewart & Ermon, 2017). However, these methods either require access to the underlying ground-truth state-space or do not scale to long-range due to absence of interaction reasoning. A more generic yet explicit approach has been to leverage graph neural networks (Scarselli et al., 2009) to capture interactions between entities in a scene (Battaglia et al., 2018; Chang et al., 2016). Closest to our approach are interaction models that scale to pixels and reason about object interaction (Watters et al., 2017; Ye et al., 2019). However, these approaches either reason about object crops with no context around or can only deal with a predetermined number and order of objects. A concurrent work (Girdhar et al., 2020) studies using prediction for physical reasoning, but their prediction model is either in the state space or in the pixel space. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Other common ways to measure physical understanding are to predict future judgments given a scene image, e.g., predicting the stability of a configuration (Groth et al., 2018; Jia et al., 2015; Lerer et al., 2016; Li et al., 2016a;b). Several hybrid methods take a data-driven approach to estimate Newtonian parameters from raw images (Brubaker et al., 2009; Wu et al., 2016; Bhat et al., 2002; Wu et al., 2015), or model Newtonian physics via latent variable to predict motion trajectory in images (Mottaghi et al., 2016a;b; Ye et al., 2018). An extreme example is to use an actual simulator to do inference over objects (Hamrick et al., 2011). The reliance on explicit Newtonian physics makes them infeasible on real-world data and un-instrumented settings. In contrast, we take into account the context around each object via RoIPooling and explicitly model their interaction with each other or with the environment without relying on Newtonian physics, and hence, easily scalable to real videos for long-range predictions. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            361
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Video Prediction. Instead of modeling physics from raw images, an alternative is to treat visual reasoning as an image translation problem. This approach has been adopted in the line of work that falls under video prediction. The most common theme is to leverage latent-variable models for predicting future (Lee et al., 2018; Denton & Fergus, 2018; Babaeizadeh et al., 2017). Predicting pixels is difficult so several methods leverage auxiliary information like back/fore-ground (Villegas et al., 2017a; Tulyakov et al., 2017; Vondrick et al., 2016), optical flow (Walker et al., 2016; Liu et al., 2017), appearance transformation (Jia et al., 2016; Finn et al., 2016; Chen et al., 2017; Xue et al., 2016), etc. These inductive biases help in a short interval but do not capture long-range behavior as needed in several scenarios, like playing billiards, due to lack of explicit reasoning. Some approaches can scale to relative longer term but are domain-specific, e.g., pre-defined human-pose space (Villegas et al., 2017b; Walker et al., 2017). However, our goal is to model long-term interactions not only for prediction but also to facilitate planning for downstream tasks. ",
+        "bbox": [
+            173,
+            376,
+            825,
+            542
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Learning Dynamics Models. Unlike video prediction, dynamics models take actions into account for predicting the future, also known as forward models (Jordan & Rumelhart, 1992). Learning these forward dynamics models from images has recently become popular in robotics for both specific tasks (Wahlström et al., 2015; Agrawal et al., 2016; Oh et al., 2015; Finn et al., 2016) and exploration (Pathak et al., 2017; Burda et al., 2019). In contrast to these methods where a deep network directly predicts the whole outcome, we leverage our proposed region-proposal interaction module to capture each object trajectories explicitly to learn long-range forward dynamics as well as video prediction models. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            669
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Planning via Learned Models. Leveraging models to plan is the standard approach in control for obtaining task-specific behavior. Common approach is to re-plan after each action via Model Predictive Control (Allgöwer & Zheng, 2012; Camacho & Alba, 2013; Deisenroth & Rasmussen, 2011). Scaling the models and planning in a high dimensional space is a challenging problem. With deep learning, several approaches shown promising results on real-world robotic tasks (Finn et al., 2016; Finn & Levine, 2017; Agrawal et al., 2016; Pathak et al., 2018). However, the horizon of these approaches is still very short, and replanning in long-term drifts away in practice. Some methods try to alleviate this issue via object modeling (Janner et al., 2019; Li et al., 2019) or skip connections (Ebert et al., 2018a) but assume the models are trained with state-action pairs. In contrast to prior works where a short-range dynamic model is unrolled in time, we learn our long-range models from passive data and then couple them with short-range forward models to infer actions during planning. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            838
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 REGION PROPOSAL INTERACTION NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            854,
+            591,
+            871
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our model takes $N$ video frames and the corresponding object bounding boxes as inputs, and outputs the objects’ bounding boxes and masks for the future $T$ timesteps. The overall model structure is illustrated in Figure 2. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/19d566559141436db945d2174916ecbf1ddaefb8284bcb860135b0361e2e770c.jpg",
+        "image_caption": [
+            "Figure 2: Our Region Proposal Interaction Network. Given $N$ frames as inputs, we forward them to an encoder network, and then extract the foreground object features with RoIPooling (different colors represent different instances). We then perform interaction reasoning on top of the region proposal features (gray box on the bottom right). We predict each future object feature based on the previous $k$ time steps. We then estimate the object location from each object feature. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            101,
+            810,
+            284
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For each frame, we first extract the image features using a ConvNet. Then we apply RoIPooling (Girshick, 2015; He et al., 2017) to obtain the object-centric visual features. These features are then forwarded to our Convolutional Interaction Networks (CIN) to perform objects’ interaction reasoning and used to predict future object bounding boxes and masks. The whole pipeline is trained end-to-end by minimizing the loss between the predicted outputs and the ground-truth. ",
+        "bbox": [
+            173,
+            375,
+            825,
+            445
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 OBJECT-CENTRIC REPRESENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            457,
+            465,
+            470
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We apply the houglass network (Newell et al., 2016) to extract the image features. Given an input RGB image $I \\in \\breve { \\mathbb { R } } ^ { 3 \\times H \\times W }$ , the hourglass network firstly downsample the input via one 2-strided convolution and 2-strided max pooling layers, and then refine the representation by a U-Net-like encoder-decoder modules (Ronneberger et al., 2015). The hourglass network provides features with a large receptive field and a fine spatial resolution (4 times smaller than the input image), both of which are crucial to accurately model object-object and object-environment interactions. We denote the number of output channels of the feature map as $d$ . ",
+        "bbox": [
+            173,
+            476,
+            825,
+            573
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "On top of this feature map, we use RoIPooling (Girshick, 2015) to extract a $d \\times h \\times w$ objectcentric features. RoIPooling takes the feature map and a object bounding box as input. The region corresponding to the bounding box on the feature map is cropped and resize to a fixed spatial size (denoted as $h \\times w$ ). We use $\\boldsymbol { x } _ { i } ^ { t }$ to represent the feature at $t$ -th timestep for the $i$ -th object. Such feature representation differs from previous method in two perspectives: 1) It is extracted from image features with a large receptive field, which gives plenty of context information around the object. 2) The feature representation is a 3-dimensional feature map rather than a single vector representation. It can represent the objects’ shapes while the vector representation cannot because the spatial dimension is flattened. ",
+        "bbox": [
+            173,
+            580,
+            825,
+            705
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 CONVOLUTIONAL INTERACTION NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            715,
+            524,
+            729
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To better utilize the spatial information of our object feature map, we propose Convolutional Interaction Networks, an extension of Interaction Network operators on 3-dimensional tensors. In this section, we first briefly review the original Interaction Network (IN) (Battaglia et al., 2016; Watters et al., 2017) and introduce the proposed Convolutional Interaction Networks (CIN). ",
+        "bbox": [
+            174,
+            736,
+            825,
+            791
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The original interaction network is a general-purpose data-driven method to model and predict physical dynamics. It takes the feature vectors of $m$ objects at timestep $t$ : $X = \\{ x _ { 1 } ^ { t } , x _ { 2 } ^ { t } , . . . , x _ { m } ^ { \\hat { t } } \\mid x _ { i } ^ { t } \\in \\bar { \\mathbb { R } } ^ { d } \\}$ and performs object reasoning $f _ { O }$ as well as relational reasoning $f _ { R }$ on these features. Specifically, the updated rule of object features can be described as: ",
+        "bbox": [
+            173,
+            799,
+            826,
+            854
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/acb2f9c6263005e18846f3081fe5543ab0b5272ebc1e0dc0e6beae6d4ca494a6.jpg",
+        "text": "$$\n\\begin{array} { r l } & { e _ { i } ^ { t } = f _ { A } \\big ( f _ { O } ( x _ { i } ^ { t } ) + \\sum _ { j \\neq i } f _ { R } ( x _ { i } ^ { t } , x _ { j } ^ { t } ) \\big ) , } \\\\ & { z _ { i } ^ { t } = f _ { Z } ( x _ { i } ^ { t } , e _ { i } ^ { t } ) , } \\\\ & { x _ { i } ^ { t + 1 } = f _ { P } \\big ( z _ { i } ^ { t } , z _ { i } ^ { t - 1 } , \\dots , z _ { i } ^ { t - k } \\big ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            859,
+            635,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the above equation, $f _ { A }$ is the function to calculate the effect of both of object reasoning and relational reasoning results. And $f _ { Z }$ is used to combine the original object state and the reasoning effect. Finally, $f _ { P }$ is used to do future state predictions based on one or more previous object states. In IN, $f _ { O , R , A , Z , P }$ are instantiated by a fully-connected layer with learnable weights. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Convolutional Interaction Networks. The input of CIN is $m$ object feature maps at timestep $t$ : $X = \\{ x _ { 1 } ^ { t } , x _ { 2 } ^ { t } , . . . , x _ { m } ^ { t } | x _ { i } ^ { t } \\in \\mathbb { R } ^ { d \\times h \\times w } \\}$ . The high-level update rule is the same as IN, but the key difference is that we use convolution to instantiate $f _ { O , R , A , Z , P }$ . Such instantiation is crucial to utilize the spatial information encoded in our object feature map and to effectively reason future object states. Specifically, we have ",
+        "bbox": [
+            176,
+            166,
+            825,
+            236
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/20621f3512e9e9f0213f9a8b079f53dbfbc18c9b7fa48b914ba280017c3cbf6e.jpg",
+        "text": "$$\n\\begin{array} { c c } { f _ { R } ( x _ { i } ^ { t } , x _ { j } ^ { t } ) = W _ { R } * [ x _ { i } ^ { t } , x _ { j } ^ { t } ] } & { f _ { O } ( x _ { i } ^ { t } ) = W _ { O } * x _ { i } ^ { t } } \\\\ { f _ { A } ( x _ { i } ^ { t } ) = W _ { A } ^ { T } * x _ { i } ^ { t } } & { f _ { Z } ( x _ { i } ^ { t } , e _ { i } ^ { t } ) = W _ { Z } * [ x _ { i } ^ { t } , e _ { i } ^ { t } ] } \\\\ { f _ { P } ( z _ { i } ^ { t } , z _ { i } ^ { t - 1 } , . . . , z _ { i } ^ { t - k } ) = W _ { P } * [ z _ { i } ^ { t } , z _ { i } ^ { t - 1 } , . . . , z _ { i } ^ { t - k } ] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            242,
+            699,
+            310
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "One can plug the functions in Equation 1 for better understanding the operations. In the above equations, $^ *$ denotes the convolution operator, and $[ \\cdot , \\cdot ]$ denotes concatenation along the channel dimension. $W _ { R } , W _ { Z } \\in \\mathbb { R } ^ { d \\times 2 d \\times 3 \\times 3 }$ , $W _ { O } , W _ { A } \\in \\mathbb { R } ^ { d \\times d \\times 3 \\times 3 }$ , $W _ { P } \\in \\mathbb { R } ^ { d \\times ( k d ) \\times 3 \\times 3 }$ are learnable weights of the convolution kernels with kernel size $3 \\times 3$ . We also add ReLU activation after each of the convolutional operators. ",
+        "bbox": [
+            173,
+            319,
+            826,
+            392
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 LEARNING REGION PROPOSAL INTERACTION NETWORKS (RPIN) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            402,
+            673,
+            417
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our model predicts the future bounding box and (optionally) masks of each object. Given the predicted feature $\\boldsymbol { x } _ { i } ^ { t + 1 }$ , we use a simple two layer MLP decoder to estimate its bounding boxes coordinates and masks. The bounding box decoder takes a flattened object feature map as input. It firstly projects it to $d$ dimensional vector, and outputs 4-d vector, representing the center location and size of the box. The mask decoder is of the same architecture but has $2 1 \\times 2 1$ output channels, representing a $2 1 \\times 2 1$ binary masks inside the corresponding bounding boxes. We use the $\\ell ^ { 2 }$ loss for bounding box predictions. For mask prediction, we use spatial cross-entropy loss which sums the cross-entropy values of a $2 1 \\times 2 1$ predicted positions. The objective can be written as: ",
+        "bbox": [
+            173,
+            422,
+            826,
+            535
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/06bb11307f2db06390766e78d948efd63e255df6301abb6d361df3262f392f60.jpg",
+        "text": "$$\nL _ { p } = \\sum _ { t = 1 } ^ { T } \\lambda _ { t } \\sum _ { i = 1 } ^ { n } \\Big ( \\| \\hat { B } _ { i } ^ { t + 1 } - B _ { i } ^ { t + 1 } \\| _ { 2 } ^ { 2 } + C E ( \\hat { M } _ { i } ^ { t + 1 } , M _ { i } ^ { t + 1 } ) \\Big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            539,
+            699,
+            583
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use discounted loss during training (Watters et al., 2017) to mitigate the effect of inaccurate prediction at early training stage and $\\lambda _ { t }$ is the discounted factor. ",
+        "bbox": [
+            174,
+            597,
+            823,
+            626
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            638,
+            398,
+            655
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We evaluate our method’s prediction performance on four different datasets, and demonstrate the ability to perform downstream physical reasoning and planning tasks on two of them. We briefly introduce the four datasets below. The full dataset details are in the appendix. ",
+        "bbox": [
+            174,
+            665,
+            823,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "PHYRE: We use the BALL-tier of the PHYRE benchmark (Bakhtin et al., 2019). In this dataset, we set $T = 5$ . We treat all of the moving balls or jars as objects and other static bodies as background. The benchmark provides two evaluation settings: 1) within task generalization (PHYRE-W), where the testing environments contain the same object category but different sizes and positions; 2) cross task generalization (PHYRE-C), where environments containing objects and context never present during training. We report prediction using the official fold 0 and the physical reasoning performance averaged on 10 folds. ",
+        "bbox": [
+            173,
+            713,
+            825,
+            811
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "ShapeStacks (SS): This dataset contains multiple stacked objects (cubes, cylinders, or balls) (Ye et al., 2019). In this dataset, we set $T = 1 5$ . We evaluate all baselines and our methods follow the protocol of (Ye et al., 2019) with uncertainty estimation incorporated (see Appendix for detail). ",
+        "bbox": [
+            174,
+            819,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Real World Billiards (RealB): We collect “Three-cushion Billiards” videos from professional games with different viewpoints downloaded from YouTube. There are 62 training videos with 18, 306 frames, and 5 testing videos with 1, 995 frames. The bounding box annotations are from an offthe-shelf ResNet-101 FPN detector (Lin et al., 2017) pretrained on COCO (Lin et al., 2014) and fine-tuned on a subset of 30 images from our dataset. We manually filtered out wrong detections. In this dataset, we set $T = 2 0$ . ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            131
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Simulation Billiards (SimB): We create a simulated billiard environment with three different colored balls with a radius 2 are randomly placed in a $6 4 \\times 6 4$ image. At starting point, one ball is moving with a randomly sampled velocity. We generate 1,000 video sequences for training and 1,000 video sequences for testing, with 100 frames per sequence. We will also evaluate the ability to generalize to more balls and different sized balls in the experiment section. In this dataset, we set $T = 2 0$ . ",
+        "bbox": [
+            174,
+            138,
+            823,
+            208
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For PHYRE and SS, it is possible to infer the future from just the initial configuration. So we set $N = 1$ in these two datasets. For SimB and RealB, the objects are moving in a flat table so we cannot infer the future trajectories based on a single image. Therefore in this setting, we set $N = 4$ to infer the velocity/acceleration of objects. We set $k = N$ in all the dataset because we only have access to $N$ features when we make prediction at $t = N + 1$ . We predict object masks for PHYRE and ShapeStacks, and only predict bounding boxes for Billiard datasets. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            299
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines. There are a large amount of work studying how to estimate objects’ states and predict their dynamics from raw image inputs. They fall into the following categories: ",
+        "bbox": [
+            173,
+            306,
+            821,
+            334
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "VIN: Instead of using object-centric spatial pooling to extract object features, it use a ConvNet to globally encode an image to a fixed $d \\times m$ dimensional vector. Different channels of the vector is assigned to different objects (Kipf et al., 2020; Watters et al., 2017). This approach requires specifying a fixed number of objects and a fixed mapping between feature channels and object identity, which make it impossible to generalize to different number of objects and different appearances. ",
+        "bbox": [
+            174,
+            342,
+            825,
+            411
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Object Masking (OM): This approach takes one image and $m$ object bounding boxes or masks as input (Wu et al., 2017; Veerapaneni et al., 2019; Janner et al., 2019). For each proposal, only the pixels inside object proposals are kept while others are set to 0, leading to $m$ masked images. This approach assumes no background information is needed thus fails to predict accurate trajectories in complex environments such as PHYRE. And it also cost $m$ times computational resources. ",
+        "bbox": [
+            174,
+            417,
+            823,
+            488
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "CVP: The object feature is extracted by cropping the object image patch and forwarding it to an encoder (Ye et al., 2019; Yi et al., 2020). Since the object features are directly extracted from the raw image patches, the context information is also ignored. We re-implement CVP’s feature extraction method within our framework. We show we can reproduce their results in Section A.2. ",
+        "bbox": [
+            174,
+            494,
+            823,
+            550
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EVALUATION RESULTS: PREDICTION, GENERALIZATION, AND PLANNING ",
+        "bbox": [
+            174,
+            569,
+            816,
+            585
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We organize this section and analyze our results by discussing four scientific questions related to the prediction quality, generalization ability across time & environment configurations, and the ability to plan actions for downstream tasks. ",
+        "bbox": [
+            174,
+            597,
+            823,
+            638
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 HOW ACCURATE IS THE PREDICTED DYNAMICS? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            659,
+            547,
+            671
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To evaluate how well the world dynamics is modeled, we first report the average prediction errors on the test split, over the same time-horizon as which model is trained on, i.e., $t \\in [ 0 , T _ { \\mathrm { t r a i n } } ]$ . The prediction error is calculated by the squared $\\ell _ { 2 }$ distance between predicted object center location and the ground-truth object centers. The results are shown in Table 1 (left half). ",
+        "bbox": [
+            174,
+            680,
+            825,
+            736
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Firstly, we show the effectiveness of our proposed RoI Feature by comparing Table 1 VIN, OM, CVP, and Ours (IN). These four entries use the same backbone network and interaction network modules and only visual encoder is changed. Among them, VIN cannot even be trained on PHYRE-W since it cannot handle varying number of objects. The OM method performs slightly better than other baselines since it also explicitly models objects by instance masking. For CVP, it cannot produce reasonable results on all of the datasets except on the SS dataset. The reason is that in PHYRE and billiard environments, cropped images are unaware of environment information and the relative position and pose of different objects, making it impossible to make accurate predictions. In SS, since the object size is large and objects are very close to each other, the cropped image regions already provide enough context. In contrast, our RoI Feature can implicitly encode the context and environment information and it performs much better than all baselines. In the very challenging PHYRE dataset, the prediction error is only $1 / 4$ of the best baseline. In the other three easier datasets, the gap is not as large since the environment is less complicated, but our method still achieves ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/e8978241f8e12ee992b116aed5b9805c5b794ef308b29af359b9de918009a725.jpg",
+        "table_caption": [
+            "Table 1: We compare our method with different baselines on all four datasets. The left part shows the prediction error when rollout timesteps is the same as training time. The right part shows the generalization ability to longer horizon unseen during training. The error is scaled by 1,000. Our method has significantly improvements on all of the datasets "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">method</td><td rowspan=\"2\">visual encoder</td><td colspan=\"3\">t ∈ [0,Ttrain]</td><td rowspan=\"2\"></td><td colspan=\"3\">t ∈[Ttrain,2 × Ttrain]</td></tr><tr><td>PHYRE-W</td><td>sS RealB</td><td>SimB</td><td>PHYRE-W ss</td><td>RealB</td><td>SimB</td></tr><tr><td>VIN</td><td>Global Encoding</td><td>N.A.</td><td>2.47</td><td>1.02</td><td>3.89</td><td>N.A.</td><td>7.77 5.11</td><td>29.51</td></tr><tr><td>OM</td><td>Masked Image</td><td>6.45</td><td>3.01</td><td>0.59 3.48</td><td>25.72</td><td>9.51</td><td>3.23</td><td>28.87</td></tr><tr><td>CVP</td><td>Cropped Image</td><td>60.12</td><td>2.84</td><td>3.57</td><td>80.01</td><td>79.11 7.72</td><td>6.63</td><td>108.56</td></tr><tr><td>Ours (IN)</td><td>RoI Feature</td><td>1.50</td><td>1.85</td><td>0.37</td><td>3.01</td><td>12.45 4.89</td><td>2.72</td><td>27.88</td></tr><tr><td>Ours (CIN)</td><td>RoI Feature</td><td>1.31</td><td>1.03</td><td>0.30</td><td>2.55</td><td>11.10 4.73</td><td>2.34</td><td>25.77</td></tr></table>",
+        "bbox": [
+            205,
+            101,
+            789,
+            224
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/24a1d1d978ce8402f6243581c8fb72ffc7215b4eee77da1487bce904debebb13.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>method</td><td>visual encoder</td><td>PHYRE-C SS-4 SimB-5</td></tr><tr><td>VIN</td><td>Global Encoding</td><td>N.A. N.A. N.A.</td></tr><tr><td>OM</td><td>Masked Image</td><td>50.28 17.02 59.70</td></tr><tr><td>CVP</td><td>Cropped Image</td><td>99.26 16.88 113.39</td></tr><tr><td>Ours (IN)</td><td>RoI Feature</td><td>10.98 15.02 24.42</td></tr><tr><td>Ours (CIN)</td><td>RoI Feature</td><td>9.22 14.61 22.38</td></tr></table>",
+        "bbox": [
+            318,
+            300,
+            674,
+            410
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2: The ability to generalize to novel environments. We show the average prediction error for $t \\in [ 0 , 2 \\times T _ { \\mathrm { t r a i n } } ]$ . Our method achieves significantly better results compared to previous methods. The error is scaled by 1,000. Our method generalizes much better than other baselines. ",
+        "bbox": [
+            176,
+            419,
+            825,
+            462
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "more than $10 \\%$ improvements. These results clearly demonstrates the advantage of using rich state representations. ",
+        "bbox": [
+            173,
+            478,
+            823,
+            507
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Secondly, we show that the effectiveness of our proposed Convolutional Interaction Network by comparing Table 1 Ours (IN) and Ours (CIN). With every other components the same, changing the vector-form representation to spatial feature maps and use convolution to model the interactions can further improve the performance by $10 \\% { \\sim } 4 0 \\%$ . This result shows our convolutional interaction network could better utilize the spatial information encoded in the object feature map. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            583
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 DOES LEARNED MODEL GENERALIZE TO LONGER HORIZON THAN TRAINING? ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            598,
+            751,
+            611
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Generalize to longer horizons is a challenging task. In this section we compare the performance of predicting trajectories longer than training time. In Table 1 (right half), we report the prediction error for $t \\in [ \\bar { T } _ { \\mathrm { t r a i n } } , 2 \\times T _ { \\mathrm { t r a i n } } ]$ . The results in this setting are consistent with what we found in Section 5.1. Our method still achieves the best performance against all baselines. Specifically, for all datasets except SimB, we reduce the error by more than $30 \\%$ percent. In SimB, the improvement is not as significant because the interaction with environment only includes bouncing off the boundaries (see Figure 4 (c) and (d)). Meanwhile, changing IN to CIN further improve the performance. This again validates our hypothesis that the key to making accurate long-term feature prediction is the rich state representation extracted from an image. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            743
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 DOES LEARNED MODEL GENERALIZE TO UNSEEN CONFIGURATIONS? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            757,
+            692,
+            770
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The general applicability of RoI Feature has been extensively verified in the computer vision community. As one of the benefits, our method can generalize to novel environments configurations without any modifications or online training. We test such a claim by testing on several novel environments unseen during training. Specifically, we construct 1) simulation billiard dataset contains 5 balls with radius 2 (SimB-5); 2) PHYRE-C where the test tasks are not seen during training; 3) ShapeStacks with 4 stacked blocks (SS-4). The results are shown in Table 2. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Since VIN needs a fixed number of objects as input, it cannot generalize to a different number of objects, thus we don’t report its performance on SimB-5, PHYRE-C, and SS-4. In the SimB-5 and PHYRE-C setting, where generalization ability to different numbers and different appearances is required, our method reduce the prediction error by $7 5 \\%$ . In SS-4, the improvement is not as significant as the previous two because cropped image may be enough on this simpler dataset as mentioned above. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/7beace613bc020608801052c89f18747fd9be818952f8c7a379d6c9c7420a4fe.jpg",
+        "table_caption": [
+            "Table 3: PHYRE Planning results. RAND stands for a score function with random policy. We show that our method achieves state-ofthe-art on both within-task generalization as well as cross-task generalization. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Within</td><td>Cross</td></tr><tr><td>RAND</td><td>13.7±0.5</td><td>13.0±5.0</td></tr><tr><td>DQN</td><td>77.6±1.1</td><td>36.8±9.7</td></tr><tr><td>Ours</td><td>85.2±0.7</td><td>42.2±7.1</td></tr></table>",
+        "bbox": [
+            215,
+            112,
+            419,
+            185
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/1ae42b21e1b94441e8e221df5f318c0df61a2557097a77564e791cc14f84c7aa.jpg",
+        "table_caption": [
+            "Table 4: Simulation Billiards planning results. To make a fair comparison, all of baselines and our methods are using the original interaction network and only the visual encoding method is changing. RAND stands for a policy taking random actions. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Target State Error</td><td>Hitting Accuracy</td></tr><tr><td>RAND</td><td>36.91</td><td>9.50%</td></tr><tr><td>CVP</td><td>29.84</td><td>20.3%</td></tr><tr><td>VIN</td><td>9.11</td><td>51.2%</td></tr><tr><td>OM</td><td>8.75</td><td>54.5%</td></tr><tr><td>Ours</td><td>7.62</td><td>57.2%</td></tr></table>",
+        "bbox": [
+            514,
+            90,
+            774,
+            200
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            299,
+            823,
+            327
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 HOW WELL CAN THE LEARNED MODEL BE USED FOR PLANNING ACTIONS? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            339,
+            730,
+            353
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The advantage of using a general purpose task-agnostic prediction model is that it can help us do downstream planning and reasoning tasks. In this section, we evaluate our prediction model in the recently proposed challenging PHYRE benchmark (Bakhtin et al., 2019) and simulation billiards planning tasks. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            415
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "PHYRE. We use the B-tier of the environment. In this task, we need to place one red ball at a certain location such that the green ball touches another blue/purple object (see figure 1 right for an example). Bakhtin et al. (2019) trains a classification network whose inputs are the first image and a candidate action, and outputs whether the action leads to success. Such a method does not utilize the dynamics information. In contrast, we can train a classifier on top of the predicted objects’ features so that it can utilize dynamics information and makes more accurate classification. ",
+        "bbox": [
+            174,
+            422,
+            825,
+            506
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "During training, we use the same prediction model as described in previous sections except for $T _ { \\mathrm { t r a i n } } = 1 0$ , and then attach an extra classifier on the objects’ features. Specifically, we concatenate each object’s features at the 0th, 3rd, 6th, and 9th timestep and then pass it through two fullyconnected layers to get a feature trajectory for each object. Then we take the average of all the objects’ features and pass it through one fully-connected layer to get a score indicating whether this placement solve the task. We minimize the cross-entropy loss between the score and the ground-truth label indicating whether the action is a success. Note that different from previous work (Bakhtin et al., 2019; Girdhar et al., 2020), our model does not need to convert the input image to the 7-channel segmentation map since object information is already utilized by our object-centric representation. During testing, We enumerate the first 10,000 actions from the pre-computed action set in Bakhtin et al. (2019) and render the red ball on the initial image as our prediction model’s input. Our final output is an sorted action list according to the model’s output score. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            679
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We report the AUCCESS metric on the official 10 folds of train/test splits for both within-task generalization and cross-task generalization setting. The results are in Table 3. Our method achieves about 8 points improvement over the strong DQN baseline (Bakhtin et al., 2019) in the withintask generalization setting. On the more challenging setting of cross-task generalization where the environments may not be seen during training, our method is 6 points higher than DQN. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            756
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "SimB Planning. We consider two tasks in the SimB environment: 1) Billiard Target State. Given an initial and final configuration after 40 timesteps, the goal is to find one action that will lead to the target configuration. We report the smallest distances between the trajectory between timestep 35-45 and the final position. 2) Billiard Hitting. Given the initial configurations, the goal is to find an action that can hit the other two balls within 50 timesteps. ",
+        "bbox": [
+            174,
+            762,
+            823,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We firstly train a forward model taken image and action as input, to predict the first 4 object positions and render it to image. After that the rendered images are passed in our prediction model. We score each action according to the similarity between the generated trajectory and the goal state. Then the action with the highest score is selected. The results are shown in Table 4. Our results achieves best performance on all tasks. The full planning algorithm and implementation details are included in the appendix. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/d2f7e576d8d7fe742bce84281066ea6d0abae4d18ceb29d317b44eab945243b3.jpg",
+        "image_caption": [
+            "Figure 3: We show the qualitative comparisons between our method and other baselines in the PHYRE benchmark. Our model can accurately infer objects’ interactions and collisions with the environment over a long-range (10s), while the baseline methods cannot (the balls sometimes penetrates other objects). In this visualization, only the moving objects’ location and masks are predicted (the color is taken from the simulator). Static environment parts (with black color) are rendered from the initial image. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            99,
+            826,
+            356
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/0b41d50c27cc9b6937b35a3119bc78bc8cf402bfc6746959eea4c38dcc388422.jpg",
+        "image_caption": [
+            "Figure 4: We show the qualitative results of our predicted trajectories in the other three (RealB, SimB, and SS) datasets. Our model could produce accurate and plausible predictions on different scenarios. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            479,
+            825,
+            641
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.5 QUALITATIVE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            715,
+            377,
+            729
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In figure 3, we show the qualitative prediction results both for our method as well as the OM and CVP baselines. In figure 4, we compare our prediction and ground-truth on the other three datasets. More results and videos are available at our Website. ",
+        "bbox": [
+            174,
+            739,
+            825,
+            781
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            809,
+            328,
+            824
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we leverage the modern computer vision techniques to propose Region Proposal Interaction Networks for physical interaction reasoning with visual inputs. We show that our general, yet simple method achieves a significant improvement and can generalize across both simulation and real-world environments for long-range prediction and planning. We believe this method may serve as a good benchmark for developing future methods in the field of learning intuitive physics, as well as their application to real-world robotics. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            357,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work is supported in part by DARPA MCS and DARPA LwLL. We would like to thank the members of BAIR for fruitful discussions and comments. ",
+        "bbox": [
+            174,
+            133,
+            823,
+            162
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nPulkit Agrawal, Ashvin V Nair, Pieter Abbeel, Jitendra Malik, and Sergey Levine. Learning to poke by poking: Experiential learning of intuitive physics. In NeurIPS, 2016. 3   \nFrank Allgöwer and Alex Zheng. Nonlinear model predictive control. Birkhäuser, 2012. 1, 3   \nMohammad Babaeizadeh, Chelsea Finn, Dumitru Erhan, Roy H Campbell, and Sergey Levine. Stochastic variational video prediction. ICLR, 2017. 3   \nAnton Bakhtin, Laurens van der Maaten, Justin Johnson, Laura Gustafson, and Ross Girshick. Phyre: A new benchmark for physical reasoning. In NeurIPS, 2019. 2, 5, 8, 15, 16   \nPeter Battaglia, Razvan Pascanu, Matthew Lai, Danilo Jimenez Rezende, et al. Interaction networks for learning about objects, relations and physics. In NeurIPS, 2016. 1, 2, 4   \nPeter W Battaglia, Jessica B Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, et al. Relational inductive biases, deep learning, and graph networks. arXiv, 2018. 3   \nKiran S Bhat, Steven M Seitz, Jovan Popovic, and Pradeep K Khosla. Computing the physical ´ parameters of rigid-body motion from video. In ECCV, 2002. 3   \nApratim Bhattacharyya, Mateusz Malinowski, Bernt Schiele, and Mario Fritz. Long-term image boundary extrapolation. arXiv, 2016. 2   \nMarcus A Brubaker, Leonid Sigal, and David J Fleet. Estimating contact dynamics. In ICCV. IEEE, 2009. 3   \nYuri Burda, Harri Edwards, Deepak Pathak, Amos Storkey, Trevor Darrell, and Alexei A. Efros. Large-scale study of curiosity-driven learning. In ICLR, 2019. 3   \nEduardo F Camacho and Carlos Bordons Alba. Model predictive control. Springer Science & Business Media, 2013. 1, 3   \nMichael B Chang, Tomer Ullman, Antonio Torralba, and Joshua B Tenenbaum. A compositional object-based approach to learning physical dynamics. ICLR, 2016. 1, 2, 3   \nBaoyang Chen, Wenmin Wang, and Jinzhuo Wang. Video imagination from a single image with transformation generation. In ACMMM Workshop, 2017. 3   \nKenneth James Williams Craik. The nature of explanation. CUP Archive, 1952. 1   \nJifeng Dai, Haozhi Qi, Yuwen Xiong, Yi Li, Guodong Zhang, Han Hu, and Yichen Wei. Deformable convolutional networks. In ICCV, 2017. 2   \nMarc Deisenroth and Carl E Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In ICML, 2011. 3   \nEmily Denton and Rob Fergus. Stochastic video generation with a learned prior. In ICML, 2018. 1, 3   \nFrederik Ebert, Sudeep Dasari, Alex X Lee, Sergey Levine, and Chelsea Finn. Robustness via retrying: Closed-loop robotic manipulation with self-supervised learning. arXiv, 2018a. 3   \nFrederik Ebert, Chelsea Finn, Sudeep Dasari, Annie Xie, Alex Lee, and Sergey Levine. Visual foresight: Model-based deep reinforcement learning for vision-based robotic control. arXiv, 2018b. 1 ",
+        "bbox": [
+            171,
+            161,
+            828,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sebastien Ehrhardt, Aron Monszpart, Niloy J Mitra, and Andrea Vedaldi. Learning a physical long-term predictor. arXiv, 2017. 2 ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn and Sergey Levine. Deep visual foresight for planning robot motion. In ICRA, 2017. 3 ",
+        "bbox": [
+            173,
+            140,
+            825,
+            156
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Ian Goodfellow, and Sergey Levine. Unsupervised learning for physical interaction through video prediction. In NeurIPS, 2016. 3 ",
+        "bbox": [
+            176,
+            164,
+            823,
+            194
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Katerina Fragkiadaki, Pulkit Agrawal, Sergey Levine, and Jitendra Malik. Learning visual predictive models of physics for playing billiards. ICLR, 2015. 2, 15 ",
+        "bbox": [
+            173,
+            202,
+            823,
+            231
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rohit Girdhar, Laura Gustafson, Aaron Adcock, and Laurens van der Maaten. Forward prediction for physical reasoning. arXiv, 2020. 3, 8 ",
+        "bbox": [
+            171,
+            239,
+            825,
+            267
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ross Girshick. Fast R-CNN. In ICCV, 2015. 2, 4 ",
+        "bbox": [
+            173,
+            275,
+            501,
+            291
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Georgia Gkioxari, Jitendra Malik, and Justin Johnson. Mesh R-CNN. In ICCV, 2019. 2 ",
+        "bbox": [
+            169,
+            299,
+            751,
+            315
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oliver Groth, Fabian Fuchs, Ingmar Posner, and Andrea Vedaldi. Shapestacks: Learning vision-based physical intuition for generalised object stacking. In ECCV, 2018. 3 ",
+        "bbox": [
+            174,
+            323,
+            826,
+            353
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Radek Grzeszczuk, Demetri Terzopoulos, and Geoffrey Hinton. Neuroanimator: Fast neural network emulation and control of physics-based models. In SIGGRAPH, 1998. 2 ",
+        "bbox": [
+            174,
+            361,
+            825,
+            390
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jessica Hamrick, Peter Battaglia, and Joshua B Tenenbaum. Internal physics models guide probabilistic judgments about object dynamics. In COGSCI, 2011. 3 ",
+        "bbox": [
+            174,
+            398,
+            823,
+            428
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Georgia Gkioxari, Piotr Dollár, and Ross Girshick. Mask R-CNN. In ICCV, 2017. 2, 4 ",
+        "bbox": [
+            174,
+            435,
+            821,
+            452
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Janner, Sergey Levine, William T Freeman, Joshua B Tenenbaum, Chelsea Finn, and Jiajun Wu. Reasoning about physical interactions with object-oriented prediction and planning. ICLR, 2019. 2, 3, 6 ",
+        "bbox": [
+            174,
+            459,
+            823,
+            502
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dinesh Jayaraman, Frederik Ebert, Alexei A Efros, and Sergey Levine. Time-agnostic prediction: Predicting predictable video frames. In ICLR, 2019. 1 ",
+        "bbox": [
+            174,
+            511,
+            823,
+            540
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xu Jia, Bert De Brabandere, Tinne Tuytelaars, and Luc V Gool. Dynamic filter networks. In NeurIPS, 2016. 3 ",
+        "bbox": [
+            171,
+            547,
+            825,
+            577
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhaoyin Jia, Andrew C Gallagher, Ashutosh Saxena, and Tsuhan Chen. 3d reasoning from blocks to stability. PAMI, 2015. 3 ",
+        "bbox": [
+            173,
+            585,
+            825,
+            614
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael I Jordan and David E Rumelhart. Forward models: Supervised learning with a distal teacher. Cognitive science, 1992. 3 ",
+        "bbox": [
+            173,
+            622,
+            823,
+            651
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv, 2014. 15 ",
+        "bbox": [
+            169,
+            660,
+            818,
+            676
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational bayes. ICLR, 2014. 14 ",
+        "bbox": [
+            174,
+            684,
+            758,
+            700
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thomas Kipf, Elise van der Pol, and Max Welling. Contrastive learning of structured world models. ICLR, 2020. 2, 6 ",
+        "bbox": [
+            174,
+            707,
+            821,
+            738
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "James R Kubricht, Keith J Holyoak, and Hongjing Lu. Intuitive physics: Current research and controversies. Trends in cognitive sciences, 2017. 1 ",
+        "bbox": [
+            173,
+            746,
+            823,
+            775
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex X Lee, Richard Zhang, Frederik Ebert, Pieter Abbeel, Chelsea Finn, and Sergey Levine. Stochastic adversarial video prediction. arXiv, 2018. 1, 3 ",
+        "bbox": [
+            171,
+            782,
+            823,
+            813
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Lerer, Sam Gross, and Rob Fergus. Learning physical intuition of block towers by example. In ICML, 2016. 3 ",
+        "bbox": [
+            173,
+            820,
+            825,
+            849
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wenbin Li, Seyedmajid Azimi, Aleš Leonardis, and Mario Fritz. To fall or not to fall: A visual approach to physical stability prediction. arXiv, 2016a. 3 ",
+        "bbox": [
+            173,
+            858,
+            823,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wenbin Li, Aleš Leonardis, and Mario Fritz. Visual stability prediction and its application to manipulation. AAAI, 2016b. 3 ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yunzhu Li, Jiajun Wu, Jun-Yan Zhu, Joshua B Tenenbaum, Antonio Torralba, and Russ Tedrake. Propagation networks for model-based control under partial observation. In ICRA, 2019. 3 ",
+        "bbox": [
+            173,
+            103,
+            826,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ECCV, 2014. 5 ",
+        "bbox": [
+            173,
+            142,
+            825,
+            171
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Piotr Dollár, Ross Girshick, Kaiming He, Bharath Hariharan, and Serge Belongie. Feature pyramid networks for object detection. In CVPR, 2017. 5 ",
+        "bbox": [
+            173,
+            180,
+            825,
+            210
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ziwei Liu, Raymond A Yeh, Xiaoou Tang, Yiming Liu, and Aseem Agarwala. Video frame synthesis using deep voxel flow. In ICCV, 2017. 3 ",
+        "bbox": [
+            174,
+            219,
+            823,
+            248
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv, 2016. 15 ",
+        "bbox": [
+            176,
+            258,
+            825,
+            287
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Michael McCloskey. Intuitive physics. Scientific american, 1983. 1 ",
+        "bbox": [
+            173,
+            297,
+            619,
+            314
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Roozbeh Mottaghi, Hessam Bagherinezhad, Mohammad Rastegari, and Ali Farhadi. Newtonian scene understanding: Unfolding the dynamics of objects in static images. In CVPR, 2016a. 3 ",
+        "bbox": [
+            174,
+            323,
+            826,
+            352
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Roozbeh Mottaghi, Mohammad Rastegari, Abhinav Gupta, and Ali Farhadi. “what happens if...” learning to predict the effect of forces in images. In ECCV, 2016b. 3 ",
+        "bbox": [
+            173,
+            362,
+            826,
+            391
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alejandro Newell, Kaiyu Yang, and Jia Deng. Stacked hourglass networks for human pose estimation. In ECCV, 2016. 4, 14 ",
+        "bbox": [
+            174,
+            400,
+            826,
+            429
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-conditional video prediction using deep networks in atari games. In NeurIPS, 2015. 3 ",
+        "bbox": [
+            171,
+            439,
+            823,
+            469
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak, Pulkit Agrawal, Alexei A Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. ICML, 2017. 3 ",
+        "bbox": [
+            173,
+            478,
+            823,
+            507
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak, Parsa Mahmoudieh, Guanghao Luo, Pulkit Agrawal, Dian Chen, Yide Shentu, Evan Shelhamer, Jitendra Malik, Alexei A Efros, and Trevor Darrell. Zero-shot visual imitation. In ICLR, 2018. 3 ",
+        "bbox": [
+            173,
+            517,
+            823,
+            559
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In MICCAI, 2015. 4 ",
+        "bbox": [
+            174,
+            570,
+            821,
+            599
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alvaro Sanchez-Gonzalez, Jonathan Godwin, Tobias Pfaff, Rex Ying, Jure Leskovec, and Peter W Battaglia. Learning to simulate complex physics with graph networks. arXiv, 2020. 1 ",
+        "bbox": [
+            176,
+            608,
+            823,
+            638
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Network, 2009. 3 ",
+        "bbox": [
+            174,
+            647,
+            823,
+            678
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Russell Stewart and Stefano Ermon. Label-free supervision of neural networks with physics and domain knowledge. In AAAI, 2017. 2 ",
+        "bbox": [
+            173,
+            686,
+            823,
+            715
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Tulyakov, Ming-Yu Liu, Xiaodong Yang, and Jan Kautz. Mocogan: Decomposing motion and content for video generation. CVPR, 2017. 3 ",
+        "bbox": [
+            173,
+            726,
+            825,
+            755
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rishi Veerapaneni, John D Co-Reyes, Michael Chang, Michael Janner, Chelsea Finn, Jiajun Wu, Joshua B Tenenbaum, and Sergey Levine. Entity abstraction in visual model-based reinforcement learning. In CoRL, 2019. 6 ",
+        "bbox": [
+            176,
+            763,
+            825,
+            806
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ruben Villegas, Jimei Yang, Seunghoon Hong, Xunyu Lin, and Honglak Lee. Decomposing motion and content for natural video sequence prediction. ICLR, 2017a. 3 ",
+        "bbox": [
+            171,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ruben Villegas, Jimei Yang, Yuliang Zou, Sungryull Sohn, Xunyu Lin, and Honglak Lee. Learning to generate long-term future via hierarchical prediction. ICML, 2017b. 3 ",
+        "bbox": [
+            171,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. In NeurIPS, 2016. 3 ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Niklas Wahlström, Thomas B Schön, and Marc Peter Deisenroth. From pixels to torques: Policy learning with deep dynamical models. ICML, 2015. 3   \nJacob Walker, Carl Doersch, Abhinav Gupta, and Martial Hebert. An uncertain future: Forecasting from static images using variational autoencoders. In ECCV, 2016. 1, 3   \nJacob Walker, Kenneth Marino, Abhinav Gupta, and Martial Hebert. The pose knows: Video forecasting by generating pose futures. In ICCV, 2017. 3   \nNicholas Watters, Daniel Zoran, Theophane Weber, Peter Battaglia, Razvan Pascanu, and Andrea Tacchetti. Visual interaction networks: Learning a physics simulator from video. In NeurIPS, 2017. 2, 3, 4, 5, 6   \nJiajun Wu, Ilker Yildirim, Joseph J Lim, Bill Freeman, and Josh Tenenbaum. Galileo: Perceiving physical object properties by integrating a physics engine with deep learning. In NeurIPS, 2015. 3   \nJiajun Wu, Joseph J Lim, Hongyi Zhang, Joshua B Tenenbaum, and William T Freeman. Physics 101: Learning physical object properties from unlabeled videos. In BMVC, 2016. 3   \nJiajun Wu, Erika Lu, Pushmeet Kohli, Bill Freeman, and Josh Tenenbaum. Learning to see physics via visual de-animation. In NeurIPS, 2017. 6   \nTianfan Xue, Jiajun Wu, Katherine Bouman, and Bill Freeman. Visual dynamics: Probabilistic future frame synthesis via cross convolutional networks. In NeurIPS, 2016. 3   \nTian Ye, Xiaolong Wang, James Davidson, and Abhinav Gupta. Interpretable intuitive physics model. ECCV, 2018. 3   \nYufei Ye, Maneesh Singh, Abhinav Gupta, and Shubham Tulsiani. Compositional video prediction. ICCV, 2019. 2, 3, 5, 6, 14, 15   \nKexin Yi, Chuang Gan, Yunzhu Li, Pushmeet Kohli, Jiajun Wu, Antonio Torralba, and Joshua B Tenenbaum. Clevrer: Collision events for video representation and reasoning. In ICLR, 2020. 6 ",
+        "bbox": [
+            171,
+            99,
+            828,
+            525
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            102,
+            439,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.1 NETWORK ARCHITECTURE DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            135,
+            472,
+            150
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Backbone Networks: We use the same backbone network for our method and all the baselines (VIN, OM, CVP). We choose the hourglass network (Newell et al., 2016) as the image feature extractor. Given an input image, the hourglass network firstly applies a $7 \\times 7$ stride-2 convolution, three residual blocks with channel dimension $d / 4$ , and a stride-2 max pooling on it. Then this intermediate feature representation is fed into one hourglass modules. In the hourglass module, the feature maps are downsampled with 3 stride-2 residual blocks and then up-sampled with nearest neighbor interpolation. The dimensions of both the input channel and the output channel of each residual block are $d$ . For SimB, we use $d = 6 4$ since the visual information in this environment is relatively simple. For RealB, PHYRE, and ShapeStacks, $d = 2 5 6$ . We use batch normalization before each convolutional layer in the backbone network. The resulting feature map size is $d \\times \\frac { H } { 4 } \\times \\frac { W } { 4 }$ , where $H$ , $W$ is the input image size and 4 is the spatial feature stride of the hourglass network. ",
+        "bbox": [
+            174,
+            161,
+            826,
+            314
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The output features are transformed to object-centric representations differently for our method and each of the baseline methods: ",
+        "bbox": [
+            174,
+            320,
+            821,
+            349
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "VIN: The resulting feature map is forwarded to 4 convolutional layers with stride 2 and a spatial global average pooling layer to get a $d$ dimensional feature vector. This feature vector is transformed to $d \\times m$ by one fully-connected layer. This feature will be reshaped to $m$ vectors with $d$ channel dimensional to represent each object. This representation is refined by two $d \\times d$ fully-connected layers and passed to the (convolutional) interaction network. ",
+        "bbox": [
+            174,
+            356,
+            825,
+            426
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "M and CVP: The output feature map is of shape $m \\times d \\times \\textstyle { \\frac { H } { 4 } } \\times \\frac { W } { 4 }$ because this method produce $m$ masked (or cropped) images as input. The resulting feature map is forwarded to 4 convolutional layers with stride 2 and a spatial global average pooling layer to get a $d$ dimensional feature vector and the output feature is of size $m \\times d$ , representing the features of $m$ objects. This representation is refined by two $d \\times d$ fully-connected layers and passed to the (convolutional) interaction network. ",
+        "bbox": [
+            174,
+            431,
+            825,
+            502
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.2 UNCERTAINTY MODELING. ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            520,
+            406,
+            534
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Only in the shapestack datasets, we also incorporate uncertainty estimation follows (Ye et al., 2019), by modeling the latent distribution using a variational auto-encoder (Kingma & Welling, 2014). For the complete details, we refer the reader to (Ye et al., 2019). Here we only give a summary: we build an encoder $h$ which takes the image feature from first $\\mathcal { F } ^ { 0 }$ and last frame $\\check { \\mathcal { F } } ^ { T }$ of a video sequence as the input. The output of $h$ is a distribution parameter, denoted by $h ( \\mathbf { u } | \\mathcal { F } ^ { 0 } , \\mathcal { F } ^ { T } )$ . Given a particular sample from such distribution, we recover the latent variable by feeding them into a one-layer LSTM and merge into the object feature $\\ v x _ { i } ^ { t }$ . In this case, our pipeline is trained with an additional loss that minimize the KL divergence between the predicted distribution and normal distribution (Kingma & Welling, 2014). ",
+        "bbox": [
+            174,
+            545,
+            825,
+            670
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "During inference, we sample 100 trajectories for each test image and report the minimum of them. This setting is the same as the original CVP paper $\\mathrm { Y e }$ et al. (2019). Our implementation gets $5 . 2 8 \\times 1 0 ^ { - 3 }$ squared $\\ell _ { 2 }$ distance for $T \\in [ 0 , T _ { \\mathrm { t r a i n } } ]$ while the original paper report $6 . 6 9 \\times 1 0 ^ { - 3 }$ . ",
+        "bbox": [
+            176,
+            678,
+            823,
+            719
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.3 DATASET DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            736,
+            348,
+            751
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "SimB: To get the initial velocity, the magnitude (number of pixels moved per timestep) is sampled from [2, 3, 4, 5, 6] and the direction is sampled from $\\{ 6 i \\pi , i = 0 , 1 , \\ldots , 1 1 \\}$ . ",
+        "bbox": [
+            173,
+            762,
+            823,
+            791
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "RealB: We found that the bounding box prediction results are accurate enough to serve as the groundtruth. After running the detector, we also manually go through the dataset and filter out images with incorrect detections. ",
+        "bbox": [
+            174,
+            796,
+            825,
+            839
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "ShapeStacks: There are 1,320 training videos and 296 testing videos, with 32 frames per video. Only objects’ center positions provided. Following (Ye et al., 2019), we assume the object bounding box is square and of size $7 0 \\times 7 0$ . ",
+        "bbox": [
+            174,
+            845,
+            825,
+            888
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "PHYRE: For within task generalization (PHYRE-W), the training set contains 80 templates for each of the 25 task. The testing set contains the remaining 20 templates from each task. For cross task generalization (PHYRE-C), the training set contains 100 templates from 20 tasks while the test set contains 100 templates from the remaining 5 tasks. For each template, we randomly sample a maximum 100 success and 400 failure actions to collect the trajectories to train our model. The image sequence is temporally downsampled by 60. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For our physical reasoning experiments in section 5.4, we train the model using 400 successful actions and 1600 failure actions per template. We use the validation set to select hyper-parameters first, and then do training on the union of train and validation sets and report the final results in the test set. ",
+        "bbox": [
+            176,
+            166,
+            823,
+            208
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.4 HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            224,
+            361,
+            239
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We use Adam optimizer Kingma & Ba (2014) with cosine decay Loshchilov & Hutter (2016) to train our networks. The default input frames is $N = 4$ except $N = 1$ for ShapeStacks and PHYRE. We set $d$ to be 256 except for simulation billiard $d$ is 64. During training, $T$ (denoted as $T _ { \\mathrm { t r a i n . } }$ ) is set to be 20 for SimB and RealB, 5 for PHYRE, and 15 for fair comparison with Ye et al. (2019). The discounted factor $\\lambda _ { t }$ is set to be $\\begin{array} { r } { \\big ( \\frac { \\mathrm { c u r r e n t \\_ i t e r } } { \\mathrm { m a x \\_ i t e r } } \\big ) ^ { t } } \\end{array}$ . ",
+        "bbox": [
+            174,
+            251,
+            825,
+            324
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Simulation Billiards. The image size is $6 4 \\times 6 4$ . We train the model for 100K iterations with a learning rate $2 \\times 1 0 ^ { - 3 }$ , weight decay $\\mathrm { 1 \\check { \\times } 1 0 ^ { - 6 } }$ , and batch size 200. ",
+        "bbox": [
+            173,
+            329,
+            823,
+            357
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Real World Billiards. The image is resized to $1 9 2 \\times 6 4$ . We train the model for 240K iterations with a learning rate $1 \\times 1 0 ^ { - 4 }$ , weight decay $1 \\times 1 0 ^ { - 6 }$ , and batch size 20. ",
+        "bbox": [
+            174,
+            364,
+            823,
+            392
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "PHYRE. The image is resized to $1 2 8 \\times 1 2 8$ . We train the model for 150K iterations with a learning rate $2 \\times 1 0 ^ { - 4 }$ , weight decay $3 \\times 1 0 ^ { - 7 }$ , and batch size 20. ",
+        "bbox": [
+            174,
+            400,
+            821,
+            428
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "ShapeStacks. The image is resized to $2 2 4 \\times 2 2 4$ . We train the model for 25K iterations with a learning rate $2 \\times 1 0 ^ { - 4 }$ , no weight decay (the same as Ye et al. (2019)), and batch size 40. In this dataset, we apply uncertainty modeling. The loss weight of KL-divergence is $3 \\times 1 0 ^ { - 5 }$ . During inference, following Ye et al. (2019), we randomly sample 100 outputs from our model, and select the best (in terms of the distance to ground-truth) of them as our model’s output. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            505
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B PLANNING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            525,
+            377,
+            541
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Given an initial state (represented by an image) and a goal, we aim to produce an action that can lead to the goal from the initial state. Our planning algorithm works in a similar way as visual imagination Fragkiadaki et al. (2015): Firstly, we select a candidate action a from a candidate action set $\\mathcal { A }$ . Then we generate the input images $\\mathcal { T }$ . For SimB, we train a forward model take the initial image and the action embedding to generate object positions for the next 3 steps. Then we use the simulator to generate the 3 images. For PHYRE, we convert the action to the red ball using the simulator and get the initial image. After that, we run our model described in section 5.4 and the score of each action is simply the classifier’s output. We then select the action with the max score. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            667
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We introduce the action set for each task in section B.1, and how to design distance function in B.2.   \nA summary of our algorithm is in Algorithm 1. ",
+        "bbox": [
+            174,
+            674,
+            823,
+            703
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B.1 CANDIDATE ACTION SETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            719,
+            400,
+            734
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For simulation billiard, the action is 3 dimensional. The first two dimensions stand for the direction of the force. The last dimension stands for the magnitude of the force. During doing planning, we enumerate over 5 different magnitudes and 12 different angles, leading to 60 possible actions. All of the initial condition is guaranteed to have a solution. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            801
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For PHYRE, the action is also 3 dimensional. The first two dimensions stand for the location placing the red ball. The last dimension stands for the radius of the ball. Following (Bakhtin et al., 2019), we use the first 10k actions provided by the benchmark. ",
+        "bbox": [
+            174,
+            808,
+            825,
+            851
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B.2 DISTANCE FUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            867,
+            367,
+            882
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Init-End State Error. Denote the given target location of $m$ objects as $y \\in R ^ { m \\times 2 }$ . We use the following distance function, which measures the distance between the final rollout location and the ",
+        "bbox": [
+            173,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "target location: ",
+        "bbox": [
+            173,
+            103,
+            274,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/23b9b79138180f34629dc569b6a4984dc827218b3c64a7a4c7b93886a4ed09ba.jpg",
+        "text": "$$\nD = \\sum _ { i = 1 } ^ { m } \\sum _ { j = 1 } ^ { 2 } ( \\hat { p } _ { T , i , j } - y _ { i , j } ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            114,
+            594,
+            160
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Hitting Accuracy. Denote the given initial location of $m$ objects as $x \\in R ^ { m \\times 2 }$ . We apply force at the object $i ^ { \\prime }$ . We use the following distance function, which prefer the larger moving distance for objects other than $i ^ { \\prime }$ : ",
+        "bbox": [
+            174,
+            167,
+            823,
+            209
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5d9e390619b5491c2cb7f6e579355ed31cdbf899381189db3e63cd3983b125e3.jpg",
+        "text": "$$\nD = - \\operatorname* { m i n } _ { i } \\sum _ { \\substack { i = 1 , i \\neq i ^ { \\prime } } } ^ { m } \\sum _ { j = 1 } ^ { 2 } ( \\hat { p } _ { T , i , j } - x _ { i , j } ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            207,
+            630,
+            252
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "PHYRE task. Since we already train a classifier to classify whether the predicted trajectory will lead to a successful solution of the current task, during test time we can directly use it to classify whether the current action will lead to a successful solution. The distance function is just the negative output score. ",
+        "bbox": [
+            173,
+            261,
+            825,
+            316
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "B.3 PLANNING ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            334,
+            385,
+            348
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Planning Algorithm for Simulated Billiard and PHYRE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            367,
+            632,
+            382
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Input: candidate actions $\\begin{array} { r } { \\boldsymbol { \\mathcal { A } } = \\{ \\mathbf { a } _ { i } \\} } \\end{array}$ , initial state $x$ , end state $y$ (optional)   \nOutput: action $\\mathbf { a } ^ { * }$   \nfor a in $\\mathcal { A }$ do $\\mathcal { T } = \\mathrm { S i m u l a t i o n } ( x , \\mathbf { a } )$ ; $\\hat { p } =$ PredictionModel $( \\mathcal { T } )$ ; calculate $D$ according to task as in B.2; if $D < D ^ { * }$ then $D ^ { * } = D$ ; $a ^ { * } = a$ ; end   \nend ",
+        "bbox": [
+            171,
+            386,
+            660,
+            545
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "C PHYRE 10 FOLD RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            568,
+            431,
+            585
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "To enable future work to compare with our method, we provide AUCCESS scores for all folds in Table 5. The number of RAND and DQN is taken from Bakhtin et al. (2019). ",
+        "bbox": [
+            173,
+            599,
+            825,
+            630
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/3b41d5e72e65b3c83e8cbf9dcf6ded21e5ae03eefb7e5fd08412600d6e70ad1a.jpg",
+        "table_caption": [
+            "Table 5: The AUCCESS scores for each of evaluated fold. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">setting</td><td rowspan=\"2\">method</td><td colspan=\"10\">fold id</td></tr><tr><td>0</td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td></tr><tr><td rowspan=\"3\">B (within)</td><td>RAND</td><td>13.44</td><td>14.01</td><td>13.79</td><td>13.80</td><td>12.75</td><td>13.34</td><td>13.95</td><td>14.30</td><td>13.36</td><td>14.33</td></tr><tr><td>DQN</td><td>76.82 79.72</td><td></td><td>78.22</td><td>75.86</td><td>77.03</td><td>78.42</td><td>78.01</td><td>77.34</td><td>78.04</td><td>76.87</td></tr><tr><td>Ours</td><td>85.49</td><td>86.57</td><td>85.58</td><td>84.11</td><td>85.30</td><td>85.18</td><td>84.78</td><td>84.32</td><td>85.71</td><td>85.17</td></tr><tr><td rowspan=\"3\">B (cross)</td><td>RAND</td><td>11.78</td><td>12.42</td><td>18.18</td><td>12.42</td><td>3.81</td><td>22.50</td><td>11.73</td><td>13.29</td><td>8.94</td><td>14.60</td></tr><tr><td>DQN</td><td>43.69 30.96 43.05 43.91 22.77</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>44.40 34.53 39.20 18.98 46.46</td></tr><tr><td>Ours</td><td>50.86 36.58 55.44 38.34 37.11 47.23 3.23 47.19 32.23 38.76</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            196,
+            641,
+            803,
+            800
+        ],
+        "page_idx": 15
+    }
+]

parse/train/nzpLWnVAyah/nzpLWnVAyah.md

@@ -0,0 +1,344 @@
+# ON THE STABILITY OF FINE-TUNING BERT: MISCONCEPTIONS, EXPLANATIONS, AND STRONG BASELINES
+
+Marius Mosbach Spoken Language Systems (LSV) Saarland Informatics Campus, Saarland University mmosbach@lsv.uni-saarland.de
+
+Maksym Andriushchenko Theory of Machine Learning Lab École polytechnique fédérale de Lausanne maksym.andriushchenko@epfl.ch
+
+# Dietrich Klakow
+
+Spoken Language Systems (LSV) Saarland Informatics Campus, Saarland University dietrich.klakow@lsv.uni-saarland.de
+
+# ABSTRACT
+
+Fine-tuning pre-trained transformer-based language models such as BERT has become a common practice dominating leaderboards across various NLP benchmarks. Despite the strong empirical performance of fine-tuned models, fine-tuning is an unstable process: training the same model with multiple random seeds can result in a large variance of the task performance. Previous literature (Devlin et al., 2019; Lee et al., 2020; Dodge et al., 2020) identified two potential reasons for the observed instability: catastrophic forgetting and small size of the fine-tuning datasets. In this paper, we show that both hypotheses fail to explain the fine-tuning instability. We analyze BERT, RoBERTa, and ALBERT, fine-tuned on commonly used datasets from the GLUE benchmark, and show that the observed instability is caused by optimization difficulties that lead to vanishing gradients. Additionally, we show that the remaining variance of the downstream task performance can be attributed to differences in generalization where fine-tuned models with the same training loss exhibit noticeably different test performance. Based on our analysis, we present a simple but strong baseline that makes fine-tuning BERT-based models significantly more stable than the previously proposed approaches. Code to reproduce our results is available online: https://github.com/uds-lsv/bert-stable-fine-tuning.
+
+# 1 INTRODUCTION
+
+Pre-trained transformer-based masked language models such as BERT (Devlin et al., 2019), RoBERTa (Liu et al., 2019), and ALBERT (Lan et al., 2020) have had a dramatic impact on the NLP landscape in the recent year. The standard recipe for using such models typically involves training a pretrained model for a few epochs on a supervised downstream dataset, which is known as fine-tuning. While fine-tuning has led to impressive empirical results, dominating a large variety of English NLP benchmarks such as GLUE (Wang et al., 2019b) and SuperGLUE (Wang et al., 2019a), it is still poorly understood. Not only have fine-tuned models been shown to pick up spurious patterns and biases present in the training data (Niven and Kao, 2019; McCoy et al., 2019), but also to exhibit a large training instability: fine-tuning a model multiple times on the same dataset, varying only the random seed, leads to a large standard deviation of the fine-tuning accuracy (Devlin et al., 2019; Dodge et al., 2020).
+
+Few methods have been proposed to solve the observed instability (Phang et al., 2018; Lee et al., 2020), however without providing a sufficient understanding of why fine-tuning is prone to such failure. The goal of this work is to address this shortcoming. More specifically, we investigate the following question:
+
+Why is fine-tuning prone to failures and how can we improve its stability?
+
+![](images/2ca1eb5ee16c11f85ba9ece76c980550e0f43eb5a07b91cc6fbb1fed6786cf92.jpg)  
+Figure 1: Our proposed fine-tuning strategy leads to very stable results with very concentrated development set performance over 25 different random seeds across all three datasets on BERT. In particular, we significantly outperform the recently proposed approach of Lee et al. (2020) in terms of fine-tuning stability.
+
+We start by investigating two common hypotheses for fine-tuning instability: catastrophic forgetting and small size of the fine-tuning datasets and demonstrate that both hypotheses fail to explain fine-tuning instability. We then investigate fine-tuning failures on datasets from the popular GLUE benchmark and show that the observed fine-tuning instability can be decomposed into two separate aspects: (1) optimization difficulties early in training, characterized by vanishing gradients, and (2) differences in generalization late in training, characterized by a large variance of development set accuracy for runs with almost equivalent training loss.
+
+Based on our analysis, we present a simple but strong baseline for fine-tuning pre-trained language models that significantly improves the fine-tuning stability compared to previous works (Fig. 1). Moreover, we show that our findings apply not only to the widely used BERT model but also to more recent pre-trained models such as RoBERTa and ALBERT.
+
+# 2 RELATED WORK
+
+The fine-tuning instability of BERT has been pointed out in various studies. Devlin et al. (2019) report instabilities when fine-tuning BERTLARGE on small datasets and resort to performing multiple restarts of fine-tuning and selecting the model that performs best on the development set. Recently, Dodge et al. (2020) performed a large-scale empirical investigation of the fine-tuning instability of BERT. They found dramatic variations in fine-tuning accuracy across multiple restarts and argue how it might be related to the choice of random seed and the dataset size.
+
+Few approaches have been proposed to directly address the observed fine-tuning instability. Phang et al. (2018) study intermediate task training (STILTS) before fine-tuning with the goal of improving performance on the GLUE benchmark. They also find that their proposed method leads to improved fine-tuning stability. However, due to the intermediate task training, their work is not directly comparable to ours. Lee et al. (2020) propose a new regularization technique termed Mixout. The authors show that Mixout improves stability during fine-tuning which they attribute to the prevention of catastrophic forgetting.
+
+Another line of work investigates optimization difficulties of pre-training transformer-based language models (Xiong et al., 2020; Liu et al., 2020). Similar to our work, they highlight the importance of the learning rate warmup for optimization. Both works focus on pre-training and we hence view them as orthogonal to our work.
+
+# 3 BACKGROUND
+
+# 3.1 DATASETS
+
+We study four datasets from the GLUE benchmark (Wang et al., 2019b) following previous work studying instability during fine-tuning: CoLA, MRPC, RTE, and QNLI. Detailed statistics for each of the datasets can be found in Section 7.2 in the Appendix.
+
+CoLA. The Corpus of Linguistic Acceptability (Warstadt et al., 2018) is a sentence-level classification task containing sentences labeled as either grammatical or ungrammatical. Fine-tuning on CoLA was observed to be particularly stable in previous work (Phang et al., 2018; Dodge et al., 2020; Lee et al., 2020). Performance on CoLA is reported in Matthew’s correlation coefficient (MCC).
+
+MRPC. The Microsoft Research Paraphrase Corpus (Dolan and Brockett, 2005) is a sentence-pair classification task. Given two sentences, a model has to judge whether the sentences paraphrases of each other. Performance on MRPC is measured using the $F _ { 1 }$ score.
+
+RTE. The Recognizing Textual Entailment dataset is a collection of sentence-pairs collected from a series of textual entailment challenges (Dagan et al., 2005; Bar-Haim et al., 2006; Giampiccolo et al., 2007; Bentivogli et al., 2009). RTE is the second smallest dataset in the GLUE benchmark and fine-tuning on RTE was observed to be particularly unstable (Phang et al., 2018; Dodge et al., 2020; Lee et al., 2020). Accuracy is used to measure performance on RTE.
+
+QNLI. The Question-answering Natural Language Inference dataset contains sentence pairs obtained from SQuAD (Rajpurkar et al., 2016). Wang et al. (2019b) converted SQuAD into a sentence pair classification task by forming a pair between each question and each sentence in the corresponding paragraph. The task is to determine whether the context sentence contains the answer to the question, i.e. entails the answer. Accuracy is used to measure performance on QNLI.
+
+# 3.2 FINE-TUNING
+
+Unless mentioned otherwise, we follow the default fine-tuning strategy recommended by Devlin et al. (2019): we fine-tune uncased BERTLARGE (henceforth BERT) using a batch size of 16 and a learning rate of $2 \mathrm { e } { - } 5$ . The learning rate is linearly increased from 0 to $2 \mathrm { e } { - } 5$ for the first $1 0 \%$ of iterations—which is known as a warmup—and linearly decreased to 0 afterward. We apply dropout with probability $p = 0 . 1$ and weight decay with $\lambda = 0 . 0 1$ . We train for 3 epochs on all datasets and use global gradient clipping. Following Devlin et al. (2019), we use the AdamW optimizer (Loshchilov and Hutter, 2019) without bias correction.
+
+We decided to not show results for BERTBASE since previous works observed no instability when fine-tuning BERTBASE which we also confirmed in our experiments. Instead, we show additional results on RoBERTaLARGE (Liu et al., 2019) and ALBERTLARGE-V2 (Lan et al., 2020) using the same fine-tuning strategy. We note that compared to BERT, both RoBERTa and ALBERT have slightly different hyperparameters. In particular, RoBERTa uses weight decay with $\lambda = 0 . 1$ and no gradient clipping, and ALBERT does not use dropout. A detailed list of all default hyperparameters for all models can be found in Section 7.3 of the Appendix. Our implementation is based on HuggingFace’s transformers library (Wolf et al., 2019) and is available online: https://github. com/uds-lsv/bert-stable-fine-tuning.
+
+Fine-tuning stability. By fine-tuning stability we mean the standard deviation of the fine-tuning performance (measured, e.g., in terms of accuracy, MCC or $F _ { 1 }$ score) over the randomness of an algorithm. We follow previous works (Phang et al., 2018; Dodge et al., 2020; Lee et al., 2020) and measure fine-tuning stability using the development sets from the GLUE benchmark. We discuss alternative notions of stability in Section 7.1 in the Appendix.
+
+Failed runs. Following Dodge et al. (2020), we refer to a fine-tuning run as a failed run if its accuracy at the end of training is less or equal to that of a majority classifier on the respective dataset. The majority baselines for all tasks are found in Section 7.2 in the Appendix.
+
+# 4 INVESTIGATING PREVIOUS HYPOTHESES FOR FINE-TUNING INSTABILITY
+
+Previous works on fine-tuning predominantly state two hypotheses for what can be related to finetuning instability: catastrophic forgetting and small training data size of the downstream tasks. Despite the ubiquity of these hypotheses (Devlin et al., 2019; Phang et al., 2018; Dodge et al., 2020; Lee et al., 2020), we argue that none of them has a causal relationship with fine-tuning instability.
+
+![](images/17e75685fd0e4826b400d7908b5e71f88d0b2ad10037586d5cf0ebde73a2ccb4.jpg)  
+Figure 2: Language modeling perplexity for three failed (a) and successful (b) fine-tuning runs of BERT on RTE where we replace the weights of the top- $k$ layers with their pre-trained values. We can observe that it is often sufficient to reset around 10 layers out of 24 to recover back the language modeling abilities of the pre-trained model. (c) shows the average training loss and development accuracy $_ { ( \pm 1 \mathrm { s t d } ) }$ for 10 failed fine-tuning runs on RTE. Failed fine-tuning runs lead to a trivial training loss suggesting an optimization problem.
+
+![](images/a48e471441bf46291293b3e5d857c3ac31e96d8e550e638819994d2dc05d8be2.jpg)  
+Figure 3: Development set results on down-sampled MRPC, CoLA, and QNLI using the default fine-tuning scheme of BERT (Devlin et al., 2019). The leftmost boxplot in each sub-figure shows the development accuracy when training on the full training set.
+
+# 4.1 DOES CATASTROPHIC FORGETTING CAUSE FINE-TUNING INSTABILITY?
+
+Catastrophic forgetting (McCloskey and Cohen, 1989; Kirkpatrick et al., 2017) refers to the phenomenon when a neural network is sequentially trained to perform two different tasks, and it loses its ability to perform the first task after being trained on the second. More specifically, in our setup, it means that after fine-tuning a pre-trained model, it can no longer perform the original masked language modeling task used for pre-training. This can be measured in terms of the perplexity on the original training data. Although the language modeling performance of a pre-trained model correlates with its fine-tuning accuracy (Liu et al., 2019; Lan et al., 2020), there is no clear motivation for why preserving the original masked language modeling performance after fine-tuning is important.1
+
+In the context of fine-tuning BERT, Lee et al. (2020) suggest that their regularization method has an effect of alleviating catastrophic forgetting. Thus, it is important to understand how exactly catastrophic forgetting occurs during fine-tuning and how it relates to the observed fine-tuning instability. To better understand this, we perform the following experiment: we fine-tune BERT on RTE, following the default strategy by Devlin et al. (2019). We select three successful and three failed fine-tuning runs and evaluate their masked language modeling perplexity on the test set of the WikiText-2 language modeling benchmark (Merity et al., 2016).2 We sequentially substitute the top- $k$ layers of the network varying $k$ from 0 (i.e. all layers are from the fine-tuned model) to 24 (i.e. all layers are from the pre-trained model). We show the results in Fig. 2 (a) and (b).
+
+We can observe that although catastrophic forgetting occurs for the failed models (Fig. 2a) — perplexity on WikiText-2 is indeed degraded for $k = 0$ — the phenomenon is much more nuanced. Namely, catastrophic forgetting affects only the top layers of the network — in our experiments often around
+
+10 out of 24 layers, and the same is however also true for the successfully fine-tuned models, except for a much smaller increase in perplexity.
+
+Another important aspect of our experiment is that catastrophic forgetting typically requires that the model at least successfully learns how to perform the new task. However, this is not the case for the failed fine-tuning runs. Not only is the development accuracy equal to that of the majority classifier, but also the training loss on the fine-tuning task (here RTE) is trivial, i.e. close to $- \ln ( 1 / 2 )$ (see Fig. 2 (c)). This suggests that the observed fine-tuning failure is rather an optimization problem causing catastrophic forgetting in the top layers of the pre-trained model. We will show later that the optimization aspect is actually sufficient to explain most of the fine-tuning variance.
+
+# 4.2 DO SMALL TRAINING DATASETS CAUSE FINE-TUNING INSTABILITY?
+
+Having a small training dataset is by far the most commonly stated hypothesis for fine-tuning instability. Multiple recent works (Devlin et al., 2019; Phang et al., 2018; Lee et al., 2020; Zhu et al., 2020; Dodge et al., 2020; Pruksachatkun et al., 2020) that have observed BERT fine-tuning to be unstable relate this finding to the small number of training examples.
+
+To test if having a small training dataset inherently leads to fine-tuning instability we perform the following experiment:3 we randomly sample 1,000 training samples from the CoLA, MRPC, and QNLI training datasets and fine-tune BERT using 25 different random seeds on each dataset. We compare two different settings: first, training for 3 epochs on the reduced training dataset, and second, training for the same number of iterations as on the full training dataset. We show the results in Fig. 3 and observe that training on less data does indeed affect the fine-tuning variance, in particular, there are many more failed runs. However, when we simply train for as many iterations as on the full training dataset, we almost completely recover the original variance of the fine-tuning performance. We also observe no failed runs on MRPC and QNLI and only a single failed run on CoLA which is similar to the results obtained by training on the full training set. Further, as expected, we observe that training on fewer samples affects the generalization of the model, leading to a worse development set performance on all three tasks.4
+
+We conclude from this experiment, that the role of training dataset size per se is orthogonal to fine-tuning stability. What is crucial is rather the number of training iterations. As our experiment shows, the observed increase in instability when training with smaller datasets can rather be attributed to the reduction of the number of iterations (that changes the effective learning rate schedule) which, as we will show in the next section, has a crucial influence on the fine-tuning stability.
+
+# 5 DISENTANGLING OPTIMIZATION AND GENERALIZATION IN FINE-TUNING INSTABILITY
+
+Our findings in Section 4 detail that while both catastrophic forgetting and small size of the datasets indeed correlate with fine-tuning instability, none of them are causing it. In this section, we argue that the fine-tuning instability is an optimization problem, and it admits a simple solution. Additionally, we show that even though a large fraction of the fine-tuning instability can be explained by optimization, the remaining instability can be attributed to generalization issues where fine-tuning runs with the same training loss exhibit noticeable differences in the development set performance.
+
+# 5.1 THE ROLE OF OPTIMIZATION
+
+Failed fine-tuning runs suffer from vanishing gradients. We observed in Fig. 2c that the failed runs have practically constant training loss throughout the training (see Fig. 14 in the Appendix for a comparison with successful fine-tuning). In order to better understand this phenomenon, in Fig. 4 we plot the $\ell _ { 2 }$ gradient norms of the loss function with respect to different layers of BERT, for one failed and successful fine-tuning run. For the failed run we see large enough gradients only for the top layers and vanishing gradients for the bottom layers. This is in large contrast to the successful run. While we also observe small gradients at the beginning of training (until iteration 70), gradients start to grow as training continues. Moreover, at the end of fine-tuning, we observe gradient norms nearly $2 \times$ orders of magnitude larger than that of the failed run. Similar visualizations for additional layers and weights can be found in Fig. 10 in the Appendix. Moreover, we observe the same behavior also for RoBERTa and ALBERT models, and the corresponding figures can be found in the Appendix as well (Fig. 11 and 12).
+
+![](images/57e7a65c978622e72bb1473321aaeda3de93a912bcd3ee37e09d63cc6b5f65c8.jpg)  
+Figure 4: Gradient norms (plotted on a logarithmic scale) of different layers on RTE for a failed and successful run of BERT fine-tuning. We observe that the failed run is characterized by vanishing gradients in the bottom layers of the network. Additional plots for other weight matrices can be found in the Appendix.
+
+![](images/3191efa17953497d2e9ffc0c93f807f8b51d41f4b8d3de7bc3e0485cd1eece89.jpg)  
+Figure 5: Box plots showing the fine-tuning performance of (a) BERT, (b) RoBERTa, (c) ALBERT for different learning rates $\alpha$ with and without bias correction (BC) on RTE. For BERT and ALBERT, having bias correction leads to more stable results and allows to train using larger learning rates. For RoBERTa, the effect is less pronounced but still visible.
+
+Importantly, we note that the vanishing gradients we observe during fine-tuning are harder to resolve than the standard vanishing gradient problem (Hochreiter, 1991; Bengio et al., 1994). In particular, common weight initialization schemes (Glorot and Bengio, 2010; He et al., 2015) ensure that the pre-activations of each layer of the network have zero mean and unit variance in expectation. However, we cannot simply modify the weights of a pre-trained model on each layer to ensure this property since this would conflict with the idea of using the pre-trained weights.
+
+Importance of bias correction in ADAM. Following Devlin et al. (2019), subsequent works on fine-tuning BERT-based models use the ADAM optimizer (Kingma and Ba, 2015). A subtle detail of the fine-tuning scheme of Devlin et al. (2019) is that it does not include the bias correction in ADAM. Kingma and Ba (2015) already describe the effect of the bias correction as to reduce the learning rate at the beginning of training. By rewriting the update equations of ADAM as follows, we can clearly see this effect of bias correction:
+
+$$
+\begin{array} { l } { { \alpha _ { t }  \alpha \cdot \sqrt { 1 - \beta _ { 2 } ^ { t } } / ( 1 - \beta _ { 1 } ^ { t } ) , } } \\ { { \theta _ { t }  \theta _ { t - 1 } - \alpha _ { t } \cdot m _ { t } / ( \sqrt { v _ { t } } + \epsilon ) , } } \end{array}
+$$
+
+![](images/3c47d595d071fb108f72fd94bef1fccf858d1b6f1f998d6e516fba81f4a80708.jpg)  
+Figure 7: 2D loss surfaces in the subspace spanned by $\delta _ { 1 } = \theta _ { f } - \theta _ { p }$ and $\delta _ { 2 } = \theta _ { s } - \theta _ { p }$ on RTE, MRPC, and CoLA. $\theta _ { p } , \theta _ { f }$ , $\theta _ { s }$ denote the parameters of the pre-trained, failed, and successfully trained model, respectively.
+
+Here $m _ { t }$ and $v _ { t }$ are biased first and second moment estimates respectively. Equation (1) shows that bias correction simply boils down to reducing the original step size $\alpha$ by a multiplicative factor $\sqrt { 1 - \beta _ { 2 } ^ { t } } / ( 1 - \beta _ { 1 } ^ { t } )$ which is significantly below 1 for the first iterations of training and approaches 1 as the number of training iterations $t$ increases (see Fig. 6). Along the same lines, You et al. (2020) explicitly remark that bias correction in ADAM has a similar effect to the warmup which is widely used in deep learning to prevent divergence early in training (He et al., 2016; Goyal et al., 2017; Devlin et al., 2019; Wong et al., 2020).
+
+![](images/9a66213890a3d625ea59c5e23e6ef48bb4a27bf9977d9ae208e9e6e199e42c24.jpg)  
+Figure 6: The bias correction term of ADAM ( $\beta _ { 1 } = 0 . 9$ and $\beta _ { 2 } = 0 . 9 9 9$ ).
+
+The implicit warmup of ADAM is likely to be an important factor that contributed to its success. We argue that fine-tuning BERT-based language models is not an exception. In Fig. 5 we show the results of fine-tuning on RTE with and without bias correction for BERT, RoBERTa, and ALBERT models.5 We observe that there is a significant benefit in combining warmup with bias correction, particularly for BERT and ALBERT. Even though for RoBERTa fine-tuning is already more stable even without bias correction, adding bias correction gives an additional improvement.
+
+Our results show that bias correction is useful if we want to get the best performance within 3 epochs, the default recommendation by Devlin et al. (2019). An alternative solution is to simply train longer with a smaller learning rate, which also leads to much more stable fine-tuning. We provide a more detailed ablation study in Appendix (Fig. 9) with analogous box plots for BERT using various learning rates, numbers of training epochs, with and without bias correction. Finally, concurrently to our work, Zhang et al. (2021) also make a similar observation about the importance of bias correction and longer training which gives further evidence to our findings.
+
+Loss surfaces. To get further intuition about the fine-tuning failure, we provide loss surface visualizations (Li et al., 2018; Hao et al., 2019) of failed and successful runs when fine-tuning BERT. Denote by $\theta _ { p }$ , $\theta _ { f }$ , $\theta _ { s }$ the parameters of the pre-trained model, failed model, and successfully trained model, respectively. We plot a two-dimensional loss surface $f ( \alpha , \beta ) = \mathcal { L } ( \theta _ { p } + \alpha \delta _ { 1 } + \beta \delta _ { 2 } )$ in the subspace spanned by $\delta _ { 1 } = \theta _ { f } - \theta _ { p }$ and $\delta _ { 2 } = \theta _ { s } - \theta _ { p }$ centered at the weights of the pre-trained model $\theta _ { p }$ . Additional details are specified in Section 7.6 in the Appendix.
+
+Contour plots of the loss surfaces for RTE, MRPC, and CoLA are shown in Fig. 7. They provide additional evidence to our findings on vanishing gradients: for failed fine-tuning runs gradient descent converges to a “bad” valley with a sub-optimal training loss. Moreover, this bad valley is separated from the local minimum (to which the successfully trained run converged) by a barrier (see also Fig. 13 in the Appendix). Interestingly, we observe a highly similar geometry for all three datasets providing further support for our interpretation of fine-tuning instability as a primarily optimization issue.
+
+![](images/ca95a024a64a8b0ba9fc93b72ee20f9b1017d95083887ebc0519890dcc0a0e16.jpg)  
+Figure 8: Development set accuracy for multiple fine-tuning runs on RTE. The models for (a) are trained with 10 different seeds, and models for (b) are taken at the end of the training, and trained with different seeds and hyperparameters.
+
+# 5.2 THE ROLE OF GENERALIZATION
+
+We now turn to the generalization aspects of fine-tuning instability. In order to show that the remaining fine-tuning variance on the development set can be attributed to generalization, we perform the following experiment: we fine-tune BERT on RTE for 20 epochs and show the development set accuracy for 10 successful runs in Fig. 8a. Further, we show in Fig. 8b the development set accuracy vs. training loss of all BERT models fine-tuned on RTE for the full ablation study (shown in Fig. 9 in the Appendix), in total 450 models.
+
+We find that despite achieving close to zero training loss overfitting is not an issue during fine-tuning. This is consistent with previous work (Hao et al., 2019), which arrived at a similar conclusion. Based on our results, we argue that it is even desirable to train for a larger number of iterations since the development accuracy varies considerably during fine-tuning and it does not degrade even when the training loss is as low as 10−5.
+
+Combining these findings with results from the previous section, we conclude that the fine-tuning instability can be decomposed into two aspects: optimization and generalization. In the next section, we propose a simple solution addressing both issues.
+
+# 6 A SIMPLE BUT HARD-TO-BEAT BASELINE FOR FINE-TUNING BERT
+
+As our findings in Section 5 show, the empirically observed instability of fine-tuning BERT can be attributed to vanishing gradients early in training as well as differences in generalization late in training. Given the new understanding of fine-tuning instability, we propose the following guidelines for fine-tuning transformer-based masked language models on small datasets:
+
+• Use small learning rates with bias correction to avoid vanishing gradients early in training.   
+• Increase the number of iterations considerably and train to (almost) zero training loss.
+
+This leads to the following simple baseline scheme: we fine-tune BERT using ADAM with bias correction and a learning rate of 2e−5. The training is performed for 20 epochs, and the learning rate is linearly increased for the first $1 0 \%$ of steps and linearly decayed to zero afterward. All other hyperparameters are kept unchanged. A full ablation study on RTE testing various combinations of the changed hyperparameters is presented in Section 7.4 in the Appendix.
+
+Results. Despite the simplicity of our proposed fine-tuning strategy, we obtain strong empirical performance. Table 1 and Fig. 1 show the results of fine-tuning BERT on RTE, MRPC, and CoLA. We compare to the default strategy of Devlin et al. (2019) and the recent Mixout method from Lee et al. (2020). First, we observe that our method leads to a much more stable fine-tuning performance on all three datasets as evidenced by the significantly smaller standard deviation of the final performance. To further validate our claim about the fine-tuning stability, we run Levene’s test (Levene, 1960) to check the equality of variances for the distributions of the final performances on each dataset. For all three datasets, the test results in a p-value less than 0.001 when we compare the variances between our method and the method achieving the second smallest variance. Second, we also observe that our method improves the overall fine-tuning performance: in Table 1 we achieve a higher mean value on all datasets and also comparable or better maximum performance on MRPC and CoLA respectively.
+
+Table 1: Standard deviation, mean, and maximum performance on the development set of RTE, MRPC, and CoLA when fine-tuning BERT over 25 random seeds. Standard deviation: lower is better, i.e. fine-tuning is more stable. ? denotes significant difference $\mathit { p } < 0 . 0 0 1 $ ) when compared to the second smallest standard deviation.   
+
+<table><tr><td>Approach</td><td colspan="3">RTE</td><td colspan="3">MRPC</td><td colspan="3">CoLA</td></tr><tr><td></td><td>std</td><td>mean</td><td>max</td><td>std</td><td>mean</td><td>max</td><td>std</td><td>mean</td><td>max</td></tr><tr><td>Devlin et al. (2019)</td><td>4.5</td><td>50.9</td><td>67.5</td><td>3.9</td><td>84.0</td><td>91.2</td><td>25.6</td><td>45.6</td><td>64.6</td></tr><tr><td>Lee et al. (2020)</td><td>7.9</td><td>65.3</td><td>74.4</td><td>3.8</td><td>87.8</td><td>91.8</td><td>20.9</td><td>51.9</td><td>64.0</td></tr><tr><td>Ours</td><td>2.7*</td><td>67.3</td><td>71.1</td><td>0.8*</td><td>90.3</td><td>91.7</td><td>1.8*</td><td>62.1</td><td>65.3</td></tr></table>
+
+Finally, we note that we suggest to increase the number of fine-tuning iterations only for small datasets, and thus the increased computational cost of our proposed scheme is not a problem in practice. Moreover, we think that overall our findings lead to more efficient fine-tuning because of the significantly improved stability which effectively reduces the number of necessary fine-tuning runs.
+
+# 7 CONCLUSIONS
+
+In this work, we have discussed the existing hypotheses regarding the reasons behind fine-tuning instability and proposed a new baseline strategy for fine-tuning that leads to significantly improved fine-tuning stability and overall improved results on commonly used datasets from the GLUE benchmark.
+
+By analyzing failed fine-tuning runs, we find that neither catastrophic forgetting nor small dataset sizes sufficiently explain fine-tuning instability. Instead, our analysis reveals that fine-tuning instability can be characterized by two distinct problems: (1) optimization difficulties early in training, characterized by vanishing gradients, and (2) differences in generalization, characterized by a large variance of development set accuracy for runs with almost equivalent training performance.
+
+Based on our analysis, we propose a simple but strong baseline strategy for fine-tuning BERT which outperforms the previous works in terms of fine-tuning stability and overall performance.
+
+# ACKNOWLEDGMENTS
+
+We thank Anna Khokhlova for her help with the language modeling experiments, Cheolhyoung Lee and Jesse Dodge for providing us with details of their works, and Badr Abdullah and Aditya Mogadala for their helpful comments on a draft of this paper.
+
+This work was funded by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) – Project-ID 232722074 – SFB 1102.
+
+# REFERENCES
+
+Roy Bar-Haim, Ido Dagan, Bill Dolan, Lisa Ferro, and Danilo Giampiccolo. 2006. The second pascal recognising textual entailment challenge. Proceedings of the Second PASCAL Challenges Workshop on Recognising Textual Entailment.
+
+Yoshua Bengio, Patrice Simard, and Paolo Frasconi. 1994. Learning long-term dependencies with gradient descent is difficult. IEEE transactions on neural networks, 5(2):157–166.
+
+Luisa Bentivogli, Ido Dagan, Hoa Trang Dang, Danilo Giampiccolo, and Bernardo Magnini. 2009. The fifth pascal recognizing textual entailment challenge. In Proceedings of the Second Text Analysis Conference (TAC 2009).
+
+Ido Dagan, Oren Glickman, and Bernardo Magnini. 2005. The pascal recognising textual entailment challenge. In Proceedings of the First International Conference on Machine Learning Challenges: Evaluating Predictive Uncertainty Visual Object Classification, and Recognizing Textual Entailment, MLCW’05, page 177–190, Berlin, Heidelberg. Springer-Verlag.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171–4186, Minneapolis, Minnesota. Association for Computational Linguistics.
+
+Jesse Dodge, Gabriel Ilharco, Roy Schwartz, Ali Farhadi, Hannaneh Hajishirzi, and Noah Smith. 2020. Fine-tuning pretrained language models: Weight initializations, data orders, and early stopping. arXiv preprint arXiv:2002.06305.
+
+William B. Dolan and Chris Brockett. 2005. Automatically constructing a corpus of sentential paraphrases. In Proceedings of the Third International Workshop on Paraphrasing (IWP2005).
+
+Danilo Giampiccolo, Bernardo Magnini, Ido Dagan, and Bill Dolan. 2007. The third pascal recognizing textual entailment challenge. In Proceedings of the ACL-PASCAL Workshop on Textual Entailment and Paraphrasing, RTE ’07, page 1–9, USA. Association for Computational Linguistics.
+
+Xavier Glorot and Yoshua Bengio. 2010. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pages 249–256.
+
+Priya Goyal, Piotr Dollár, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. 2017. Accurate, large minibatch sgd: Training imagenet in 1 hour.
+
+Yaru Hao, Li Dong, Furu Wei, and Ke Xu. 2019. Visualizing and understanding the effectiveness of BERT. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLPIJCNLP), pages 4143–4152, Hong Kong, China. Association for Computational Linguistics.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2015. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE international conference on computer vision, pages 1026–1034.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2016. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770–778.
+
+Sepp Hochreiter. 1991. Untersuchungen zu dynamischen neuronalen netzen. Diploma, Technische Universität München, 91(1).
+
+Tushar Khot, Ashish Sabharwal, and Peter Clark. 2018. Scitail: A textual entailment dataset from science question answering.
+
+Diederik P. Kingma and Jimmy Ba. 2015. Adam: A method for stochastic optimization. In International Conference on Learning Representations.
+
+James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A. Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, and et al. 2017. Overcoming catastrophic forgetting in neural networks. Proceedings of the National Academy of Sciences, 114(13):3521–3526.
+
+Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. 2020. Albert: A lite bert for self-supervised learning of language representations. In International Conference on Learning Representations.
+
+Cheolhyoung Lee, Kyunghyun Cho, and Wanmo Kang. 2020. Mixout: Effective regularization to finetune large-scale pretrained language models. In International Conference on Learning Representations.
+
+Howard Levene. 1960. Robust tests for equality of variances. Contributions to probability and statistics: Essays in honor of Harold Hotelling, pages 278–292.
+
+Hao Li, Zheng Xu, Gavin Taylor, Christoph Studer, and Tom Goldstein. 2018. Visualizing the loss landscape of neural nets. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett, editors, Advances in Neural Information Processing Systems 31, pages 6389–6399. Curran Associates, Inc.
+
+Liyuan Liu, Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Jiawei Han. 2020. On the variance of the adaptive learning rate and beyond. In International Conference on Learning Representations.
+
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692.
+
+Ilya Loshchilov and Frank Hutter. 2019. Decoupled weight decay regularization. In International Conference on Learning Representations.
+
+Michael McCloskey and Neal J Cohen. 1989. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of learning and motivation, volume 24, pages 109–165. Elsevier.
+
+R. Thomas McCoy, Junghyun Min, and Tal Linzen. 2020. BERTs of a feather do not generalize together: Large variability in generalization across models with similar test set performance. In Proceedings of the Third BlackboxNLP Workshop on Analyzing and Interpreting Neural Networks for NLP, pages 217–227, Online. Association for Computational Linguistics.
+
+Tom McCoy, Ellie Pavlick, and Tal Linzen. 2019. Right for the wrong reasons: Diagnosing syntactic heuristics in natural language inference. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 3428–3448, Florence, Italy. Association for Computational Linguistics.
+
+Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. 2016. Pointer sentinel mixture models. arXiv preprint arXiv:1609.07843.
+
+Timothy Niven and Hung-Yu Kao. 2019. Probing neural network comprehension of natural language arguments. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 4658–4664, Florence, Italy. Association for Computational Linguistics.
+
+Jason Phang, Thibault Févry, and Samuel R Bowman. 2018. Sentence encoders on stilts: Supplementary training on intermediate labeled-data tasks. arXiv preprint arXiv:1811.01088.
+
+Yada Pruksachatkun, Jason Phang, Haokun Liu, Phu Mon Htut, Xiaoyi Zhang, Richard Yuanzhe Pang, Clara Vania, Katharina Kann, and Samuel R. Bowman. 2020. Intermediate-task transfer learning with pretrained language models: When and why does it work? In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 5231–5247, Online. Association for Computational Linguistics.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. 2016. SQuAD: $^ { 1 0 0 , 0 0 0 + }$ questions for machine comprehension of text. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pages 2383–2392, Austin, Texas. Association for Computational Linguistics.
+
+Alex Wang, Yada Pruksachatkun, Nikita Nangia, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel Bowman. 2019a. Superglue: A stickier benchmark for general-purpose language understanding systems. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d’Alché Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32, pages 3266–3280. Curran Associates, Inc.
+
+Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. 2019b. GLUE: A multi-task benchmark and analysis platform for natural language understanding. In International Conference on Learning Representations.
+
+Alex Warstadt, Amanpreet Singh, and Samuel R Bowman. 2018. Neural network acceptability judgments. arXiv preprint arXiv:1805.12471.
+
+Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, Rémi Louf, Morgan Funtowicz, et al. 2019. Transformers: State-of-theart natural language processing. arXiv preprint arXiv:1910.03771.
+
+Eric Wong, Leslie Rice, and J. Zico Kolter. 2020. Fast is better than free: Revisiting adversarial training. In International Conference on Learning Representations.
+
+Ruibin Xiong, Yunchang Yang, Di He, Kai Zheng, Shuxin Zheng, Chen Xing, Huishuai Zhang, Yanyan Lan, Liwei Wang, and Tie-Yan Liu. 2020. On layer normalization in the transformer architecture. arXiv preprint arXiv:2002.04745.
+
+Yang You, Jing Li, Sashank Reddi, Jonathan Hseu, Sanjiv Kumar, Srinadh Bhojanapalli, Xiaodan Song, James Demmel, Kurt Keutzer, and Cho-Jui Hsieh. 2020. Large batch optimization for deep learning: Training bert in 76 minutes. In International Conference on Learning Representations.
+
+Tianyi Zhang, Felix Wu, Arzoo Katiyar, Kilian Q Weinberger, and Yoav Artzi. 2021. Revisiting few-sample BERT fine-tuning. In International Conference on Learning Representations.
+
+Chen Zhu, Yu Cheng, Zhe Gan, Siqi Sun, Tom Goldstein, and Jingjing Liu. 2020. Freelb: Enhanced adversarial training for natural language understanding. In International Conference on Learning Representations.
+
+# APPENDIX
+
+# 7.1 ALTERNATIVE NOTIONS OF STABILITY
+
+Here, we elaborate on other possible definitions of fine-tuning stability. The definition that we use throughout the paper follows the previous work (Phang et al., 2018; Dodge et al., 2020; Lee et al., 2020). For example, while Dodge et al. (2020) do not directly define fine-tuning stability, they report and analyze the standard deviation of the validation performance (e.g., see Section 4.1 of their paper). Along the same lines, an earlier work of Phang et al. (2018), which studies the influence of intermediate fine-tuning, discusses the variance of the validation performance (see Section 4: Results, paragraph Fine-Tuning Stability therein) and shows the standard deviation over multiple random seeds in Figure 1.
+
+For simplicity, let us assume that the performance metric is accuracy and we have two classes. Let $A$ be a randomized fine-tuning algorithm that produces a classifier $f _ { A }$ , and let us denote data points as $( x , y ) \sim \mathcal { D }$ where $\mathcal { D }$ is the data-generating distribution. Our definition of fine-tuning stability can be formalized as follows:
+
+$$
+S _ { \mathrm { o u r s } } ( A ) = \mathrm { V a r } _ { A } \left[ \mathrm { E } _ { x , y } \left[ \mathbb { 1 } _ { f _ { A } ( x ) = y } \right] \right] = \mathrm { V a r } _ { A } \left[ \mathrm { A c c u r a c y } ( f _ { A } ) \right] .
+$$
+
+This definition directly measures the variance of the performance metric and aims to answer the question: If we perform fine-tuning multiple times, how large will the difference in performance be?
+
+An alternative definition of fine-tuning stability that could be considered is per-point stability where the expectation and variance are interchanged:
+
+$$
+S _ { \mathrm { p e r - p o i n t } } ( A ) = \mathrm { E } _ { x , y } \left[ \mathrm { V a r } _ { A } \left[ \mathbb { 1 } _ { f _ { A } ( x ) = y } \right] \right] .
+$$
+
+This definition captures a different notion of stability. Namely, it captures stability per data point by measuring how much the classifiers $f _ { A }$ differ on the same point $x$ given label $y$ . Studying the per-point fine-tuning stability can be useful to better understand the properties of fine-tuned models and we refer to McCoy et al. (2020) for a study in this direction.
+
+# 7.2 TASK STATISTICS
+
+Statistics for each of the datasets studied in this paper are shown in Table 2. All datasets are publicly available. The GLUE datasets can be downloaded here: https://github.com/nyu-mll/ jiant. SciTail is available at https://github.com/allenai/scitail.
+
+Table 2: Dataset statistics and majority baselines.   
+
+<table><tr><td></td><td>RTE</td><td>MRPC</td><td>CoLA</td><td>QNLI</td><td>SciTail</td></tr><tr><td>Training</td><td>2491</td><td>3669</td><td>8551</td><td>104744</td><td>23596</td></tr><tr><td>Development</td><td>278</td><td>409</td><td>1043</td><td>5464</td><td>1304</td></tr><tr><td>Majority baseline</td><td>0.53</td><td>0.75</td><td>0.0</td><td>0.50</td><td>0.63</td></tr><tr><td>Metric</td><td>Acc.</td><td>F1 score</td><td>MCC</td><td>Acc.</td><td>Acc.</td></tr></table>
+
+# 7.3 HYPERPARAMETERS
+
+Hyperparameters for BERT, RoBERTa, and ALBERT used for all our experiments are shown in Table 3.
+
+# 7.4 ABLATION STUDIES
+
+Figure 9 shows the results of fine-tuning on RTE with different combinations of learning rate, number of training epochs, and bias correction. We make the following observations:
+
+• When training for only 3 epochs, disabling bias correction clearly hurts performance. • With bias correction, training with larger learning rates is possible. • Combining the usage of bias correction with training for more epochs leads to the best performance.
+
+![](images/8e6041c913757b68ade8bd2ce9cc243f8155476e8baa77a8c80c2cef0ac9edf6.jpg)  
+Figure 9: Full ablation of fine-tuning BERT on RTE. For each setting, we vary only the number of training steps, learning rate, and usage of bias correction (BC). All other hyperparameters are unchanged. We fine-tune 25 models for each setting. $\star$ shows the setting which we recommend as a new baseline fine-tuning strategy.
+
+Table 3: Hyperparameters used for fine-tuning.   
+
+<table><tr><td>Hyperparam</td><td>BERT</td><td>RoBERTa</td><td>ALBERT</td></tr><tr><td>Epochs</td><td>3,10,20</td><td>3</td><td>3</td></tr><tr><td>Learning rate</td><td>le-5-5e-5</td><td>le-5-3e-5</td><td>le-5-3e-5</td></tr><tr><td>Learning rate schedule</td><td>warmup-linear</td><td>warmup-linear</td><td>warmup-linear</td></tr><tr><td>Warmup ratio</td><td>0.1</td><td>0.1</td><td>0.1</td></tr><tr><td>Batch size</td><td>16</td><td>16</td><td>16</td></tr><tr><td>Adam e</td><td>1e-6</td><td>1e-6</td><td>1e-6</td></tr><tr><td>Adam β1</td><td>0.9</td><td>0.9</td><td>0.9</td></tr><tr><td>Adam β2</td><td>0.999</td><td>0.98</td><td>0.999</td></tr><tr><td>Adam bias correction</td><td>{True,False}</td><td>{True, False}</td><td>{True,False}</td></tr><tr><td>Dropout</td><td>0.1</td><td>0.1</td><td>1</td></tr><tr><td>Weight decay</td><td>0.01</td><td>0.1</td><td>1</td></tr><tr><td>Clipping gradient norm</td><td>1.0</td><td>1</td><td>1.0</td></tr><tr><td>Number of random seeds</td><td>25</td><td>25</td><td>25</td></tr></table>
+
+# 7.5 ADDITIONAL GRADIENT NORM VISUALIZATIONS
+
+We provide additional visualizations for the vanishing gradients observed when fine-tuning BERT, RoBERTa, and ALBERT in Figures 10, 11, 12. Note that for ALBERT besides the pooler and classification layers, we plot only the gradient norms of a single hidden layer (referred to as layer0) because of weight sharing.
+
+Gradient norms and MLM perplexity. We can see from the gradient norm visualizations for BERT in Figures 4 and 10 that the gradient norm of the pooler and classification layer remains large. Hence, even though the gradients on most layers of the model vanish, we still update the weights on the top layers. In fact, this explains the large increase in MLM perplexity for the failed models which is shown in Fig. 2a. While most of the layers do not change as we continue training, the top layers of the network change dramatically.
+
+# 7.6 LOSS SURFACES
+
+For Fig. 7, we define the range for both $\alpha$ and $\beta$ as $[ - 1 . 5 , 1 . 5 ]$ and sample 40 points for each axis. We evaluate the loss on 128 samples from the training dataset of each task using all model parameters, including the classification layer. We disabled dropout for generating the surface plots.
+
+Fig. 13 shows contour plots of the total gradient norm. We can again see that the point to which the failed model converges to $( \theta _ { f } )$ is separated from the point the successful model converges to $( \theta _ { s } )$ by a barrier. Moreover, on all the three datasets we can clearly see the valley around $\theta _ { f }$ with a small gradient norm.
+
+# 7.7 TRAINING CURVES
+
+Fig. 14 shows training curves for 10 successful and 10 failed fine-tuning runs on RTE. We can clearly observe that all 10 failed runs have a common pattern: throughout the training, their training loss stays close to that at initialization. This implies an optimization problem and suggests to reconsider the optimization scheme.
+
+# 7.8 ADDITIONAL FINE-TUNING RESULTS
+
+We report additional fine-tuning results on the SciTail dataset (Khot et al., 2018) in Table 4 to demonstrate that our findings generalize to datasets from other domains.
+
+Due to its comparatively large size (28k training samples) fine-tuning on SciTail with the Devlin et al. (2019) scheme is already very stable even when trained for 3 epochs. This is comparable to what we find for QNLI in Section 4.1. When applying our fine-tuning scheme to SciTail, the results are very close to that of Devlin et al. (2019). On the other hand, when training on a smaller subset of SciTail (1k training samples) we can clearly see the same results as also observed in Fig. 3 for MRPC, CoLA, and QNLI, i.e. using more training iterations improves the fine-tuning stability.
+
+![](images/aa8a8b9659df6d688662b4bea2049adae33425a7f0f112cf24a5af9c2ebe29c9.jpg)  
+Figure 10: Gradient norms (plotted on a logarithmic scale) of additional weight matrices of BERT fine-tuned on RTE. Corresponding layer names are in the captions. We show gradient norms corresponding to a single failed and single successful, respectively.
+
+![](images/c22373173b2d3e4c52148f931644cc42972a88544fe122a835913b32b836d35e.jpg)  
+Figure 11: Gradient norms (plotted on a logarithmic scale) of additional weight matrices of RoBERTa fine-tuned on RTE. Corresponding layer names are in the captions. We show gradient norms corresponding to a single failed and single successful, respectively.
+
+![](images/f80e109368e2f0c95feae8d7bd688ef690c92a1c69f2044b53235fdd49e4a206.jpg)  
+Figure 12: Gradient norms (plotted on a logarithmic scale) of additional weight matrices of ALBERT fine-tuned on RTE. Corresponding layer names are in the captions. We show gradient norms corresponding to a single failed and single successful, respectively.
+
+![](images/9ab580f48b2fa5f55b9a68c1a50f9ee6baf599d3dcdf80a319ab2c6f3e99dd50.jpg)  
+Figure 13: 2D gradient norm surfaces in the subspace spanned by $\delta _ { 1 } = \theta _ { f } - \theta _ { p }$ and $\delta _ { 2 } = \theta _ { s } - \theta _ { p }$ for BERT fine-tuned on RTE, MRPC and CoLA. $\theta _ { p } , \theta _ { f }$ , $\theta _ { s }$ denote the parameters of the pre-trained, failed, and successfully trained model, respectively.
+
+![](images/90f258b1a316c75b6c3fd83719d5d45da6c0f0e8634399099a0b6c0069373136.jpg)  
+Figure 14: The test accuracy and training loss of (a) 10 successful runs with our fine-tuning scheme and (b) 10 failed runs with fine-tuning scheme Devlin on RTE. Solid line shows the mean, error bars show $\pm 1 \mathrm { s t d }$ .
+
+Table 4: Standard deviation, mean, and maximum performance on the development set of SciTail when finetuning BERT over 25 random seeds. Standard deviation: lower is better, i.e. fine-tuning is more stable.   
+
+<table><tr><td rowspan="2">Approach</td><td colspan="3">SciTail</td></tr><tr><td>std</td><td>mean</td><td>max</td></tr><tr><td>Devlin et al. (2019),full train set, 3 epochs</td><td>0.4</td><td>95.1</td><td>96.0</td></tr><tr><td>Devlin et al. (2019),1k samples,3 epochs</td><td>17.9</td><td>69.8</td><td>89.4</td></tr><tr><td>Devlin et al. (2019),1k samples,71 epochs</td><td>0.9</td><td>87.5</td><td>89.1</td></tr><tr><td>Ours, full train set</td><td>0.6</td><td>95.1</td><td>96.8</td></tr></table>
+
+We conclude from this experiment that our findings and guidelines generalize to datasets from other domains as well. This gives further evidence that the observed instability is not a property of any particular dataset but rather a result of too few training iterations based on the common fine-tuning practice of using a fixed number of epochs (and not iterations) independently of the training data size.

parse/train/nzpLWnVAyah/nzpLWnVAyah_content_list.json

@@ -0,0 +1,1882 @@
+[
+    {
+        "type": "text",
+        "text": "ON THE STABILITY OF FINE-TUNING BERT: MISCONCEPTIONS, EXPLANATIONS, AND STRONG BASELINES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            828,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Marius Mosbach Spoken Language Systems (LSV) Saarland Informatics Campus, Saarland University mmosbach@lsv.uni-saarland.de ",
+        "bbox": [
+            183,
+            172,
+            516,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Maksym Andriushchenko Theory of Machine Learning Lab École polytechnique fédérale de Lausanne maksym.andriushchenko@epfl.ch ",
+        "bbox": [
+            534,
+            172,
+            818,
+            229
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Dietrich Klakow ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            252,
+            299,
+            265
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Spoken Language Systems (LSV) Saarland Informatics Campus, Saarland University dietrich.klakow@lsv.uni-saarland.de ",
+        "bbox": [
+            184,
+            266,
+            527,
+            306
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            344,
+            544,
+            359
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Fine-tuning pre-trained transformer-based language models such as BERT has become a common practice dominating leaderboards across various NLP benchmarks. Despite the strong empirical performance of fine-tuned models, fine-tuning is an unstable process: training the same model with multiple random seeds can result in a large variance of the task performance. Previous literature (Devlin et al., 2019; Lee et al., 2020; Dodge et al., 2020) identified two potential reasons for the observed instability: catastrophic forgetting and small size of the fine-tuning datasets. In this paper, we show that both hypotheses fail to explain the fine-tuning instability. We analyze BERT, RoBERTa, and ALBERT, fine-tuned on commonly used datasets from the GLUE benchmark, and show that the observed instability is caused by optimization difficulties that lead to vanishing gradients. Additionally, we show that the remaining variance of the downstream task performance can be attributed to differences in generalization where fine-tuned models with the same training loss exhibit noticeably different test performance. Based on our analysis, we present a simple but strong baseline that makes fine-tuning BERT-based models significantly more stable than the previously proposed approaches. Code to reproduce our results is available online: https://github.com/uds-lsv/bert-stable-fine-tuning. ",
+        "bbox": [
+            233,
+            375,
+            766,
+            625
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            650,
+            336,
+            666
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pre-trained transformer-based masked language models such as BERT (Devlin et al., 2019), RoBERTa (Liu et al., 2019), and ALBERT (Lan et al., 2020) have had a dramatic impact on the NLP landscape in the recent year. The standard recipe for using such models typically involves training a pretrained model for a few epochs on a supervised downstream dataset, which is known as fine-tuning. While fine-tuning has led to impressive empirical results, dominating a large variety of English NLP benchmarks such as GLUE (Wang et al., 2019b) and SuperGLUE (Wang et al., 2019a), it is still poorly understood. Not only have fine-tuned models been shown to pick up spurious patterns and biases present in the training data (Niven and Kao, 2019; McCoy et al., 2019), but also to exhibit a large training instability: fine-tuning a model multiple times on the same dataset, varying only the random seed, leads to a large standard deviation of the fine-tuning accuracy (Devlin et al., 2019; Dodge et al., 2020). ",
+        "bbox": [
+            174,
+            681,
+            825,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Few methods have been proposed to solve the observed instability (Phang et al., 2018; Lee et al., 2020), however without providing a sufficient understanding of why fine-tuning is prone to such failure. The goal of this work is to address this shortcoming. More specifically, we investigate the following question: ",
+        "bbox": [
+            174,
+            840,
+            825,
+            896
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Why is fine-tuning prone to failures and how can we improve its stability? ",
+        "bbox": [
+            258,
+            909,
+            740,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/2ca1eb5ee16c11f85ba9ece76c980550e0f43eb5a07b91cc6fbb1fed6786cf92.jpg",
+        "image_caption": [
+            "Figure 1: Our proposed fine-tuning strategy leads to very stable results with very concentrated development set performance over 25 different random seeds across all three datasets on BERT. In particular, we significantly outperform the recently proposed approach of Lee et al. (2020) in terms of fine-tuning stability. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            103,
+            818,
+            236
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We start by investigating two common hypotheses for fine-tuning instability: catastrophic forgetting and small size of the fine-tuning datasets and demonstrate that both hypotheses fail to explain fine-tuning instability. We then investigate fine-tuning failures on datasets from the popular GLUE benchmark and show that the observed fine-tuning instability can be decomposed into two separate aspects: (1) optimization difficulties early in training, characterized by vanishing gradients, and (2) differences in generalization late in training, characterized by a large variance of development set accuracy for runs with almost equivalent training loss. ",
+        "bbox": [
+            174,
+            318,
+            825,
+            416
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Based on our analysis, we present a simple but strong baseline for fine-tuning pre-trained language models that significantly improves the fine-tuning stability compared to previous works (Fig. 1). Moreover, we show that our findings apply not only to the widely used BERT model but also to more recent pre-trained models such as RoBERTa and ALBERT. ",
+        "bbox": [
+            174,
+            422,
+            825,
+            478
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            505,
+            339,
+            521
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The fine-tuning instability of BERT has been pointed out in various studies. Devlin et al. (2019) report instabilities when fine-tuning BERTLARGE on small datasets and resort to performing multiple restarts of fine-tuning and selecting the model that performs best on the development set. Recently, Dodge et al. (2020) performed a large-scale empirical investigation of the fine-tuning instability of BERT. They found dramatic variations in fine-tuning accuracy across multiple restarts and argue how it might be related to the choice of random seed and the dataset size. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            623
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Few approaches have been proposed to directly address the observed fine-tuning instability. Phang et al. (2018) study intermediate task training (STILTS) before fine-tuning with the goal of improving performance on the GLUE benchmark. They also find that their proposed method leads to improved fine-tuning stability. However, due to the intermediate task training, their work is not directly comparable to ours. Lee et al. (2020) propose a new regularization technique termed Mixout. The authors show that Mixout improves stability during fine-tuning which they attribute to the prevention of catastrophic forgetting. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            729
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another line of work investigates optimization difficulties of pre-training transformer-based language models (Xiong et al., 2020; Liu et al., 2020). Similar to our work, they highlight the importance of the learning rate warmup for optimization. Both works focus on pre-training and we hence view them as orthogonal to our work. ",
+        "bbox": [
+            176,
+            736,
+            825,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            818,
+            326,
+            834
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            853,
+            287,
+            867
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We study four datasets from the GLUE benchmark (Wang et al., 2019b) following previous work studying instability during fine-tuning: CoLA, MRPC, RTE, and QNLI. Detailed statistics for each of the datasets can be found in Section 7.2 in the Appendix. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "CoLA. The Corpus of Linguistic Acceptability (Warstadt et al., 2018) is a sentence-level classification task containing sentences labeled as either grammatical or ungrammatical. Fine-tuning on CoLA was observed to be particularly stable in previous work (Phang et al., 2018; Dodge et al., 2020; Lee et al., 2020). Performance on CoLA is reported in Matthew’s correlation coefficient (MCC). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "MRPC. The Microsoft Research Paraphrase Corpus (Dolan and Brockett, 2005) is a sentence-pair classification task. Given two sentences, a model has to judge whether the sentences paraphrases of each other. Performance on MRPC is measured using the $F _ { 1 }$ score. ",
+        "bbox": [
+            174,
+            166,
+            823,
+            208
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "RTE. The Recognizing Textual Entailment dataset is a collection of sentence-pairs collected from a series of textual entailment challenges (Dagan et al., 2005; Bar-Haim et al., 2006; Giampiccolo et al., 2007; Bentivogli et al., 2009). RTE is the second smallest dataset in the GLUE benchmark and fine-tuning on RTE was observed to be particularly unstable (Phang et al., 2018; Dodge et al., 2020; Lee et al., 2020). Accuracy is used to measure performance on RTE. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            285
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "QNLI. The Question-answering Natural Language Inference dataset contains sentence pairs obtained from SQuAD (Rajpurkar et al., 2016). Wang et al. (2019b) converted SQuAD into a sentence pair classification task by forming a pair between each question and each sentence in the corresponding paragraph. The task is to determine whether the context sentence contains the answer to the question, i.e. entails the answer. Accuracy is used to measure performance on QNLI. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            362
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 FINE-TUNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            397,
+            310,
+            411
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unless mentioned otherwise, we follow the default fine-tuning strategy recommended by Devlin et al. (2019): we fine-tune uncased BERTLARGE (henceforth BERT) using a batch size of 16 and a learning rate of $2 \\mathrm { e } { - } 5$ . The learning rate is linearly increased from 0 to $2 \\mathrm { e } { - } 5$ for the first $1 0 \\%$ of iterations—which is known as a warmup—and linearly decreased to 0 afterward. We apply dropout with probability $p = 0 . 1$ and weight decay with $\\lambda = 0 . 0 1$ . We train for 3 epochs on all datasets and use global gradient clipping. Following Devlin et al. (2019), we use the AdamW optimizer (Loshchilov and Hutter, 2019) without bias correction. ",
+        "bbox": [
+            174,
+            430,
+            825,
+            529
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We decided to not show results for BERTBASE since previous works observed no instability when fine-tuning BERTBASE which we also confirmed in our experiments. Instead, we show additional results on RoBERTaLARGE (Liu et al., 2019) and ALBERTLARGE-V2 (Lan et al., 2020) using the same fine-tuning strategy. We note that compared to BERT, both RoBERTa and ALBERT have slightly different hyperparameters. In particular, RoBERTa uses weight decay with $\\lambda = 0 . 1$ and no gradient clipping, and ALBERT does not use dropout. A detailed list of all default hyperparameters for all models can be found in Section 7.3 of the Appendix. Our implementation is based on HuggingFace’s transformers library (Wolf et al., 2019) and is available online: https://github. com/uds-lsv/bert-stable-fine-tuning. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            660
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Fine-tuning stability. By fine-tuning stability we mean the standard deviation of the fine-tuning performance (measured, e.g., in terms of accuracy, MCC or $F _ { 1 }$ score) over the randomness of an algorithm. We follow previous works (Phang et al., 2018; Dodge et al., 2020; Lee et al., 2020) and measure fine-tuning stability using the development sets from the GLUE benchmark. We discuss alternative notions of stability in Section 7.1 in the Appendix. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            737
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Failed runs. Following Dodge et al. (2020), we refer to a fine-tuning run as a failed run if its accuracy at the end of training is less or equal to that of a majority classifier on the respective dataset. The majority baselines for all tasks are found in Section 7.2 in the Appendix. ",
+        "bbox": [
+            174,
+            744,
+            825,
+            786
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 INVESTIGATING PREVIOUS HYPOTHESES FOR FINE-TUNING INSTABILITY ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            825,
+            805,
+            842
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Previous works on fine-tuning predominantly state two hypotheses for what can be related to finetuning instability: catastrophic forgetting and small training data size of the downstream tasks. Despite the ubiquity of these hypotheses (Devlin et al., 2019; Phang et al., 2018; Dodge et al., 2020; Lee et al., 2020), we argue that none of them has a causal relationship with fine-tuning instability. ",
+        "bbox": [
+            174,
+            867,
+            826,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/17e75685fd0e4826b400d7908b5e71f88d0b2ad10037586d5cf0ebde73a2ccb4.jpg",
+        "image_caption": [
+            "Figure 2: Language modeling perplexity for three failed (a) and successful (b) fine-tuning runs of BERT on RTE where we replace the weights of the top- $k$ layers with their pre-trained values. We can observe that it is often sufficient to reset around 10 layers out of 24 to recover back the language modeling abilities of the pre-trained model. (c) shows the average training loss and development accuracy $_ { ( \\pm 1 \\mathrm { s t d } ) }$ for 10 failed fine-tuning runs on RTE. Failed fine-tuning runs lead to a trivial training loss suggesting an optimization problem. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            109,
+            818,
+            244
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/a48e471441bf46291293b3e5d857c3ac31e96d8e550e638819994d2dc05d8be2.jpg",
+        "image_caption": [
+            "Figure 3: Development set results on down-sampled MRPC, CoLA, and QNLI using the default fine-tuning scheme of BERT (Devlin et al., 2019). The leftmost boxplot in each sub-figure shows the development accuracy when training on the full training set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            338,
+            825,
+            473
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 DOES CATASTROPHIC FORGETTING CAUSE FINE-TUNING INSTABILITY?",
+        "text_level": 1,
+        "bbox": [
+            174,
+            551,
+            704,
+            565
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Catastrophic forgetting (McCloskey and Cohen, 1989; Kirkpatrick et al., 2017) refers to the phenomenon when a neural network is sequentially trained to perform two different tasks, and it loses its ability to perform the first task after being trained on the second. More specifically, in our setup, it means that after fine-tuning a pre-trained model, it can no longer perform the original masked language modeling task used for pre-training. This can be measured in terms of the perplexity on the original training data. Although the language modeling performance of a pre-trained model correlates with its fine-tuning accuracy (Liu et al., 2019; Lan et al., 2020), there is no clear motivation for why preserving the original masked language modeling performance after fine-tuning is important.1 ",
+        "bbox": [
+            173,
+            577,
+            825,
+            689
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the context of fine-tuning BERT, Lee et al. (2020) suggest that their regularization method has an effect of alleviating catastrophic forgetting. Thus, it is important to understand how exactly catastrophic forgetting occurs during fine-tuning and how it relates to the observed fine-tuning instability. To better understand this, we perform the following experiment: we fine-tune BERT on RTE, following the default strategy by Devlin et al. (2019). We select three successful and three failed fine-tuning runs and evaluate their masked language modeling perplexity on the test set of the WikiText-2 language modeling benchmark (Merity et al., 2016).2 We sequentially substitute the top- $k$ layers of the network varying $k$ from 0 (i.e. all layers are from the fine-tuned model) to 24 (i.e. all layers are from the pre-trained model). We show the results in Fig. 2 (a) and (b). ",
+        "bbox": [
+            173,
+            695,
+            825,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We can observe that although catastrophic forgetting occurs for the failed models (Fig. 2a) — perplexity on WikiText-2 is indeed degraded for $k = 0$ — the phenomenon is much more nuanced. Namely, catastrophic forgetting affects only the top layers of the network — in our experiments often around ",
+        "bbox": [
+            176,
+            828,
+            821,
+            871
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "10 out of 24 layers, and the same is however also true for the successfully fine-tuned models, except for a much smaller increase in perplexity. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Another important aspect of our experiment is that catastrophic forgetting typically requires that the model at least successfully learns how to perform the new task. However, this is not the case for the failed fine-tuning runs. Not only is the development accuracy equal to that of the majority classifier, but also the training loss on the fine-tuning task (here RTE) is trivial, i.e. close to $- \\ln ( 1 / 2 )$ (see Fig. 2 (c)). This suggests that the observed fine-tuning failure is rather an optimization problem causing catastrophic forgetting in the top layers of the pre-trained model. We will show later that the optimization aspect is actually sufficient to explain most of the fine-tuning variance. ",
+        "bbox": [
+            174,
+            140,
+            825,
+            236
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 DO SMALL TRAINING DATASETS CAUSE FINE-TUNING INSTABILITY?",
+        "text_level": 1,
+        "bbox": [
+            176,
+            256,
+            684,
+            268
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Having a small training dataset is by far the most commonly stated hypothesis for fine-tuning instability. Multiple recent works (Devlin et al., 2019; Phang et al., 2018; Lee et al., 2020; Zhu et al., 2020; Dodge et al., 2020; Pruksachatkun et al., 2020) that have observed BERT fine-tuning to be unstable relate this finding to the small number of training examples. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            337
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To test if having a small training dataset inherently leads to fine-tuning instability we perform the following experiment:3 we randomly sample 1,000 training samples from the CoLA, MRPC, and QNLI training datasets and fine-tune BERT using 25 different random seeds on each dataset. We compare two different settings: first, training for 3 epochs on the reduced training dataset, and second, training for the same number of iterations as on the full training dataset. We show the results in Fig. 3 and observe that training on less data does indeed affect the fine-tuning variance, in particular, there are many more failed runs. However, when we simply train for as many iterations as on the full training dataset, we almost completely recover the original variance of the fine-tuning performance. We also observe no failed runs on MRPC and QNLI and only a single failed run on CoLA which is similar to the results obtained by training on the full training set. Further, as expected, we observe that training on fewer samples affects the generalization of the model, leading to a worse development set performance on all three tasks.4 ",
+        "bbox": [
+            174,
+            344,
+            825,
+            510
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We conclude from this experiment, that the role of training dataset size per se is orthogonal to fine-tuning stability. What is crucial is rather the number of training iterations. As our experiment shows, the observed increase in instability when training with smaller datasets can rather be attributed to the reduction of the number of iterations (that changes the effective learning rate schedule) which, as we will show in the next section, has a crucial influence on the fine-tuning stability. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            587
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 DISENTANGLING OPTIMIZATION AND GENERALIZATION IN FINE-TUNING INSTABILITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            611,
+            805,
+            642
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our findings in Section 4 detail that while both catastrophic forgetting and small size of the datasets indeed correlate with fine-tuning instability, none of them are causing it. In this section, we argue that the fine-tuning instability is an optimization problem, and it admits a simple solution. Additionally, we show that even though a large fraction of the fine-tuning instability can be explained by optimization, the remaining instability can be attributed to generalization issues where fine-tuning runs with the same training loss exhibit noticeable differences in the development set performance. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 THE ROLE OF OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            762,
+            413,
+            775
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Failed fine-tuning runs suffer from vanishing gradients. We observed in Fig. 2c that the failed runs have practically constant training loss throughout the training (see Fig. 14 in the Appendix for a comparison with successful fine-tuning). In order to better understand this phenomenon, in Fig. 4 we plot the $\\ell _ { 2 }$ gradient norms of the loss function with respect to different layers of BERT, for one failed and successful fine-tuning run. For the failed run we see large enough gradients only for the top layers and vanishing gradients for the bottom layers. This is in large contrast to the successful run. While we also observe small gradients at the beginning of training (until iteration 70), gradients start to grow as training continues. Moreover, at the end of fine-tuning, we observe gradient norms nearly $2 \\times$ orders of magnitude larger than that of the failed run. Similar visualizations for additional layers and weights can be found in Fig. 10 in the Appendix. Moreover, we observe the same behavior also for RoBERTa and ALBERT models, and the corresponding figures can be found in the Appendix as well (Fig. 11 and 12). ",
+        "bbox": [
+            174,
+            789,
+            825,
+            858
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/57e7a65c978622e72bb1473321aaeda3de93a912bcd3ee37e09d63cc6b5f65c8.jpg",
+        "image_caption": [
+            "Figure 4: Gradient norms (plotted on a logarithmic scale) of different layers on RTE for a failed and successful run of BERT fine-tuning. We observe that the failed run is characterized by vanishing gradients in the bottom layers of the network. Additional plots for other weight matrices can be found in the Appendix. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            246,
+            113,
+            751,
+            267
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/3191efa17953497d2e9ffc0c93f807f8b51d41f4b8d3de7bc3e0485cd1eece89.jpg",
+        "image_caption": [
+            "Figure 5: Box plots showing the fine-tuning performance of (a) BERT, (b) RoBERTa, (c) ALBERT for different learning rates $\\alpha$ with and without bias correction (BC) on RTE. For BERT and ALBERT, having bias correction leads to more stable results and allows to train using larger learning rates. For RoBERTa, the effect is less pronounced but still visible. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            342,
+            826,
+            472
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            568,
+            825,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Importantly, we note that the vanishing gradients we observe during fine-tuning are harder to resolve than the standard vanishing gradient problem (Hochreiter, 1991; Bengio et al., 1994). In particular, common weight initialization schemes (Glorot and Bengio, 2010; He et al., 2015) ensure that the pre-activations of each layer of the network have zero mean and unit variance in expectation. However, we cannot simply modify the weights of a pre-trained model on each layer to ensure this property since this would conflict with the idea of using the pre-trained weights. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            757
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Importance of bias correction in ADAM. Following Devlin et al. (2019), subsequent works on fine-tuning BERT-based models use the ADAM optimizer (Kingma and Ba, 2015). A subtle detail of the fine-tuning scheme of Devlin et al. (2019) is that it does not include the bias correction in ADAM. Kingma and Ba (2015) already describe the effect of the bias correction as to reduce the learning rate at the beginning of training. By rewriting the update equations of ADAM as follows, we can clearly see this effect of bias correction: ",
+        "bbox": [
+            173,
+            763,
+            825,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4a893f8dabcba29556295ef549e7aaf7e62b1445705b134780d68aa339017a43.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\alpha _ { t }  \\alpha \\cdot \\sqrt { 1 - \\beta _ { 2 } ^ { t } } / ( 1 - \\beta _ { 1 } ^ { t } ) , } } \\\\ { { \\theta _ { t }  \\theta _ { t - 1 } - \\alpha _ { t } \\cdot m _ { t } / ( \\sqrt { v _ { t } } + \\epsilon ) , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            859,
+            609,
+            907
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/3c47d595d071fb108f72fd94bef1fccf858d1b6f1f998d6e516fba81f4a80708.jpg",
+        "image_caption": [
+            "Figure 7: 2D loss surfaces in the subspace spanned by $\\delta _ { 1 } = \\theta _ { f } - \\theta _ { p }$ and $\\delta _ { 2 } = \\theta _ { s } - \\theta _ { p }$ on RTE, MRPC, and CoLA. $\\theta _ { p } , \\theta _ { f }$ , $\\theta _ { s }$ denote the parameters of the pre-trained, failed, and successfully trained model, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            106,
+            823,
+            246
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here $m _ { t }$ and $v _ { t }$ are biased first and second moment estimates respectively. Equation (1) shows that bias correction simply boils down to reducing the original step size $\\alpha$ by a multiplicative factor $\\sqrt { 1 - \\beta _ { 2 } ^ { t } } / ( 1 - \\beta _ { 1 } ^ { t } )$ which is significantly below 1 for the first iterations of training and approaches 1 as the number of training iterations $t$ increases (see Fig. 6). Along the same lines, You et al. (2020) explicitly remark that bias correction in ADAM has a similar effect to the warmup which is widely used in deep learning to prevent divergence early in training (He et al., 2016; Goyal et al., 2017; Devlin et al., 2019; Wong et al., 2020). ",
+        "bbox": [
+            174,
+            321,
+            581,
+            477
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9a66213890a3d625ea59c5e23e6ef48bb4a27bf9977d9ae208e9e6e199e42c24.jpg",
+        "image_caption": [
+            "Figure 6: The bias correction term of ADAM ( $\\beta _ { 1 } = 0 . 9$ and $\\beta _ { 2 } = 0 . 9 9 9$ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            606,
+            324,
+            810,
+            439
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The implicit warmup of ADAM is likely to be an important factor that contributed to its success. We argue that fine-tuning BERT-based language models is not an exception. In Fig. 5 we show the results of fine-tuning on RTE with and without bias correction for BERT, RoBERTa, and ALBERT models.5 We observe that there is a significant benefit in combining warmup with bias correction, particularly for BERT and ALBERT. Even though for RoBERTa fine-tuning is already more stable even without bias correction, adding bias correction gives an additional improvement. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            568
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our results show that bias correction is useful if we want to get the best performance within 3 epochs, the default recommendation by Devlin et al. (2019). An alternative solution is to simply train longer with a smaller learning rate, which also leads to much more stable fine-tuning. We provide a more detailed ablation study in Appendix (Fig. 9) with analogous box plots for BERT using various learning rates, numbers of training epochs, with and without bias correction. Finally, concurrently to our work, Zhang et al. (2021) also make a similar observation about the importance of bias correction and longer training which gives further evidence to our findings. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            671
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Loss surfaces. To get further intuition about the fine-tuning failure, we provide loss surface visualizations (Li et al., 2018; Hao et al., 2019) of failed and successful runs when fine-tuning BERT. Denote by $\\theta _ { p }$ , $\\theta _ { f }$ , $\\theta _ { s }$ the parameters of the pre-trained model, failed model, and successfully trained model, respectively. We plot a two-dimensional loss surface $f ( \\alpha , \\beta ) = \\mathcal { L } ( \\theta _ { p } + \\alpha \\delta _ { 1 } + \\beta \\delta _ { 2 } )$ in the subspace spanned by $\\delta _ { 1 } = \\theta _ { f } - \\theta _ { p }$ and $\\delta _ { 2 } = \\theta _ { s } - \\theta _ { p }$ centered at the weights of the pre-trained model $\\theta _ { p }$ . Additional details are specified in Section 7.6 in the Appendix. ",
+        "bbox": [
+            174,
+            678,
+            825,
+            762
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Contour plots of the loss surfaces for RTE, MRPC, and CoLA are shown in Fig. 7. They provide additional evidence to our findings on vanishing gradients: for failed fine-tuning runs gradient descent converges to a “bad” valley with a sub-optimal training loss. Moreover, this bad valley is separated from the local minimum (to which the successfully trained run converged) by a barrier (see also Fig. 13 in the Appendix). Interestingly, we observe a highly similar geometry for all three datasets providing further support for our interpretation of fine-tuning instability as a primarily optimization issue. ",
+        "bbox": [
+            173,
+            768,
+            825,
+            866
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ca95a024a64a8b0ba9fc93b72ee20f9b1017d95083887ebc0519890dcc0a0e16.jpg",
+        "image_caption": [
+            "Figure 8: Development set accuracy for multiple fine-tuning runs on RTE. The models for (a) are trained with 10 different seeds, and models for (b) are taken at the end of the training, and trained with different seeds and hyperparameters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            217,
+            104,
+            782,
+            282
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 THE ROLE OF GENERALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            364,
+            434,
+            378
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We now turn to the generalization aspects of fine-tuning instability. In order to show that the remaining fine-tuning variance on the development set can be attributed to generalization, we perform the following experiment: we fine-tune BERT on RTE for 20 epochs and show the development set accuracy for 10 successful runs in Fig. 8a. Further, we show in Fig. 8b the development set accuracy vs. training loss of all BERT models fine-tuned on RTE for the full ablation study (shown in Fig. 9 in the Appendix), in total 450 models. ",
+        "bbox": [
+            173,
+            390,
+            825,
+            473
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We find that despite achieving close to zero training loss overfitting is not an issue during fine-tuning. This is consistent with previous work (Hao et al., 2019), which arrived at a similar conclusion. Based on our results, we argue that it is even desirable to train for a larger number of iterations since the development accuracy varies considerably during fine-tuning and it does not degrade even when the training loss is as low as 10−5. ",
+        "bbox": [
+            174,
+            481,
+            825,
+            550
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Combining these findings with results from the previous section, we conclude that the fine-tuning instability can be decomposed into two aspects: optimization and generalization. In the next section, we propose a simple solution addressing both issues. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            599
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 A SIMPLE BUT HARD-TO-BEAT BASELINE FOR FINE-TUNING BERT ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            621,
+            758,
+            636
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As our findings in Section 5 show, the empirically observed instability of fine-tuning BERT can be attributed to vanishing gradients early in training as well as differences in generalization late in training. Given the new understanding of fine-tuning instability, we propose the following guidelines for fine-tuning transformer-based masked language models on small datasets: ",
+        "bbox": [
+            174,
+            651,
+            825,
+            707
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• Use small learning rates with bias correction to avoid vanishing gradients early in training.   \n• Increase the number of iterations considerably and train to (almost) zero training loss. ",
+        "bbox": [
+            209,
+            714,
+            823,
+            742
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This leads to the following simple baseline scheme: we fine-tune BERT using ADAM with bias correction and a learning rate of 2e−5. The training is performed for 20 epochs, and the learning rate is linearly increased for the first $1 0 \\%$ of steps and linearly decayed to zero afterward. All other hyperparameters are kept unchanged. A full ablation study on RTE testing various combinations of the changed hyperparameters is presented in Section 7.4 in the Appendix. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            819
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results. Despite the simplicity of our proposed fine-tuning strategy, we obtain strong empirical performance. Table 1 and Fig. 1 show the results of fine-tuning BERT on RTE, MRPC, and CoLA. We compare to the default strategy of Devlin et al. (2019) and the recent Mixout method from Lee et al. (2020). First, we observe that our method leads to a much more stable fine-tuning performance on all three datasets as evidenced by the significantly smaller standard deviation of the final performance. To further validate our claim about the fine-tuning stability, we run Levene’s test (Levene, 1960) to check the equality of variances for the distributions of the final performances on each dataset. For all three datasets, the test results in a p-value less than 0.001 when we compare the variances between our method and the method achieving the second smallest variance. Second, we also observe that our method improves the overall fine-tuning performance: in Table 1 we achieve a higher mean value on all datasets and also comparable or better maximum performance on MRPC and CoLA respectively. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b8e84593c9e859f37803c22973a47e3e0af11e360b1685bcbc1c6724b38ee6e8.jpg",
+        "table_caption": [
+            "Table 1: Standard deviation, mean, and maximum performance on the development set of RTE, MRPC, and CoLA when fine-tuning BERT over 25 random seeds. Standard deviation: lower is better, i.e. fine-tuning is more stable. ? denotes significant difference $\\mathit { p } < 0 . 0 0 1 $ ) when compared to the second smallest standard deviation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Approach</td><td colspan=\"3\">RTE</td><td colspan=\"3\">MRPC</td><td colspan=\"3\">CoLA</td></tr><tr><td></td><td>std</td><td>mean</td><td>max</td><td>std</td><td>mean</td><td>max</td><td>std</td><td>mean</td><td>max</td></tr><tr><td>Devlin et al. (2019)</td><td>4.5</td><td>50.9</td><td>67.5</td><td>3.9</td><td>84.0</td><td>91.2</td><td>25.6</td><td>45.6</td><td>64.6</td></tr><tr><td>Lee et al. (2020)</td><td>7.9</td><td>65.3</td><td>74.4</td><td>3.8</td><td>87.8</td><td>91.8</td><td>20.9</td><td>51.9</td><td>64.0</td></tr><tr><td>Ours</td><td>2.7*</td><td>67.3</td><td>71.1</td><td>0.8*</td><td>90.3</td><td>91.7</td><td>1.8*</td><td>62.1</td><td>65.3</td></tr></table>",
+        "bbox": [
+            191,
+            151,
+            805,
+            243
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            268,
+            825,
+            325
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, we note that we suggest to increase the number of fine-tuning iterations only for small datasets, and thus the increased computational cost of our proposed scheme is not a problem in practice. Moreover, we think that overall our findings lead to more efficient fine-tuning because of the significantly improved stability which effectively reduces the number of necessary fine-tuning runs. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            387
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            410,
+            328,
+            425
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we have discussed the existing hypotheses regarding the reasons behind fine-tuning instability and proposed a new baseline strategy for fine-tuning that leads to significantly improved fine-tuning stability and overall improved results on commonly used datasets from the GLUE benchmark. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            497
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "By analyzing failed fine-tuning runs, we find that neither catastrophic forgetting nor small dataset sizes sufficiently explain fine-tuning instability. Instead, our analysis reveals that fine-tuning instability can be characterized by two distinct problems: (1) optimization difficulties early in training, characterized by vanishing gradients, and (2) differences in generalization, characterized by a large variance of development set accuracy for runs with almost equivalent training performance. ",
+        "bbox": [
+            174,
+            505,
+            825,
+            575
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Based on our analysis, we propose a simple but strong baseline strategy for fine-tuning BERT which outperforms the previous works in terms of fine-tuning stability and overall performance. ",
+        "bbox": [
+            174,
+            582,
+            821,
+            609
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            632,
+            356,
+            647
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We thank Anna Khokhlova for her help with the language modeling experiments, Cheolhyoung Lee and Jesse Dodge for providing us with details of their works, and Badr Abdullah and Aditya Mogadala for their helpful comments on a draft of this paper. ",
+        "bbox": [
+            174,
+            664,
+            825,
+            705
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This work was funded by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) – Project-ID 232722074 – SFB 1102. ",
+        "bbox": [
+            173,
+            713,
+            823,
+            741
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            763,
+            287,
+            779
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Roy Bar-Haim, Ido Dagan, Bill Dolan, Lisa Ferro, and Danilo Giampiccolo. 2006. The second pascal recognising textual entailment challenge. Proceedings of the Second PASCAL Challenges Workshop on Recognising Textual Entailment. ",
+        "bbox": [
+            174,
+            787,
+            825,
+            830
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Patrice Simard, and Paolo Frasconi. 1994. Learning long-term dependencies with gradient descent is difficult. IEEE transactions on neural networks, 5(2):157–166. ",
+        "bbox": [
+            173,
+            840,
+            823,
+            869
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Luisa Bentivogli, Ido Dagan, Hoa Trang Dang, Danilo Giampiccolo, and Bernardo Magnini. 2009. The fifth pascal recognizing textual entailment challenge. In Proceedings of the Second Text Analysis Conference (TAC 2009). ",
+        "bbox": [
+            176,
+            881,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ido Dagan, Oren Glickman, and Bernardo Magnini. 2005. The pascal recognising textual entailment challenge. In Proceedings of the First International Conference on Machine Learning Challenges: Evaluating Predictive Uncertainty Visual Object Classification, and Recognizing Textual Entailment, MLCW’05, page 177–190, Berlin, Heidelberg. Springer-Verlag. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171–4186, Minneapolis, Minnesota. Association for Computational Linguistics. ",
+        "bbox": [
+            173,
+            170,
+            826,
+            241
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jesse Dodge, Gabriel Ilharco, Roy Schwartz, Ali Farhadi, Hannaneh Hajishirzi, and Noah Smith. 2020. Fine-tuning pretrained language models: Weight initializations, data orders, and early stopping. arXiv preprint arXiv:2002.06305. ",
+        "bbox": [
+            176,
+            252,
+            823,
+            295
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "William B. Dolan and Chris Brockett. 2005. Automatically constructing a corpus of sentential paraphrases. In Proceedings of the Third International Workshop on Paraphrasing (IWP2005). ",
+        "bbox": [
+            171,
+            305,
+            823,
+            335
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danilo Giampiccolo, Bernardo Magnini, Ido Dagan, and Bill Dolan. 2007. The third pascal recognizing textual entailment challenge. In Proceedings of the ACL-PASCAL Workshop on Textual Entailment and Paraphrasing, RTE ’07, page 1–9, USA. Association for Computational Linguistics. ",
+        "bbox": [
+            173,
+            344,
+            826,
+            401
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot and Yoshua Bengio. 2010. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pages 249–256. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            455
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Piotr Dollár, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. 2017. Accurate, large minibatch sgd: Training imagenet in 1 hour. ",
+        "bbox": [
+            174,
+            465,
+            823,
+            508
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yaru Hao, Li Dong, Furu Wei, and Ke Xu. 2019. Visualizing and understanding the effectiveness of BERT. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLPIJCNLP), pages 4143–4152, Hong Kong, China. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            577
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2015. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE international conference on computer vision, pages 1026–1034. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            631
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2016. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770–778. ",
+        "bbox": [
+            173,
+            640,
+            825,
+            684
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter. 1991. Untersuchungen zu dynamischen neuronalen netzen. Diploma, Technische Universität München, 91(1). ",
+        "bbox": [
+            173,
+            694,
+            823,
+            723
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tushar Khot, Ashish Sabharwal, and Peter Clark. 2018. Scitail: A textual entailment dataset from science question answering. ",
+        "bbox": [
+            173,
+            733,
+            823,
+            763
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. 2015. Adam: A method for stochastic optimization. In International Conference on Learning Representations. ",
+        "bbox": [
+            173,
+            773,
+            823,
+            803
+        ],
+        "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 et al. 2017. Overcoming catastrophic forgetting in neural networks. Proceedings of the National Academy of Sciences, 114(13):3521–3526. ",
+        "bbox": [
+            174,
+            814,
+            826,
+            869
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. 2020. Albert: A lite bert for self-supervised learning of language representations. In International Conference on Learning Representations. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cheolhyoung Lee, Kyunghyun Cho, and Wanmo Kang. 2020. Mixout: Effective regularization to finetune large-scale pretrained language models. In International Conference on Learning Representations. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Howard Levene. 1960. Robust tests for equality of variances. Contributions to probability and statistics: Essays in honor of Harold Hotelling, pages 278–292. ",
+        "bbox": [
+            171,
+            155,
+            825,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hao Li, Zheng Xu, Gavin Taylor, Christoph Studer, and Tom Goldstein. 2018. Visualizing the loss landscape of neural nets. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett, editors, Advances in Neural Information Processing Systems 31, pages 6389–6399. Curran Associates, Inc. ",
+        "bbox": [
+            174,
+            193,
+            826,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Liyuan Liu, Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Jiawei Han. 2020. On the variance of the adaptive learning rate and beyond. In International Conference on Learning Representations. ",
+        "bbox": [
+            174,
+            258,
+            825,
+            301
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692. ",
+        "bbox": [
+            174,
+            309,
+            825,
+            352
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. 2019. Decoupled weight decay regularization. In International Conference on Learning Representations. ",
+        "bbox": [
+            174,
+            361,
+            823,
+            390
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael McCloskey and Neal J Cohen. 1989. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of learning and motivation, volume 24, pages 109–165. Elsevier. ",
+        "bbox": [
+            174,
+            398,
+            825,
+            441
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "R. Thomas McCoy, Junghyun Min, and Tal Linzen. 2020. BERTs of a feather do not generalize together: Large variability in generalization across models with similar test set performance. In Proceedings of the Third BlackboxNLP Workshop on Analyzing and Interpreting Neural Networks for NLP, pages 217–227, Online. Association for Computational Linguistics. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            507
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom McCoy, Ellie Pavlick, and Tal Linzen. 2019. Right for the wrong reasons: Diagnosing syntactic heuristics in natural language inference. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 3428–3448, Florence, Italy. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            573
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. 2016. Pointer sentinel mixture models. arXiv preprint arXiv:1609.07843. ",
+        "bbox": [
+            171,
+            580,
+            823,
+            611
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Timothy Niven and Hung-Yu Kao. 2019. Probing neural network comprehension of natural language arguments. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pages 4658–4664, Florence, Italy. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            662
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jason Phang, Thibault Févry, and Samuel R Bowman. 2018. Sentence encoders on stilts: Supplementary training on intermediate labeled-data tasks. arXiv preprint arXiv:1811.01088. ",
+        "bbox": [
+            173,
+            670,
+            821,
+            700
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yada Pruksachatkun, Jason Phang, Haokun Liu, Phu Mon Htut, Xiaoyi Zhang, Richard Yuanzhe Pang, Clara Vania, Katharina Kann, and Samuel R. Bowman. 2020. Intermediate-task transfer learning with pretrained language models: When and why does it work? In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 5231–5247, Online. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            779
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. 2016. SQuAD: $^ { 1 0 0 , 0 0 0 + }$ questions for machine comprehension of text. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pages 2383–2392, Austin, Texas. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            787,
+            825,
+            844
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Wang, Yada Pruksachatkun, Nikita Nangia, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel Bowman. 2019a. Superglue: A stickier benchmark for general-purpose language understanding systems. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d’Alché Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32, pages 3266–3280. Curran Associates, Inc. ",
+        "bbox": [
+            176,
+            853,
+            826,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. 2019b. GLUE: A multi-task benchmark and analysis platform for natural language understanding. In International Conference on Learning Representations. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Warstadt, Amanpreet Singh, and Samuel R Bowman. 2018. Neural network acceptability judgments. arXiv preprint arXiv:1805.12471. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, Rémi Louf, Morgan Funtowicz, et al. 2019. Transformers: State-of-theart natural language processing. arXiv preprint arXiv:1910.03771. ",
+        "bbox": [
+            174,
+            193,
+            821,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Eric Wong, Leslie Rice, and J. Zico Kolter. 2020. Fast is better than free: Revisiting adversarial training. In International Conference on Learning Representations. ",
+        "bbox": [
+            173,
+            243,
+            821,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ruibin Xiong, Yunchang Yang, Di He, Kai Zheng, Shuxin Zheng, Chen Xing, Huishuai Zhang, Yanyan Lan, Liwei Wang, and Tie-Yan Liu. 2020. On layer normalization in the transformer architecture. arXiv preprint arXiv:2002.04745. ",
+        "bbox": [
+            174,
+            281,
+            823,
+            324
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yang You, Jing Li, Sashank Reddi, Jonathan Hseu, Sanjiv Kumar, Srinadh Bhojanapalli, Xiaodan Song, James Demmel, Kurt Keutzer, and Cho-Jui Hsieh. 2020. Large batch optimization for deep learning: Training bert in 76 minutes. In International Conference on Learning Representations. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tianyi Zhang, Felix Wu, Arzoo Katiyar, Kilian Q Weinberger, and Yoav Artzi. 2021. Revisiting few-sample BERT fine-tuning. In International Conference on Learning Representations. ",
+        "bbox": [
+            173,
+            385,
+            823,
+            414
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chen Zhu, Yu Cheng, Zhe Gan, Siqi Sun, Tom Goldstein, and Jingjing Liu. 2020. Freelb: Enhanced adversarial training for natural language understanding. In International Conference on Learning Representations. ",
+        "bbox": [
+            174,
+            422,
+            825,
+            465
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            263,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "7.1 ALTERNATIVE NOTIONS OF STABILITY ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            133,
+            478,
+            147
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Here, we elaborate on other possible definitions of fine-tuning stability. The definition that we use throughout the paper follows the previous work (Phang et al., 2018; Dodge et al., 2020; Lee et al., 2020). For example, while Dodge et al. (2020) do not directly define fine-tuning stability, they report and analyze the standard deviation of the validation performance (e.g., see Section 4.1 of their paper). Along the same lines, an earlier work of Phang et al. (2018), which studies the influence of intermediate fine-tuning, discusses the variance of the validation performance (see Section 4: Results, paragraph Fine-Tuning Stability therein) and shows the standard deviation over multiple random seeds in Figure 1. ",
+        "bbox": [
+            173,
+            157,
+            826,
+            270
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For simplicity, let us assume that the performance metric is accuracy and we have two classes. Let $A$ be a randomized fine-tuning algorithm that produces a classifier $f _ { A }$ , and let us denote data points as $( x , y ) \\sim \\mathcal { D }$ where $\\mathcal { D }$ is the data-generating distribution. Our definition of fine-tuning stability can be formalized as follows: ",
+        "bbox": [
+            173,
+            276,
+            825,
+            332
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9b2b8cb13be63d20270ba2830c5391dab93cd991e475c515d86a0a0478d13ed1.jpg",
+        "text": "$$\nS _ { \\mathrm { o u r s } } ( A ) = \\mathrm { V a r } _ { A } \\left[ \\mathrm { E } _ { x , y } \\left[ \\mathbb { 1 } _ { f _ { A } ( x ) = y } \\right] \\right] = \\mathrm { V a r } _ { A } \\left[ \\mathrm { A c c u r a c y } ( f _ { A } ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            333,
+            699,
+            353
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "This definition directly measures the variance of the performance metric and aims to answer the question: If we perform fine-tuning multiple times, how large will the difference in performance be? ",
+        "bbox": [
+            174,
+            353,
+            823,
+            382
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "An alternative definition of fine-tuning stability that could be considered is per-point stability where the expectation and variance are interchanged: ",
+        "bbox": [
+            173,
+            387,
+            823,
+            416
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e8af2a647d12834bd5ffbce865436fae63c57e76348d1aebd96e277cf5707c12.jpg",
+        "text": "$$\nS _ { \\mathrm { p e r - p o i n t } } ( A ) = \\mathrm { E } _ { x , y } \\left[ \\mathrm { V a r } _ { A } \\left[ \\mathbb { 1 } _ { f _ { A } ( x ) = y } \\right] \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            417,
+            630,
+            436
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "This definition captures a different notion of stability. Namely, it captures stability per data point by measuring how much the classifiers $f _ { A }$ differ on the same point $x$ given label $y$ . Studying the per-point fine-tuning stability can be useful to better understand the properties of fine-tuned models and we refer to McCoy et al. (2020) for a study in this direction. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            492
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "7.2 TASK STATISTICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            508,
+            334,
+            522
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Statistics for each of the datasets studied in this paper are shown in Table 2. All datasets are publicly available. The GLUE datasets can be downloaded here: https://github.com/nyu-mll/ jiant. SciTail is available at https://github.com/allenai/scitail. ",
+        "bbox": [
+            176,
+            534,
+            826,
+            577
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/36e44997ce4bc84b6bc75f869fe0272ab87f8a8612e07707a008598221a4ff40.jpg",
+        "table_caption": [
+            "Table 2: Dataset statistics and majority baselines. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>RTE</td><td>MRPC</td><td>CoLA</td><td>QNLI</td><td>SciTail</td></tr><tr><td>Training</td><td>2491</td><td>3669</td><td>8551</td><td>104744</td><td>23596</td></tr><tr><td>Development</td><td>278</td><td>409</td><td>1043</td><td>5464</td><td>1304</td></tr><tr><td>Majority baseline</td><td>0.53</td><td>0.75</td><td>0.0</td><td>0.50</td><td>0.63</td></tr><tr><td>Metric</td><td>Acc.</td><td>F1 score</td><td>MCC</td><td>Acc.</td><td>Acc.</td></tr></table>",
+        "bbox": [
+            266,
+            611,
+            730,
+            698
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "7.3 HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            719,
+            357,
+            734
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameters for BERT, RoBERTa, and ALBERT used for all our experiments are shown in Table 3. ",
+        "bbox": [
+            176,
+            744,
+            823,
+            773
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "7.4 ABLATION STUDIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            790,
+            352,
+            804
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Figure 9 shows the results of fine-tuning on RTE with different combinations of learning rate, number of training epochs, and bias correction. We make the following observations: ",
+        "bbox": [
+            168,
+            815,
+            825,
+            844
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "• When training for only 3 epochs, disabling bias correction clearly hurts performance. • With bias correction, training with larger learning rates is possible. • Combining the usage of bias correction with training for more epochs leads to the best performance. ",
+        "bbox": [
+            215,
+            853,
+            825,
+            919
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/8e6041c913757b68ade8bd2ce9cc243f8155476e8baa77a8c80c2cef0ac9edf6.jpg",
+        "image_caption": [
+            "Figure 9: Full ablation of fine-tuning BERT on RTE. For each setting, we vary only the number of training steps, learning rate, and usage of bias correction (BC). All other hyperparameters are unchanged. We fine-tune 25 models for each setting. $\\star$ shows the setting which we recommend as a new baseline fine-tuning strategy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            207,
+            802,
+            767
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/3d348f706c864cb62ba315139c71ac8b5ecb6c4825a4126a3fb1b566bf718030.jpg",
+        "table_caption": [
+            "Table 3: Hyperparameters used for fine-tuning. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyperparam</td><td>BERT</td><td>RoBERTa</td><td>ALBERT</td></tr><tr><td>Epochs</td><td>3,10,20</td><td>3</td><td>3</td></tr><tr><td>Learning rate</td><td>le-5-5e-5</td><td>le-5-3e-5</td><td>le-5-3e-5</td></tr><tr><td>Learning rate schedule</td><td>warmup-linear</td><td>warmup-linear</td><td>warmup-linear</td></tr><tr><td>Warmup ratio</td><td>0.1</td><td>0.1</td><td>0.1</td></tr><tr><td>Batch size</td><td>16</td><td>16</td><td>16</td></tr><tr><td>Adam e</td><td>1e-6</td><td>1e-6</td><td>1e-6</td></tr><tr><td>Adam β1</td><td>0.9</td><td>0.9</td><td>0.9</td></tr><tr><td>Adam β2</td><td>0.999</td><td>0.98</td><td>0.999</td></tr><tr><td>Adam bias correction</td><td>{True,False}</td><td>{True, False}</td><td>{True,False}</td></tr><tr><td>Dropout</td><td>0.1</td><td>0.1</td><td>1</td></tr><tr><td>Weight decay</td><td>0.01</td><td>0.1</td><td>1</td></tr><tr><td>Clipping gradient norm</td><td>1.0</td><td>1</td><td>1.0</td></tr><tr><td>Number of random seeds</td><td>25</td><td>25</td><td>25</td></tr></table>",
+        "bbox": [
+            232,
+            126,
+            766,
+            337
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "7.5 ADDITIONAL GRADIENT NORM VISUALIZATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            364,
+            550,
+            377
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We provide additional visualizations for the vanishing gradients observed when fine-tuning BERT, RoBERTa, and ALBERT in Figures 10, 11, 12. Note that for ALBERT besides the pooler and classification layers, we plot only the gradient norms of a single hidden layer (referred to as layer0) because of weight sharing. ",
+        "bbox": [
+            174,
+            388,
+            825,
+            445
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Gradient norms and MLM perplexity. We can see from the gradient norm visualizations for BERT in Figures 4 and 10 that the gradient norm of the pooler and classification layer remains large. Hence, even though the gradients on most layers of the model vanish, we still update the weights on the top layers. In fact, this explains the large increase in MLM perplexity for the failed models which is shown in Fig. 2a. While most of the layers do not change as we continue training, the top layers of the network change dramatically. ",
+        "bbox": [
+            174,
+            452,
+            825,
+            536
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "7.6 LOSS SURFACES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            554,
+            326,
+            569
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For Fig. 7, we define the range for both $\\alpha$ and $\\beta$ as $[ - 1 . 5 , 1 . 5 ]$ and sample 40 points for each axis. We evaluate the loss on 128 samples from the training dataset of each task using all model parameters, including the classification layer. We disabled dropout for generating the surface plots. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            623
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Fig. 13 shows contour plots of the total gradient norm. We can again see that the point to which the failed model converges to $( \\theta _ { f } )$ is separated from the point the successful model converges to $( \\theta _ { s } )$ by a barrier. Moreover, on all the three datasets we can clearly see the valley around $\\theta _ { f }$ with a small gradient norm. ",
+        "bbox": [
+            174,
+            630,
+            825,
+            685
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "7.7 TRAINING CURVES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            704,
+            346,
+            719
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Fig. 14 shows training curves for 10 successful and 10 failed fine-tuning runs on RTE. We can clearly observe that all 10 failed runs have a common pattern: throughout the training, their training loss stays close to that at initialization. This implies an optimization problem and suggests to reconsider the optimization scheme. ",
+        "bbox": [
+            173,
+            731,
+            825,
+            786
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "7.8 ADDITIONAL FINE-TUNING RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            806,
+            465,
+            820
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We report additional fine-tuning results on the SciTail dataset (Khot et al., 2018) in Table 4 to demonstrate that our findings generalize to datasets from other domains. ",
+        "bbox": [
+            173,
+            832,
+            823,
+            861
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Due to its comparatively large size (28k training samples) fine-tuning on SciTail with the Devlin et al. (2019) scheme is already very stable even when trained for 3 epochs. This is comparable to what we find for QNLI in Section 4.1. When applying our fine-tuning scheme to SciTail, the results are very close to that of Devlin et al. (2019). On the other hand, when training on a smaller subset of SciTail (1k training samples) we can clearly see the same results as also observed in Fig. 3 for MRPC, CoLA, and QNLI, i.e. using more training iterations improves the fine-tuning stability. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/aa8a8b9659df6d688662b4bea2049adae33425a7f0f112cf24a5af9c2ebe29c9.jpg",
+        "image_caption": [
+            "Figure 10: Gradient norms (plotted on a logarithmic scale) of additional weight matrices of BERT fine-tuned on RTE. Corresponding layer names are in the captions. We show gradient norms corresponding to a single failed and single successful, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            215,
+            218,
+            782,
+            767
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/c22373173b2d3e4c52148f931644cc42972a88544fe122a835913b32b836d35e.jpg",
+        "image_caption": [
+            "Figure 11: Gradient norms (plotted on a logarithmic scale) of additional weight matrices of RoBERTa fine-tuned on RTE. Corresponding layer names are in the captions. We show gradient norms corresponding to a single failed and single successful, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            140,
+            751,
+            819
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/f80e109368e2f0c95feae8d7bd688ef690c92a1c69f2044b53235fdd49e4a206.jpg",
+        "image_caption": [
+            "Figure 12: Gradient norms (plotted on a logarithmic scale) of additional weight matrices of ALBERT fine-tuned on RTE. Corresponding layer names are in the captions. We show gradient norms corresponding to a single failed and single successful, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            140,
+            751,
+            821
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/9ab580f48b2fa5f55b9a68c1a50f9ee6baf599d3dcdf80a319ab2c6f3e99dd50.jpg",
+        "image_caption": [
+            "Figure 13: 2D gradient norm surfaces in the subspace spanned by $\\delta _ { 1 } = \\theta _ { f } - \\theta _ { p }$ and $\\delta _ { 2 } = \\theta _ { s } - \\theta _ { p }$ for BERT fine-tuned on RTE, MRPC and CoLA. $\\theta _ { p } , \\theta _ { f }$ , $\\theta _ { s }$ denote the parameters of the pre-trained, failed, and successfully trained model, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            106,
+            823,
+            246
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/90f258b1a316c75b6c3fd83719d5d45da6c0f0e8634399099a0b6c0069373136.jpg",
+        "image_caption": [
+            "Figure 14: The test accuracy and training loss of (a) 10 successful runs with our fine-tuning scheme and (b) 10 failed runs with fine-tuning scheme Devlin on RTE. Solid line shows the mean, error bars show $\\pm 1 \\mathrm { s t d }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            218,
+            320,
+            781,
+            496
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "table",
+        "img_path": "images/e666631860a1280ac5795253fc6d64c705542da5faa8e31d107fe066b7fd8042.jpg",
+        "table_caption": [
+            "Table 4: Standard deviation, mean, and maximum performance on the development set of SciTail when finetuning BERT over 25 random seeds. Standard deviation: lower is better, i.e. fine-tuning is more stable. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Approach</td><td colspan=\"3\">SciTail</td></tr><tr><td>std</td><td>mean</td><td>max</td></tr><tr><td>Devlin et al. (2019),full train set, 3 epochs</td><td>0.4</td><td>95.1</td><td>96.0</td></tr><tr><td>Devlin et al. (2019),1k samples,3 epochs</td><td>17.9</td><td>69.8</td><td>89.4</td></tr><tr><td>Devlin et al. (2019),1k samples,71 epochs</td><td>0.9</td><td>87.5</td><td>89.1</td></tr><tr><td>Ours, full train set</td><td>0.6</td><td>95.1</td><td>96.8</td></tr></table>",
+        "bbox": [
+            287,
+            585,
+            710,
+            690
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            715,
+            825,
+            744
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "We conclude from this experiment that our findings and guidelines generalize to datasets from other domains as well. This gives further evidence that the observed instability is not a property of any particular dataset but rather a result of too few training iterations based on the common fine-tuning practice of using a fixed number of epochs (and not iterations) independently of the training data size. ",
+        "bbox": [
+            173,
+            751,
+            826,
+            808
+        ],
+        "page_idx": 18
+    }
+]