Add files using upload-large-folder tool

parse/dev/8XWP2ewX-im/8XWP2ewX-im.md

@@ -0,0 +1,350 @@
+# Hidden Progress in Deep Learning: SGD Learns Parities Near the Computational Limit
+
+Boaz Barak Harvard University
+
+Benjamin L. Edelman Harvard University
+
+Surbhi Goel Microsoft Research & University of Pennsylvania
+
+Sham Kakade Harvard University
+
+Eran Malach Hebrew University of Jerusalem
+
+Cyril Zhang Microsoft Research
+
+b@boazbarak.org, sham@seas.harvard.edu,
+
+bedelman@g.harvard.edu, surbhig@cis.upenn.edu eran.malach@mail.huji.ac.il, cyrilzhang@microsoft.com
+
+# Abstract
+
+There is mounting evidence of emergent phenomena in the capabilities of deep learning methods as we scale up datasets, model sizes, and training times. While there are some accounts of how these resources modulate statistical capacity, far less is known about their effect on the computational problem of model training. This work conducts such an exploration through the lens of learning a $k$ -sparse parity of $n$ bits, a canonical discrete search problem which is statistically easy but computationally hard. Empirically, we find that a variety of neural networks successfully learn sparse parities, with discontinuous phase transitions in the training curves. On small instances, learning abruptly occurs at approximately $n ^ { O ( k ) }$ iterations; this nearly matches SQ lower bounds, despite the apparent lack of a sparse prior. Our theoretical analysis shows that these observations are not explained by a Langevin-like mechanism, whereby SGD “stumbles in the dark” until it finds the hidden set of features (a natural algorithm which also runs in $n ^ { O ( k ) }$ time). Instead, we show that SGD gradually amplifies the sparse solution via a Fourier gap in the population gradient, making continual progress that is invisible to loss and error metrics.
+
+# 1 Introduction
+
+In deep learning, performance improvements are frequently observed upon simply scaling up resources (such as data, model size, and training time). While these improvements are often continuous in terms of these resources, some of the most surprising recent advances in the field have been emergent capabilities: at a certain threshold, behavior changes qualitatively and discontinuously. Through a statistical lens, it is well-understood that larger models, trained with more data, can fit more complex and expressive functions. However, far less is known about the analogous computational question: how does the scaling of these resources influence the success of gradient-based optimization?
+
+These phase transitions cannot be explained via statistical capacity alone: they can appear even when the amount of data remains fixed, with only model size or training time increasing. A timely example is the emergence of reasoning and few-shot learning capabilities when scaling up language models (Radford et al., 2019; Brown et al., 2020; Chowdhery et al., 2022; Hoffmann et al., 2022); Srivastava et al. (2022) identify various tasks which language models are only able to solve if they are larger than a critical scale. Power et al. (2022) give examples of discontinuous improvements in population accuracy (“grokking”) when running time increases, while dataset and model sizes remain fixed.
+
+![](images/f5f27b7d50a94e0f6d0f12aa5d0ab42e3b151b48c843d58252ce826edbdb6d5f.jpg)  
+Figure 1: Main empirical findings at a glance. A variety of neural networks, with standard training and initialization, can solve the $( n , k )$ -parity learning problem, with a number of iterations scaling as $n ^ { O ( k ) }$ . Left: Training curves under various algorithmic choices (architecture, batch size, learning rate) on the $( n = 5 0 , k = 3$ )-parity problem. Right: Median convergence times for small $( n , k )$ .
+
+In this work, we analyze the computational aspects of scaling in deep learning, in an elementary synthetic setting which already exhibits discontinuous improvements. Specifically, we consider the supervised learning problem of learning a sparse parity: the label is the parity (XOR) of $k \ll n$ bits in a random length- $^ n$ binary string. This problem is computationally difficult for a range of algorithms, including gradient-based $\mathrm { ( } \bar { \mathrm { K e a r n s } } , \bar { \mathrm { 1 9 9 8 } } \mathrm { ) }$ and streaming $\mathtt { ( K o l e t a l . } \mathtt { \backslash } \mathtt { E 0 1 7 } )$ algorithms. We focus on analyzing the resource measure of training time, and demonstrate that the loss curves for sparse parities display a phase transition across a variety of architectures and hyperparameters (see Figure $\checkmark$ left). Strikingly, we observe that SGD finds the sparse subset (and hence, reaches 0 error) with a variety of activation functions and initialization schemes, even with no over-parameterization.
+
+A natural hypothesis to explain SGD’s success in learning parities, with no visible progress in error and loss for most of training, would be that it simply “stumbles in the dark”, performing random search for the unknown target (e.g. via stochastic gradient Langevin dynamics). If that were the case, we might expect to observe a convergence time of $2 ^ { \Omega ( n ) }$ , like a naive search over parameters or subsets of indices. However, Figure $1 ( r i { \bar { g } } h t )$ , already provides some evidence against this “random search” hypothesis: the convergence time adapts to the sparsity parameter $k$ , with a scaling of $n ^ { O ( k ) }$ on small instances. Notably, such a convergence rate implies that SGD is closer to achieving the optimal computation time among a natural class of algorithms (namely, statistical query algorithms).
+
+Through an extensive empirical analysis of the scaling behavior of a variety of models, as well as theoretical analysis, we give strong evidence against the “stumbling in the dark” viewpoint. Instead, there is a hidden progress measure under which SGD is steadily improving. Furthermore, and perhaps surprisingly, we show that SGD achieves a computational runtime much closer to the optimal SQ lower bound than simply doing (non-sparse) parameter search. More generally, our investigations reveal a number of notable phenomena regarding the dependence of SGD’s performance on resources: we identify phase transitions when varying data, model size, and training time.
+
+# 1.1 Our contributions
+
+SGD learns sparse parities. It is known from SQ lower bounds that with a constant noise level, gradient descent on any architecture requires at least $n ^ { \Omega ( k ) }$ computational steps to learn $k$ -sparse $n$ -dimensional parities (for background, see Appendix $\mathbf { A } )$ . We first show a wide variety of positive empirical results, in which neural networks successfully solve the parity problem in a number of iterations which scales near this computational limit:
+
+Empirical Finding 1. For all small instances $( n ~ \leq ~ 3 0 , k ~ \leq ~ 4 )$ of the sparse parity problem, architectures $\mathcal { A } \in \{ 2$ -layer MLPs, Transformers1, sinusoidal/oscillating neurons, PolyNets2}, initializations in uniform, Gaussian, Bernoulli , and batch sizes $1 \leq B \leq 1 0 2 4$ , SGD on $\mathcal { A }$ solves the $( n , k )$ -sparse parity problem $( w . p . \ge 0 . 2 )$ within at most $c \cdot n ^ { \alpha k }$ steps, for small constants $c , \alpha$ .
+
+Theoretical analyses of sparse feature emergence. Our empirical results suggest that, in a number of computational steps matching the SQ limit, SGD is able to solve the parity problem and identify the influential coordinates, without an explicit sparse prior. We give a theoretical analysis which validates this claim.
+
+Informal Theorem 2. On 2-layer MLPs of width $2 ^ { \Theta ( k ) }$ , and with batch size $n ^ { O ( k ) }$ , SGD converges with high probability to a solution with at most ✏ error on the $( n , k )$ -parity problem in at most $2 ^ { O ( k ) } \cdot \mathrm { p o l y } ( 1 / \epsilon )$ iterations.
+
+We also present a stronger analysis for an idealized architecture (which we call the disjoint-PolyNet), which allows for any batch size, and captures the phase transitions observed in the error curves.
+
+Informal Theorem 3. On disjoint-PolyNets, SGD (with any batch size $B \geq 1$ ) converges with high probability to a solution with at most ✏ error on the $( n , k )$ -parity problem in at most $n ^ { O ( k ) } \cdot \log ( 1 / \epsilon )$ iterations. Continuous-time gradient flow exhibits a phase transition: it spends a $1 - o ( 1 )$ fraction of its time before convergence with error $\geq 4 9 \%$ .
+
+Our theoretical and empirical results hold in non-overparameterized regimes (including with a width-1 sinusoidal neuron), in which no fixed kernel, including the neural tangent kernel (NTK) (Jacot et al., 2018), is sufficiently expressive to fit all sparse parities with a large margin. Thus, our findings comprise an elementary example of combinatorial feature learning: SGD can only successfully converge by learning a low-width sparse representation.
+
+Further empirical explorations. Building upon our core positive results, we provide a wide variety of preliminary experiments, showing sparse parity learning to be a versatile testbed for understanding the challenges and surprises in solving combinatorial problems with neural networks. These include quantities which reveal the continual hidden progress behind uninformative training curves (as predicted by the theory), experiments at small sample sizes which exhibit grokking (Power et al., $\boxed { 2 0 2 2 }$ , as well as an example where greedy layer-wise learning is impossible but end-to-end SGD can learn the layers jointly.
+
+# 1.2 Related work
+
+We present the most directly related work on feature learning, and learning parities with neural nets.   
+A broader discussion can be found in Appendix A.3.
+
+SGD and feature learning. Theoretical analysis of gradient descent on neural networks is notoriously hard, due to the non-convex nature of the optimization problem. That said, it has been established that in some settings, the dynamics of GD keep the weights close to their initialization, thus behaving like convex optimization over the Neural Tangent Kernel (see, for example, $\left( \mathrm { J a c o t \thinspace e t \ a l . } \right)$ 2018; Allen-Zhu et al., 2019; Du et al., 2018)). In contrast, it has been shown that in various tasks, moving away from the fixed features of the NTK is essential for the success of neural networks trained with GD (for example (Yehudai and Shamir, 2019; Allen-Zhu and Li, 2019; Wei et al., 2019) and the review in $( \mathbf { \underline { { M a l a c h \ e t \ a l . } } } ) \mathbf { \underline { { 2 0 2 1 } } } ) )$ . These results demonstrate that feature learning is an important part of the GD optimization process. Our work also focuses on a setting where feature learning is essential for the target task. In our theoretical analysis, we show that the initial population gradient encodes the relevant features for the problem. The importance of the first gradient step for feature learning has been recently studied in $\left( \overline { { \mathbf { B a } \operatorname { e t } \mathrm { { a l . } } } } \right) , \left. 2 0 2 2 \right)$
+
+Learning parities with neural networks. The problem of learning parities using neural networks has been investigated in prior works from various perspectives. It has been demonstrated that parities are hard for gradient-based algorithms, using similar arguments as in the SQ analysis (Shalev-Shwartz et al., 2017; Abbe and Sandon, 2020). One possible approach for overcoming the computational hardness is to make favorable assumptions on the input distribution. Indeed, recent works show that under various assumptions on the input distribution, neural networks can be efficiently trained to learn parities (XORs) (Daniely and Malach, 2020; Shi et al., 2021; Frei et al., 2022; Malach et al., $\boxed { 2 0 2 1 }$ . In contrast to these results, this work takes the approach of intentionally focusing on a hard benchmark task, without assuming that the distribution has some favorable (namely, non-uniform) structure. This setting allows us to probe the performance of deep learning at a known computational limit. Notably, the work of Andoni et al. (2014) provides analysis for learning polynomials (and in particular, parities) under the uniform distribution. However, their main results require a network of size $n ^ { O ( \hat { k } ) }$ (i.e., extremely overparameterized network), and provides only partial theoretical and empirical evidence for the success of smaller networks. Studying a related subject, some works have shown that neural networks display a spectral bias, learning to fit low-frequency coefficients before high-frequency ones (Rahaman et al., 2019; Cao et al., 2019).
+
+# 2 Preliminaries
+
+We provide an expanded discussion of background and related work in Appendix A.
+
+Sparse parities. For integer $n \geq 1$ and non-empty set $S \subseteq [ n ]$ , the $( n , S )$ -parity function $\chi _ { S } :$ $\{ \pm 1 \} ^ { n }  \{ \pm 1 \}$ is defined as $\begin{array} { r } { \chi _ { S } ( x ) = \prod _ { i \in S } x _ { i } } \end{array}$ . We define the $( n , S )$ -parity distribution $\mathcal { D } _ { S }$ as the joint distribution over $( x , y ) ^ { 3 }$ where $x$ is drawn from $\operatorname { U n i f } ( \{ \pm 1 \} ^ { n } )$ , the uniform distribution over random length- $\mathbf { \nabla } \cdot n$ sign vectors, and $y : = \chi _ { S } ( x )$ is the product of the inputs at the indices given by the “relevant features” $S$ (thus, $\pm 1$ , depending on whether the number of relevant $- 1$ inputs is even or odd). We define the $( n , k )$ -parity learning problem as the task of recovering the $S$ using samples from $\mathcal { D } _ { S }$ , where $S$ is chosen at random from $\binom { [ n ] } { k }$ .
+
+A key fact about parities is that they are orthogonal under the correlation inner product: for $S ^ { \prime } \subseteq [ n ]$
+
+$$
+\underset { x \sim \mathrm { U n i f } ( \{ \pm 1 \} ^ { n } ) } { \mathbb { E } } \left[ \chi _ { S } ( x ) \chi _ { S ^ { \prime } } ( x ) \right] = \underset { ( x , y ) \sim \mathcal { D } _ { S } } { \mathbb { E } } \left[ \chi _ { S ^ { \prime } } ( x ) y \right] = \left. \begin{array} { l l } { 1 } & { S ^ { \prime } = S } \\ { 0 } & { \mathrm { o t h e r w i s e } } \end{array} \right. .
+$$
+
+That is, a learner who guesses indices $S ^ { \prime }$ cannot use correlations (equivalently, the accuracy of the hypothesis $\chi _ { S ^ { \prime } }$ ) as feedback to reveal which indices in $S ^ { \prime }$ are correct, unless $S ^ { \prime }$ is exactly the correct subset. This notion of indistinguishability leads to a computational lower bound in the statistical query (SQ) model $\scriptstyle ( \left| \mathrm { K e a r n s } \right| , \left[ 1 9 9 8 \right) : \Omega ( n ^ { k } )$ constant-noise queries are necessary, which is far greater than the statistical limit of $\begin{array} { r } { \overline { { \Theta ( \log \left( \binom { n } { k } \right) ) } } \approx k \log n } \end{array}$ samples. The hardness of parity has been used to derive computational hardness results for other settings, like agnostically learning halfspaces (Klivans and Kothari, $\boxed { 2 0 1 4 }$ and MLPs $\pmb { \mathrm { \ [ G o e l ~ e t ~ a l . } , \pmb { \mathrm { [ 2 0 1 9 ) } } }$ . Beyond the restricted computational model of statistical queries, noiseless parities can be learned in poly $( n )$ time via Gaussian elimination. However, learning sparse noisy parities, even at a very small noise level (i.e., $o ( 1 )$ or $n ^ { - \delta }$ ), is believed to inherently require $n ^ { \Omega ( k ) }$ computational steps $\cdot ^ { 4 }$ In all, learning sparse parities is a well-studied combinatorial problem which exemplifies the computational difficulty of learning a joint dependence on multiple relevant features.
+
+Notation for neural networks and training. Our main results are presented in the online learning setting, with a stream of i.i.d. batches of examples. At each iteration $t = 1 , \dots , T$ , a learning algorithm $\mathcal { A }$ receives a batch of $B$ examples $\{ ( x _ { t , i } , y _ { t , i } ) \} _ { i = 1 } ^ { B }$ drawn i.i.d. from $\mathcal { D } _ { S }$ , then outputs a classifier $\widehat { y } _ { t } : \{ \pm 1 \} ^ { n }  \{ \pm 1 \}$ . We say that $\mathcal { A }$ solves the parity task in $t$ steps (with error $\epsilon$ ) if
+
+$$
+\operatorname* { P r } _ { ( x , y ) \sim \mathcal { D } _ { S } } [ \widehat { y } _ { t } ( x ) = y ] \geq 1 - \epsilon .
+$$
+
+We will focus on the case that $\widehat { y } _ { t } = \mathrm { s i g n } ( f ( x ; \theta _ { t } ) )$ for some parameters $\theta _ { t }$ in a continuous domain $\Theta$ and for a continuous function $f : \{ \pm 1 \} ^ { n } \times \Theta  \mathbb { R } \mathbb { P } \} ,$ updated with the ubiquitous online learning algorithm of gradient descent (GD), whose update rule is given by
+
+$$
+\theta _ { t + 1 } \gets ( 1 - \lambda _ { t } ) \theta _ { t } - \eta _ { t } \cdot \nabla _ { \theta } \left( \frac { 1 } { B } \sum _ { i = 1 } ^ { B } \ell ( y _ { t , i } , f ( x _ { t , i } ; \theta _ { t } ) ) \right) ,
+$$
+
+for a loss function $\ell : \{ \pm 1 \} \times \mathbb { R } \to \mathbb { R }$ , learning rate schedule $\{ \eta _ { t } \} _ { t = 1 } ^ { T }$ , and weight decay schedule $\{ \lambda _ { t } \} _ { t = 1 } ^ { T } { } ^ { 6 } .$ The initialization $\theta _ { 0 }$ is drawn randomly from a chosen distribution.
+
+![](images/dd61b61a588a20721322d0a3217d2b5b6e9a58644d35f8e1586921209e35ce16.jpg)  
+Figure 2: Black-box observations on the training dynamics. Left: Histograms of convergence times over $1 0 ^ { 6 }$ random trials, with heavy upper tails but no observed successes near $t = 0$ (unlike random search). Center: Loss curves (and thus, convergence time) depend heavily on initialization, not the randomness of SGD; $B = 1 2 8$ , $\eta = 0 . 0 1$ are shown here. Right: The power-law exponent ( $\alpha$ such that $t _ { c } \propto n ^ { \alpha }$ ) eventually worsens on larger problem instances.
+
+# 3 Empirical findings
+
+# 3.1 SGD on neural networks learns sparse parities
+
+The central phenomenon of study in this work is the empirical observation that neural networks, with standard initialization and training, can solve the $( n , k )$ -parity problem in a number of iterations scaling as $n ^ { O ( k ) }$ on small instances. We observed robust positive results for randomly-initialized SGD on the following architectures, indexed by Roman numerals:
+
+• 2-layer MLPs: ReLU $( \sigma ( z ) = ( z ) _ { + } )$ or polynomial $( \sigma ( z ) = z ^ { k } ) ,$ ) activation, in a wide variety of width regimes $r \geq k$ . Settings (i), (ii), (iii) (resp. (iv), (v), (vi)) use $r = \{ 1 0 , 1 0 0 , 1 0 0 0 \}$ ReLU (resp. polynomial) activations. We also consider $r = k$ (exceptional settings $( { } ^ { * } { \bf i } ) , ( { } ^ { * } { \bf i } ) \mathrm { ~ , ~ }$ ), the minimum width for representing a $k$ -wise parity for both activations. 1-neuron networks: Next, we consider non-standard activation functions $\sigma$ which allow a one-neuron architecture $f ( x ; w ) = \sigma ( w ^ { \top } x )$ to realize $k$ -wise parities. The constructions stem from letting $\begin{array} { r } { w ^ { \ast } = \sum _ { i \in S } \dot { e } _ { i } } \end{array}$ , and constructing $\sigma ( \cdot )$ to interpolate (the appropriate scaling of) $\frac { k - w ^ { * \top } x } { 2 }$ mod 2 with a piecewise linear $k$ -zigzag activation (vii), or a degree- $k$ polynomial (viii). Going a step further, a single $\infty$ -zigzag (ix) or sinusoidal $\mathbf { \tau } ( \mathbf { x } )$ neuron can represent all $k$ -wise parities. In settings (xi), (xii), (xiii), (xiv), we remove the second trainable layer (setting $u = 1$ ). We find that wider architectures with these activations also train successfully. Transformers: There is growing interest in using parity as a benchmark for combinatorial function learning, long-range dependency learning, and length generalization in Transformers (Lu et al., 2021; Edelman et al., 2021; Hahn, 2020; Anil et al., 2022; Liu et al., 2022). Motivated by these recent theoretical and empirical works, we consider a simplified specialization of the Transformer architecture to this sequence classification problem. This is the less-robust setting $( ^ { * } \mathrm { i i i } )$ ; the architecture and optimizer are described in Appendix D.1.3. • PolyNets: Our final setting (xv) is the PolyNet, a slightly modified version of the parity machine architecture. Parity machines have been studied extensively in the statistical mechanics of ML literature (see the related work section) as well as in a line of work on ‘neural cryptography’ $\left( [ \mathrm { R o s e n - Z v i e t a l . } ] , [ \mathrm { 2 0 0 2 } ] \right)$ . A parity machine outputs the sign of the product of $k$ linear functions of the input. A PolyNet simply outputs the product itself. Both architectures can clearly realize $k$ - sparse parities. The PolyNet architecture was originally motivated by the search for an idealized setting where an end-to-end optimization trajectory analysis is tractable (see Section $4 . 1 )$ we found in these experiments that this architecture trains very stably and sample-efficiently.
+
+Robust space of positive results. All of the networks listed above were observed to successfully learn sparse parities in a variety of settings. We summarize our findings as follows: for all combinations of $\bar { n } \in \{ 1 0 , 2 0 , 3 0 \}$ , $\bar { k } \in \{ 2 , 3 , 4 \}$ , batch sizes $B \in \{ 1 , 2 , 4 , \bar { \ldots } , 1 0 2 4 \}$ , initializations {uniform, Gaussian, Bernoulli}, loss functions $\{ { \mathrm { h i n g e } }$ , square, cross entropy}, and architecture configurations $\{ ( \mathrm { i } ) , ( \mathrm { i } \mathrm { i } ) , \dots , ( \mathrm { x } \mathrm { v } ) \}$ , SGD solved the parity problem (with $1 0 0 \%$ accuracy, validated on a batch of $2 ^ { 1 3 }$ samples) in at least $2 0 \%$ of 25 random trials, for at least one choice of learning rate $\eta \in \{ 0 . 0 0 1 , 0 . 0 1 , 0 . 1 , 1 \}$ . The models converged in $t _ { c } \le c \cdot n ^ { \alpha k } \le 1 0 ^ { 5 }$ steps, for small architecture-dependent constants $c , \alpha$ (see Appendix $\bar { \mathbf { C } ) }$ . Figure 1 (left) shows some representative training curves.
+
+Less robust configurations. Settings $( ^ { * } \mathrm { { i } ) }$ and $( ^ { * } \mathrm { { i i } ) }$ , where the MLP just barely represents a $k$ -sparse parity, and the Transformer setting $( ^ { * } \mathrm { i i i } )$ , are less robust to small batch sizes. In these settings, the same positive results as above only held for sufficiently large batch sizes: $B \geq 1 6$ . Also, setting $( \romannumeral 1 )$ used the Adam optimizer (which is standard for Transformers); see Appendix $_ { \mathrm { D } . 1 . 3 }$ for details.
+
+Phase transitions in training curves. For almost all of the architectures, we find that that the training curves exhibit phase transitions in terms of running time (and thus, in the online learning setting, dataset size as well): long durations of seemingly no progress, followed by periods of rapid decrease in the validation error. Strikingly, for architectures (v) and (vi), this plateau is absent: the error in the initial phase appears to decrease with a linear slope. See Appendix $\mathrm { i } _ { \mathrm { C } . 8 }$ for more plots.
+
+# 3.2 Random search or hidden progress?
+
+The remainder of this paper seeks to answer the question: “By what mechanism does deep learning solve these emblematic computationally-hard optimization problems?”
+
+A natural hypothesis would be that SGD somehow implicitly performs Monte Carlo random search, “bouncing around” the loss landscape in the absence of a useful gradient signal. Upon closer inspection, several empirical observations clash with this hypothesis:
+
+• Scaling of convergence times: Without an explicit sparsity prior in the architecture or initialization, it is unclear how to account for the runtimes observed in experiments, which adapt to the sparsity $k$ . The initializations, which certainly do not prefer sparse functions $\bigstar$ are close to the correct solutions with probability $2 ^ { - \Omega ( n ) } \ll \dot { n } ^ { - k }$ .   
+• No early convergence: Over a large number of random trials, no copies of this randomized algorithm get “lucky” (i.e. solve the problem in significantly fewer than the median number of iterations); see Figure $2 \ ( l e f t )$ . The success times of random exhaustive search would be distributed as $\mathrm { G e o m } ( 1 / { \overline { { ( } } } _ { k } ^ { n } ) )$ , whose probability mass is highest at $t = 0$ and decreases monotonically with $t$ .   
+• Sensitivity to initialization, not SGD samples: Running these training setups over multiple stochastic batches from a common initialization, we find that loss curves and convergence times are highly correlated with the architecture’s random initialization, and are quite concentrated conditioned on initialization; see Figure 2 (center).   
+• Elbows in the scaling curves: For larger $n$ , the power-law scaling ceases to hold: the exponent worsens (see Figure $\hat { 2 } \left( r i g h t \right)$ , as well as the discussion in Appendix ${ \bf C } . 2 )$ . This would not be true for random exhaustive search.
+
+Even these observations, which do not probe the internal state of the algorithm, suggest that exhaustive search is an insufficient picture of the training dynamics, and a different mechanism is at play.
+
+# 4 Theoretical analyses
+
+# 4.1 Provable emergence of the parity indices in high-precision gradients
+
+We now provide a theoretical account for the success of SGD in solving the $( n , k )$ -parity problem. Our main theoretical observation is that, in many cases, the population gradient of the weights at initialization contains enough “information” for solving the parity problem. That is, given an accurate enough estimate of the initial gradient (by e.g. computing the gradient over a large enough batch size), the relevant subset $S$ can be found.
+
+![](images/8e047a5239904342d313535d0804e98f802e0d064070cb0e03abb9a0c461744e.jpg)  
+Figure 3: Hidden progress when learning parities with neural networks. Left, center: Black-box losses and accuracies exhibit a long plateau and sharp phase transition (top), hiding gradual progress in the SGD iterates (bottom). Right: A hidden progress measure which distinguishes gradual feature amplification (top) from training on noise (bottom).
+
+As a warm-up example, consider training a single ReLU neuron $\widehat { y } ( x ; w ) = ( w ^ { \top } x ) _ { + }$ with the correlation loss $\ell ( y , \widehat { y } ) = - y \widehat { y }$ over $\mathcal { D } _ { S }$ , from an all-ones initialization $w = [ 1 \ \dots \ 1 ] \in \mathbb { R } ^ { n }$ . While a single neuron cannot express the parity, we observe that the correct subset can be extracted from the population gradient at initialization:
+
+$$
+\underset { x , y \rangle \sim \mathcal { D } _ { S } } { \mathbb { E } } \left[ \nabla _ { w _ { i } } \ell ( y , \widehat { y } ( x ; w ) ) \right] = \underset { ( x , y ) \sim \mathcal { D } _ { S } } { \mathbb { E } } \left[ - y \nabla _ { w _ { i } } ( w ^ { \top } x ) _ { + } \right] = \underset { ( x , y ) \sim \mathcal { D } _ { S } } { \mathbb { E } } \left[ - \chi _ { S } x _ { i } \mathbb { 1 } \left[ \sum _ { i } x _ { i } \geq 0 \right] \right] .
+$$
+
+The key insight is that each coordinate in the above expression is a correlation between a parity and the function $x \mapsto - \mathbb { 1 } [ \sum _ { i } x _ { i } \geq 0 ]$ , and thus a Fourier coefficient of this Boolean function. At each relevant coordinate $( i \in S$ ), the population gradient is the order- $( k - 1 )$ Fourier coefficient $S \setminus \{ i \}$ ; for the irrelevant features $( i \notin S )$ , it is instead the order- $( k + 1 )$ coefficient $S \cup \{ i \}$ . All we require is a detectable gap between these quantities. Formally, letting $f ( x ; w ) = \sigma ( w ^ { \top } x )$ , letting ${ \widehat { f } } ( S ) : = \mathbb { E } \left[ f ( x ) \chi _ { S } ( x ) \right]$ denote the Fourier coefficient of $f$ at $S$ , we isolate the desired property:
+
+Definition 1 (Fourier gap). For a function $f : \{ \pm 1 \} ^ { n } \to \mathbb { R }$ and $S \subseteq [ n ]$ of size $k$ , we say that $f$ has a $\gamma$ -Fourier gap at $S$ if, for every $\left( k - 1 \right)$ -element subset $S ^ { - } \subset S$ and $( k + 1 )$ -element superset $S ^ { + } \supset S$ , it holds that $| { \widehat { f } } ( S ^ { - } ) | \geq | { \widehat { f } } ( S ^ { + } ) | + \gamma .$ .
+
+For the all-ones initialization, observe $\begin{array} { r } { \mathbb { 1 } [ \sum _ { i } x _ { i } \ge 0 ] = \frac { 1 + \mathrm { s i g n } \left( \sum _ { i } x _ { i } \right) } { 2 } } \end{array}$ is just an affine transformation of the majority function of $x$ , for which a Fourier gap can be established, with $\gamma = \Theta ( n ^ { - ( k - 1 ) / 2 } )$ . This arises from closed-form formulas for the Fourier spectrum of majority (see Lemma $2$ i n Appendix $\mathbf { \underline { { B . l } } } \mathbf { \underline { { \Omega } } }$ , a landmark result from the harmonic analysis of Boolean functions (Titsworth, 1962; O’Donnell, 2014). Thus, the coordinates in $S$ can be recovered from $\widetilde { \cal O } ( 1 / \gamma ^ { 2 } ) = \widetilde { \cal O } \overline { { ( n ^ { k - 1 } ) } }$ samples; see Proposition 9 in Appendix ${ \bf B } . 2$ for a formal argument.
+
+Carefully extending this insight, we obtain an end-to-end convergence result for ReLU-activation MLP networks with a particular symmetric choice of $\pm 1$ initialization, trained with the hinge loss:
+
+Theorem 4 (SGD on MLPs learns sparse parities). Let $\epsilon \in ( 0 , 1 )$ . Let $k \geq 2$ an even integer, and let $n = \Omega ( k ^ { 4 } \log ( n k / \epsilon ) )$ be an odd integer. Then, there exist a random initialization scheme, $\eta _ { t }$ , and $\lambda _ { t }$ such that for every $S \subseteq [ n ]$ of size $k$ , SGD on a ReLU MLP of width $r = \Omega ( 2 ^ { k } k \log ( k / \epsilon ) )$ , with batch size $B = \Omega ( n ^ { k } \log ( n / \epsilon ) )$ on $\mathcal { D } _ { S }$ with the hinge loss, outputs a network $f ( x ; \theta _ { t } )$ with expected8 loss $\mathbb { E } \left[ \ell ( f ( x ; \theta _ { t } ) , y ) \right] \leq \epsilon$ in at most $O ( k ^ { 3 } r ^ { 2 } n / \epsilon ^ { 2 } )$ iterations.
+
+This does not capture the full range of settings in which we empirically observe successful convergence. First, it requires a sign vector initialization, while we observe convergence with other random initialization schemes (namely, uniform and Gaussian). Second, it requires the batch size to scale with $n ^ { \Omega ( k ) } \big \triangledown$ while we also obtain positive results when $B$ is small (even $B = 1$ ). Analogous statements for these cases (as well as other activations and losses) would require Fourier gaps for population gradient functions other than majority; lower bounds on the degree- $\left( k - 1 \right)$ coefficients (“Fourier anti-concentration”) are particularly elusive in the literature, and we leave it as an open challenge to establish them in more general settings. We provide preliminary empirics in Appendix $\mathrm { C . l } ,$ suggesting that the Fourier gaps in our empirical settings are sufficiently large. 10
+
+Low width necessitates feature learning. We note that in the low-width (non-overparameterized) regimes considered in this work, no fixed kernel (including the neural tangent kernel (Jacot et al., $\boxed { 2 0 1 8 }$ , whose dimensionality is the network’s parameter count) can solve the sparse parity problem. The following is a consequence of results in (Kamath et al., 2020; Malach and Shalev-Shwartz, 2022): Theorem 5 (Low-width NTK cannot fit all parities). Let $\Psi : \{ \pm 1 \} ^ { n } \to \mathbb { R } ^ { D }$ be any $D$ -dimensional embedding with $\mathrm { s u p } _ { x } \| \Psi ( x ) \| _ { 2 } \leq 1$ . Let $R , \epsilon > 0$ , and let $\ell$ denote the 0-1 loss or hinge loss. If $D R ^ { 2 } < \epsilon ^ { 2 } \cdot \binom { n } { k }$ , then there exists some $S \subseteq [ n ]$ of size $k$ such that
+
+$$
+\operatorname* { i n f } _ { \| w \| \leq R } \operatorname* { \mathbb { E } } _ { ( x , y ) \sim \mathcal { D } _ { S } } \left[ \ell ( \Psi ( x ) ^ { \top } w , y ) \right] > 1 - \epsilon .
+$$
+
+Thus, our low-width results lie outside the NTK regime, which requires far larger models (size $n ^ { \Omega ( k ) }$ ) to express parities. However, we note that better sample complexity bounds are possible in the NTK regime, with an algorithm more similar to standard SGD (see (Telgarsky, $\boxed { 2 0 2 2 }$ and Appendix $\mathbf { A } . 3 )$ .
+
+# 4.2 Disjoint-PolyNet: exact trajectory analysis for an idealized architecture
+
+In this section, we present an architecture (a version of PolyNets (xv)) which empirically exhibits similar behavior to MLPs and bypasses the difficulty of analyzing Fourier gaps. The disjointPolyNet takes a product over $k$ linear functions of an equal-sized11 partition $P _ { 1 } , \ldots , P _ { k }$ of the input coordinates: $\begin{array} { r } { f ( x ; w _ { 1 : k } ) : = \prod _ { i = 1 } ^ { k } \langle w _ { i } , x _ { P _ { i } } \rangle } \end{array}$ . As noted in the Section $\boxed { 1 . 2 }$ this is equivalent to a tree parity machine, with real-valued (instead of $\pm 1$ ) outputs.
+
+This architecture also requires us to assume that the set $S$ of size $k$ in the $( n , k )$ -parity problem is selected such that exactly one index belongs to each disjoint partition, that is, for all $i \in [ k ]$ , $S \cap P _ { i } = 1$ . We refer to this problem as the $( n , k )$ -disjoint parity problem. Note that there are still $( n ^ { \prime } ) ^ { k } = ( n / k ) ^ { k }$ different possibilities for set $S$ under this restriction. For fixed $k$ , these represent a constant fraction of the ${ \binom { n } { k } } \approx ( n e / k ) ^ { k }$ (by Stirling’s approximation) possibilities for $S$ in the general non-disjoint case.
+
+Consider training a disjoint-PolyNet w.r.t. the correlation loss. Without loss of generality, assume that each relevant coordinate in $S$ is the first element $P _ { i }$ . Then, the population gradient is non-zero only at indices $i \in S$ :
+
+$$
+g _ { i } ( w _ { 1 : k } ) = \mathbb { E } \left[ \nabla _ { w _ { i } } \ell ( f ( x ; w _ { 1 : k } ) , y ) \right] = - \mathbb { E } \left[ y \left( \prod _ { j \neq i } \langle w _ { j } , x _ { P _ { j } } \rangle \right) x _ { P _ { i } } \right] = - \left( \prod _ { j \neq i } w _ { j , 1 } \right) e _ { 1 } .
+$$
+
+This allows us to analyze the gradient flow dynamics of the disjoint-PolyNet, without needing to establish Fourier gaps. For each $i \in [ k ]$ , in this section we treat $w _ { i }$ as a function from $\mathbb { R } _ { \geq 0 } \to \mathbb { R } ^ { n ^ { \prime } }$ which satisfies the following differential equation: $\dot { w } _ { i } = - g _ { i } ( w _ { 1 : k } ( t ) )$ . For clarity of exposition, assume all-ones initialization $\bigstar$ Then, all of the relevant weights $\{ w _ { i , 1 } : i \in [ k ] \}$ follow the same trajectory. By analyzing the resulting differential equations, we can formally exhibit “phase transition”-like behavior in the fully deterministic gradient flow setting.
+
+Theorem 6 (Loss plateau for gradient flow on disjoint-PolyNets). Suppose $k \geq 3$ . Let $T ( \epsilon )$ denote the smallest time at which the error is at most ✏. Then,
+
+$$
+{ \frac { T ( 0 . 4 9 ) } { T ( 0 ) } } \geq 1 - O \left( ( n ^ { \prime } ) ^ { 1 - k / 2 } \right) .
+$$
+
+![](images/605608856e9419b3a654be1d6be05e1461079cfe14cf29e8c5dea54f56b4dcf9.jpg)  
+Figure 4: Parity as a sandbox for understanding the effects of model size and dataset size. Left: Success times vs. network width $r$ on a fixed $( 4 0 , 3 )$ -parity task: in accordance with the theory, parallelization experiences diminishing returns (unlike expected success times for random search, shown in green). Underparameterized models $( r = 1 , 2$ ) were considered successful upon reaching $5 5 \%$ accuracy. Right: Training curves where only the sample size $m$ is varied. The two center panels display “grokking”: a large gap between the time to zero train error vs. zero test error.
+
+Informally, the network takes much longer to reach slightly-better-than-trivial accuracy than it takes to go from slightly better than trivial to perfect accuracy. Returning to discrete time, we also analyze the trajectory of disjoint-PolyNets trained with online SGD at any batch size, confirming that a neural network can learn $k$ -sparse disjoint parities within $n ^ { O ( k ) }$ iterations.
+
+Theorem 7 (SGD on disjoint-PolyNets learns disjoint parities). Suppose we train a disjoint-PolyNet, initialized as above, with online SGD. Then there exists an adaptive learning rate schedule such that for any $\epsilon > 0$ , with probability 0.99, the error falls below ✏ within $\tilde { O } \left( ( n ^ { \prime } ) ^ { ( \bar { 2 } k - 1 ) } \log ( 1 / \epsilon ) \right)$ steps.
+
+Extended versions of these theorems, along with proofs, can be found in Appendix B.3.
+
+# 5 Hidden progress: discussion and additional experiments
+
+So far, we have shown that sparse parity learning provides an idealized setting in which neural networks successfully learn sparse combinatorial features, with a mechanism of continual progress hiding behind discontinuous training curves. In this section, we outline preliminary explorations on a broader range of interesting phenomena which arise in this setting. Details are provided in Appendix $\boxed { \mathbf { C } }$ while more systematic investigations are deferred to future work.
+
+Hidden progress measures for learning parities. The theoretical and (black-box) empirical results suggest that SGD does not learn parities via the memoryless process of random exhaustive search. This suggests the existence of progress measures: scalar quantities which are functions of the training algorithm’s state (i.e. the model weights $w _ { t }$ ) and are predictive of the time to successful convergence. We provide some white-box investigations which further support the hypothesis of hidden progress, by examining the gradual improvement in quantities other than the training loss. In Appendix $\checkmark$ we directly plot the Fourier gaps of the population gradient, as a function of $t$ , finding that they are large (within a small constant factor of those of majority) in practice. In Figure $\textcircled { 3 }$ and Appendix $\underline { { \overline { { \mathbf { C . 3 } } } } } \}$ we examine the weight movement norm $\rho ( w _ { 0 : t } ) : = \| w _ { t } - w _ { 0 } \| _ { \infty }$ to reveal hidden progress, motivated by the fact that $w _ { t } - w _ { 0 }$ is a linearized estimate for the initial population gradient.
+
+Roles of overparameterization vs. oversampling. An interesting consequence of our analysis is that it illuminates scaling behaviors with respect to a third fundamental resource parameter: model size, which we study in terms of network width $r$ . If SGD operated by a “random search” mechanism, one would expect width to provide a parallel speedup. Instead, we find that SGD sequentially amplifies progress. The sharp lower tails in Figure $2 ( \bar { l e } \hat { f } t )$ imply that running $r$ identical copies of SGD does not give $( 1 / r ) \times$ speedups; more directly, in Appendix $\boxed { C . 4 }$ (previewed in Figure $\boxed { 4 } ( l e f t )$ , we find that convergence times for sparse parities empirically plateau at large model sizes.
+
+Emergence of grokking in the finite-sample (multi-pass) setting. Our main results are presented in the online learning setting (fresh minibatches from $\mathcal { D } _ { S }$ at each iteration). While this mitigates the confounding factor of overfitting, it couples the resources of training time and independent samples in a suboptimal way, due to the computational-statistical gap for parity learning. In Appendix C.5, we find empirically that minibatch SGD (with weight decay) can learn sparse parities, even with smaller sample sizes $m \ll n ^ { k }$ . We reliably observe the grokking phenomenon $\pm { \sqrt { \mathrm { P o w e r ~ e t ~ a l . } } } \left[ { \overline { { 2 0 2 2 } } } \right)$ : an initial overfitting phase, then a delayed phase transition in the generalization error; see the two center panels of Figure $\mathbb { E } ( r i g h t )$ . These results complement and corroborate the findings of Nanda and Lieberum $\underline { { \left( \overline { { 2 0 2 2 } } \right) } }$ , who analyze the hidden progress of Transformers trained on arithmetic tasks (a setting which also exhibits grokking).
+
+Deeper networks. It is a significant challenge (and generally outside the scope of this work) to understand the interactions between network depth and computational/statistical efficiency. In Appendix $\mathbf { C . 7 } ,$ we show that learning parities with deeper polynomial-activation MLPs comprises a simple counterexample to the “deep only works if shallow is good” principle of Malach and Shalev-Shwartz (2019): a deep network can get near-perfect accuracy, even when greedy layer-wise training (e.g. (Belilovsky et al., $\boxed { 2 0 1 9 } ,$ ) cannot beat trivial performance. By providing positive theory and empirics which elude these simplified explanations of SGD, we hope to point the way to a more complete understanding of learning dynamics in the challenging cases where no apparent progress is made for extended periods of time.
+
+# 6 Conclusion
+
+This work puts forward sparse parity learning as an elementary test case to explore the puzzling features of the role of computational (as opposed to statistical) resources in deep learning. In particular, we have shown that a variety of neural architectures solve this combinatorial search problem, with a number of computational steps nearly matching the sparsity-dependent SQ lower bound. Furthermore, we have shown that despite abrupt phase transitions in the loss and accuracy curves, SGD works by gradually amplifying the sparse features “under the hood”.
+
+Even in this simple setting, there are several open experimental and theoretical questions. This work largely focuses on the online learning case, which couples training iterations with fresh i.i.d. samples. We believe it would be instructive to investigate parity learning when the three resources of samples, time, and model size are scaled separately. Some very preliminary findings along these lines are presented in Section $\textcircled { 3 }$ It is an open problem to extend our theoretical results to the small-batch setting, as well as to the full range of architectures and losses in our experiments. Resolving these questions would require a better understanding of the anti-concentration behavior of Boolean Fourier coefficients, which is much less studied than the analogous concentration phenomena.
+
+Another important follow-up direction is understanding the extent to which these insights extend from parity learning to more complex (including real-world) combinatorial problem settings, as well as the extent to which non-synthetic tasks (in, e.g., natural language processing and program synthesis) embed within them parity-like subtasks of exhaustive combinatorial search. We hope that our results will lead to further progress towards understanding and improving the optimization dynamics behind the recent slew of dramatic empirical successes of deep learning in these types of domains.
+
+Broader impact. This work seeks to contribute to the foundational understanding of computational scaling behaviors in deep learning. Our theoretical and empirical analyses are in a heavily-idealized synthetic problem setting. Hence, we see no direct societal impacts of the results in this study.
+
+Acknowledgements. We would like to thank Lenka Zdeborová for providing us with references to the statistical physics literature on phase transitions in the learning curves of neural networks, and Matus Telgarsky for bringing to our attention the better sample complexity guarantees of 2-sparse parity learning in the NTK regime. Sham Kakade acknowledges funding from the Office of Naval Research under award N00014-22-1-2377.
+
+References   
+Emmanuel Abbe and Colin Sandon. Poly-time universality and limitations of deep learning. arXiv preprint arXiv:2001.02992, 2020.   
+Emmanuel Abbe, Pritish Kamath, Eran Malach, Colin Sandon, and Nathan Srebro. On the power of differentiable learning versus PAC and SQ learning. Advances in Neural Information Processing Systems, 34, 2021.   
+Emmanuel Abbe, Elisabetta Cornacchia, Jan H ˛azła, and Christopher Marquis. An initial alignment between neural network and target is needed for gradient descent to learn. arXiv preprint arXiv:2202.12846, 2022.   
+Naman Agarwal, Rohan Anil, Elad Hazan, Tomer Koren, and Cyril Zhang. Disentangling adaptive gradient methods from learning rates. arXiv preprint arXiv:2002.11803, 2020.   
+Michael Alekhnovich. More on average case vs approximation complexity. In 44th Annual IEEE Symposium on Foundations of Computer Science, 2003. Proceedings., pages 298–307. IEEE, 2003.   
+Zeyuan Allen-Zhu and Yuanzhi Li. What can ResNet learn efficiently, going beyond kernels? Advances in Neural Information Processing Systems, 32, 2019.   
+Zeyuan Allen-Zhu, Yuanzhi Li, and Zhao Song. A convergence theory for deep learning via overparameterization. In International Conference on Machine Learning, pages 242–252. PMLR, 2019.   
+Alexandr Andoni, Rina Panigrahy, Gregory Valiant, and Li Zhang. Learning polynomials with neural networks. In International Conference on Machine Learning, pages 1908–1916. PMLR, 2014.   
+Cem Anil, Yuhuai Wu, Anders Andreassen, Aitor Lewkowycz, Vedant Misra, Vinay Ramasesh, Ambrose Slone, Guy Gur-Ari, Ethan Dyer, and Behnam Neyshabur. Exploring length generalization in large language models. arXiv preprint arXiv:2207.04901, 2022.   
+Benny Applebaum, David Cash, Chris Peikert, and Amit Sahai. Fast cryptographic primitives and circular-secure encryption based on hard learning problems. In Annual International Cryptology Conference, pages 595–618. Springer, 2009.   
+Benny Applebaum, Boaz Barak, and Avi Wigderson. Public-key cryptography from different assumptions. In Proceedings of the forty-second ACM symposium on Theory of computing, pages 171–180, 2010.   
+Gerard Ben Arous, Reza Gheissari, and Aukosh Jagannath. Online stochastic gradient descent on non-convex losses from high-dimensional inference. J. Mach. Learn. Res., 22:106–1, 2021.   
+Jimmy Ba, Murat A Erdogdu, Taiji Suzuki, Zhichao Wang, Denny Wu, and Greg Yang. Highdimensional asymptotics of feature learning: How one gradient step improves the representation. arXiv preprint arXiv:2205.01445, 2022.   
+Eugene Belilovsky, Michael Eickenberg, and Edouard Oyallon. Greedy layerwise learning can scale to imagenet. In International conference on machine learning, pages 583–593. PMLR, 2019.   
+Andrew C Berry. The accuracy of the gaussian approximation to the sum of independent variates. Transactions of the American Mathematical Society, 49(1):122–136, 1941.   
+Andrej Bogdanov, Manuel Sabin, and Prashant Nalini Vasudevan. Xor codes and sparse learning parity with noise. Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 986–1004, 2019.   
+Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.   
+Yuan Cao, Zhiying Fang, Yue Wu, Ding-Xuan Zhou, and Quanquan Gu. Towards understanding the spectral bias of deep learning. arXiv preprint arXiv:1912.01198, 2019.   
+Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al. Palm: Scaling language modeling with pathways. arXiv preprint arXiv:2204.02311, 2022.   
+Alexandru Damian, Jason Lee, and Mahdi Soltanolkotabi. Neural networks can learn representations with gradient descent. In Conference on Learning Theory, pages 5413–5452. PMLR, 2022.
+
+Amit Daniely and Eran Malach. Learning parities with neural networks. Advances in Neural Information Processing Systems, 33:20356–20365, 2020.
+
+Ilias Diakonikolas, Surbhi Goel, Sushrut Karmalkar, Adam R Klivans, and Mahdi Soltanolkotabi. Approximation schemes for relu regression. In Conference on Learning Theory, pages 1452–1485. PMLR, 2020.   
+Simon S Du, Xiyu Zhai, Barnabas Poczos, and Aarti Singh. Gradient descent provably optimizes over-parameterized neural networks. arXiv preprint arXiv:1810.02054, 2018.   
+Benjamin L Edelman, Surbhi Goel, Sham Kakade, and Cyril Zhang. Inductive biases and variable creation in self-attention mechanisms. arXiv preprint arXiv:2110.10090, 2021.   
+Andreas Engel and Christian Van den Broeck. Statistical mechanics of learning. Cambridge University Press, 2001.   
+Carl-Gustav Esseen. On the Liapunov limit error in the theory of probability. Ark. Mat. Astr. Fys., 28: 1–19, 1942.   
+Spencer Frei, Yuan Cao, and Quanquan Gu. Agnostic learning of a single neuron with gradient descent. Advances in Neural Information Processing Systems, 33:5417–5428, 2020.   
+Spencer Frei, Niladri S Chatterji, and Peter L Bartlett. Random feature amplification: Feature learning and generalization in neural networks. arXiv preprint arXiv:2202.07626, 2022.   
+Elizabeth Gardner and Bernard Derrida. Three unfinished works on the optimal storage capacity of networks. Journal of Physics A: Mathematical and General, 22(12):1983, 1989.   
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pages 249–256. JMLR Workshop and Conference Proceedings, 2010.   
+Surbhi Goel, Sushrut Karmalkar, and Adam Klivans. Time/accuracy tradeoffs for learning a ReLU with respect to Gaussian marginals. Advances in Neural Information Processing Systems, 32, 2019.   
+Oded Goldreich and Leonid A Levin. A hard-core predicate for all one-way functions. In Proceedings of the twenty-first annual ACM symposium on Theory of computing, pages 25–32, 1989.   
+Sebastian Goldt, Madhu Advani, Andrew M Saxe, Florent Krzakala, and Lenka Zdeborová. Dynamics of stochastic gradient descent for two-layer neural networks in the teacher-student setup. Advances in neural information processing systems, 32, 2019.   
+Michael Hahn. Theoretical limitations of self-attention in neural sequence models. Transactions of the Association for Computational Linguistics, 8:156–171, 2020.   
+D Hansel, G Mato, and C Meunier. Memorization without generalization in a multilayered neural network. EPL (Europhysics Letters), 20(5):471, 1992.   
+Godfrey Harold Hardy, John Edensor Littlewood, George Pólya, György Pólya, et al. Inequalities. Cambridge University Press, 1952.   
+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, pages 1026–1034, 2015.   
+Jordan Hoffmann, Sebastian Borgeaud, Arthur Mensch, Elena Buchatskaya, Trevor Cai, Eliza Rutherford, Diego de Las Casas, Lisa Anne Hendricks, Johannes Welbl, Aidan Clark, et al. Training compute-optimal large language models. arXiv preprint arXiv:2203.15556, 2022.   
+Yuval Ishai, Eyal Kushilevitz, Rafail Ostrovsky, and Amit Sahai. Cryptography with constant computational overhead. In Proceedings of the 40th Annual ACM Symposium on the Theory of Computing, pages 433–442, 2008.   
+Arthur Jacot, Franck Gabriel, and Clément Hongler. Neural tangent kernel: Convergence and generalization in neural networks. Advances in neural information processing systems, 31, 2018.   
+Ziwei Ji and Matus Telgarsky. Polylogarithmic width suffices for gradient descent to achieve arbitrarily small test error with shallow relu networks. arXiv preprint arXiv:1909.12292, 2019.   
+Y Kabashima. Perfect loss of generalization due to noise in ${ \bf k } = 2$ parity machines. Journal of Physics A: Mathematical and General, 27(6):1917, 1994.
+
+Pritish Kamath, Omar Montasser, and Nathan Srebro. Approximate is good enough: Probabilistic variants of dimensional and margin complexity. In Conference on Learning Theory, pages 2236– 2262. PMLR, 2020.
+
+Michael Kearns. Efficient noise-tolerant learning from statistical queries. Journal of the ACM (JACM), 45(6):983–1006, 1998.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Adam Klivans and Pravesh Kothari. Embedding hard learning problems into gaussian space. In Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques (APPROX/RANDOM 2014). Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik, 2014.
+
+Adam R Klivans, Ryan O’Donnell, and Rocco A Servedio. Learning intersections and thresholds of halfspaces. Journal of Computer and System Sciences, 68(4):808–840, 2004.
+
+Gillat Kol, Ran Raz, and Avishay Tal. Time-space hardness of learning sparse parities. In Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, pages 1067–1080, 2017.
+
+Eyal Kushilevitz and Yishay Mansour. Learning decision trees using the fourier spectrum. SIAM Journal on Computing, 22(6):1331–1348, 1993.
+
+Beatrice Laurent and Pascal Massart. Adaptive estimation of a quadratic functional by model selection. Annals of Statistics, pages 1302–1338, 2000.
+
+Bingbin Liu, Jordan T Ash, Surbhi Goel, Akshay Krishnamurthy, and Cyril Zhang. Transformers learn shortcuts to automata. arXiv preprint arXiv:2210.10749, 2022.
+
+Kevin Lu, Aditya Grover, Pieter Abbeel, and Igor Mordatch. Pretrained transformers as universal computation engines. arXiv preprint arXiv:2103.05247, 2021.
+
+Eran Malach and Shai Shalev-Shwartz. Is deeper better only when shallow is good? Advances in Neural Information Processing Systems, 32, 2019.
+
+Eran Malach and Shai Shalev-Shwartz. When hardness of approximation meets hardness of learning. Journal of Machine Learning Research, 23(91):1–24, 2022.
+
+Eran Malach, Pritish Kamath, Emmanuel Abbe, and Nathan Srebro. Quantifying the benefit of using differentiable learning over tangent kernels. In International Conference on Machine Learning, pages 7379–7389. PMLR, 2021.
+
+GJ Mitchison and RM Durbin. Bounds on the learning capacity of some multi-layer networks. Biological Cybernetics, 60(5):345–365, 1989.
+
+Neel Nanda and Tom Lieberum. A mechanistic interpretability analysis of grokking. Alignment Forum, 2022. URL https://www.alignmentforum.org/posts/N6WM6hs7RQMKDhYjB/ a-mechanistic-interpretability-analysis-of-grokking.
+
+Ryan O’Donnell. Analysis of Boolean functions. Cambridge University Press, 2014.
+
+Manfred Opper. Learning and generalization in a two-layer neural network: The role of the vapnikchervonvenkis dimension. Physical review letters, 72(13):2113, 1994.
+
+Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. PyTorch: An imperative style, high-performance deep learning library. 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 8024–8035. Curran Associates, Inc., 2019. URL http://papers.neurips.cc/paper/ 9015-pytorch-an-imperative-style-high-performance-deep-learning-library. pdf.
+
+Alethea Power, Yuri Burda, Harri Edwards, Igor Babuschkin, and Vedant Misra. Grokking: Generalization beyond overfitting on small algorithmic datasets. arXiv preprint arXiv:2201.02177, 2022.
+
+Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, Ilya Sutskever, et al. Language models are unsupervised multitask learners. OpenAI blog, 1(8):9, 2019.
+
+Nasim Rahaman, Aristide Baratin, Devansh Arpit, Felix Draxler, Min Lin, Fred Hamprecht, Yoshua Bengio, and Aaron Courville. On the spectral bias of neural networks. In International Conference on Machine Learning, pages 5301–5310. PMLR, 2019.   
+Maria Refinetti, Sebastian Goldt, Florent Krzakala, and Lenka Zdeborová. Classifying highdimensional gaussian mixtures: Where kernel methods fail and neural networks succeed. In International Conference on Machine Learning, pages 8936–8947. PMLR, 2021.   
+Michal Rosen-Zvi, Einat Klein, Ido Kanter, and Wolfgang Kinzel. Mutual learning in a tree parity machine and its application to cryptography. Physical Review E, 66(6):066135, 2002.   
+David Saad and Sara Solla. Dynamics of on-line gradient descent learning for multilayer neural networks. Advances in neural information processing systems, 8, 1995a.   
+David Saad and Sara A Solla. On-line learning in soft committee machines. Physical Review E, 52 (4):4225, 1995b.   
+Shai Shalev-Shwartz and Shai Ben-David. Understanding machine learning: From theory to algorithms. Cambridge university press, 2014.   
+Shai Shalev-Shwartz, Ohad Shamir, and Shaked Shammah. Failures of gradient-based deep learning. In International Conference on Machine Learning, pages 3067–3075. PMLR, 2017.   
+Zhenmei Shi, Junyi Wei, and Yingyu Liang. A theoretical analysis on feature learning in neural networks: Emergence from inputs and advantage over fixed features. In International Conference on Learning Representations, 2021.   
+Roberta Simonetti and Nestor Caticha. On-line learning in parity machines. Journal of Physics A: Mathematical and General, 29(16):4859, 1996.   
+Aarohi Srivastava, Abhinav Rastogi, Abhishek Rao, Abu Awal Md Shoeb, Abubakar Abid, Adam Fisch, Adam R Brown, Adam Santoro, Aditya Gupta, Adrià Garriga-Alonso, et al. Beyond the imitation game: Quantifying and extrapolating the capabilities of language models. arXiv preprint arXiv:2206.04615, 2022.   
+Matus Telgarsky. Feature selection with gradient descent on two-layer networks in low-rotation regimes. arXiv preprint arXiv:2208.02789, 2022.   
+Robert C Titsworth. Correlation properties of cyclic sequences. PhD thesis, California Institute of Technology, 1962.   
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. Advances in neural information processing systems, 30, 2017.   
+Martin J Wainwright. High-dimensional statistics: A non-asymptotic viewpoint, volume 48. Cambridge University Press, 2019.   
+Timothy LH Watkin, Albrecht Rau, and Michael Biehl. The statistical mechanics of learning a rule. Reviews of Modern Physics, 65(2):499, 1993.   
+Colin Wei, Jason D Lee, Qiang Liu, and Tengyu Ma. Regularization matters: generalization and optimization of neural nets vs their induced kernel. Advances in Neural Information Processing Systems, 32, 2019.   
+Gilad Yehudai and Shamir Ohad. Learning a single neuron with gradient methods. In Conference on Learning Theory, pages 3756–3786. PMLR, 2020.   
+Gilad Yehudai and Ohad Shamir. On the power and limitations of random features for understanding neural networks. Advances in Neural Information Processing Systems, 32, 2019.   
+Jingzhao Zhang, Sai Praneeth Karimireddy, Andreas Veit, Seungyeon Kim, Sashank Reddi, Sanjiv Kumar, and Suvrit Sra. Why are adaptive methods good for attention models? Advances in Neural Information Processing Systems, 33:15383–15393, 2020.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]
+
+(b) Did you describe the limitations of your work? [Yes]   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [N/A]   
+(b) Did you mention the license of the assets? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/dev/e0uknAgETh/e0uknAgETh.md

@@ -0,0 +1,232 @@
+# ADVERSARIAL ATTACKS ON SPIKING CONVOLUTIONAL NETWORKS FOR EVENT-BASED VISION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Event-based sensing using dynamic vision sensors is gaining traction in lowpower vision applications. Spiking neural networks work well with the sparse nature of event-based data and suit deployment on low-power neuromorphic hardware. Being a nascent field, the sensitivity of spiking neural networks to potentially malicious adversarial attacks has received very little attention so far. In this work, we show how white-box adversarial attack algorithms can be adapted to the discrete and sparse nature of event-based visual data, and to the continuous-time setting of spiking neural networks. We test our methods on the N-MNIST and IBM Gestures neuromorphic vision datasets and show adversarial perturbations achieve a high success rate, by injecting a relatively small number of appropriately placed events. We also verify, for the first time, the effectiveness of these perturbations directly on neuromorphic hardware. Finally, we discuss the properties of the resulting perturbations and possible future directions.
+
+# 1 INTRODUCTION
+
+Unlike the usual neural networks of contemporary deep learning, spiking neural networks (SNN) resemble the animal brain more closely in at least two main aspects: the way their neurons communicate through impulses (spikes), and their dynamics, which evolve in continuous time. Aside from offering the field of computational neuroscience more biologically plausible neuron models and communication schemes, research in the technological applications of spiking neural networks is currently blooming because of the rise of neuromorphic technology. Neuromorphic hardware is directly compatible with spiking neural networks and enables the design of low-power models for use in battery-operated, always-on devices.
+
+Adversarial examples are an “intriguing property of neural networks” (Szegedy et al., 2013) by which the network is easily fooled into misclassifying an input which has been altered in an almost imperceptible way by the attacker. This property is usually undesirable in applications: it was proven, for example, that an adversarial attack may pose a threat to self-driving cars, by making them misclassify a stop sign as a speed limit sign; and that this attack can be implemented in the real world through stickers physically placed on the road sign (Eykholt et al., 2018). Because of their relevance to real-world applications, a large amount of work has been published on this subject, typically following a pattern where new attacks are discovered, followed by new defense strategies, in turn followed by proof of other strategies that can still break through them (see Akhtar & Mian (2018) for a review).
+
+With the advent of real-world applications of spiking networks in neuromorphic devices, it is essential to make sure they work securely and reliably in a variety of contexts. In particular, there is a significant need for research on the possibility of adversarial attacks on spiking network models used for computer sensing tasks. In this paper, we make an attempt at modifying event-based data, by adding and removing events, to generate adversarial examples that fool spiking networks into misclassifying them. This offers important insight into the reliability and security of neuromorphic vision devices, with important implications for commercial applications.
+
+# 1.1 WHAT IS EVENT-BASED SENSING?
+
+Event-based cameras, usually called Dynamic Vision Sensors (DVS), share many characteristics with the mammalian retina, which make them excel in some circumstances where traditional framebased cameras do not perform well (Liu & Delbruck, 2010; Liu et al., 2019b). First, events are generated only when there are changes in the visual scene, automatically removing redundancies; second, their pixels fire independently of each other which means that there is no frame rate, but rather a continuous stream of asynchronous events, so that the latency can be extremely small; third, they have a very high dynamic range which makes them suitable to detect motion in both bright and dark settings. For these reasons, they have found applications in human-robot interaction, odometry, drone control, tracking, and surveillance, including on devices that are already commercially available (Gallego et al., 2019; Kueng et al., 2016; Falanga et al., 2020). Beyond computer vision, the realm of event-based sensing extends to auditory sensors known as silicon cochleas (Chan et al., 2007), as well as radar (Stuijt et al., 2021) and tactile sensors (Caviglia et al., 2016).
+
+Neuromorphic sensors make available a new kind of sparse, asynchronous data, which does not suit current high-throughput, synchronous accelerators such as GPUs. To process event-based data efficiently, a new generation of neuromorphic hardware is being developed in parallel to the spiking neural network models that can be trained in software. Spiking neuromorphic implementations include large-scale simulation of neuronal networks for neuroscience research (Furber et al., 2012) and lowpower real-world deployments of machine learning algorithms. In particular, convolutional neural network (CNN) architectures, used for computer vision, have been run on neuromorphic chips such as IBM’s TrueNorth (Esser et al., 2016), Intel’s Loihi (Davies et al., 2018) and SynSense’s Speck and Dynap-CNN hardware (Liu et al., 2019a). The full pipeline of event-based sensors that output sparse data, stateful spiking neural networks which extract semantic meaning and asynchronous hardware backends allows for large gains in power-efficiency when compared to conventional systems.
+
+# 1.2 ADVERSARIAL ATTACKS ON DISCRETE DATA
+
+The history of attack strategies against various kinds of machine-learning algorithms pre-dates the advent of deep learning (Biggio & Roli, 2018), but the phenomenon received widespread interest when adversarial examples were first found for deep convolutional networks (Szegedy et al., 2013). Generally speaking, given a neural network classifier $C$ and an input $x$ which is correctly classified, finding an adversarial perturbation means finding the smallest $\delta$ such that $C ( x + \delta ) \neq C ( x )$ . Here, “smallest” refers to minimising $\| \delta \|$ , where the norm is chosen arbitrarily depending on the requirements of the experiment. For example, using the $L ^ { \infty }$ norm (maximum norm) will generally make the perturbation less noticeable to a human eye, since the difference in any pixel value between the original and perturbed images will be below a maximum value that is kept as low as possible. Conversely, the use of the $L ^ { 1 }$ norm will encourage sparsity, i.e. a smaller number of perturbed pixels. The main challenges in transferring existing adversarial algorithms to event-based neuromorphic vision lie in the dynamics of the data and network, which develop in continuous time, and in the discrete nature of events, which can either be present or absent at a given time and location, unlike the continuous pixel values of traditional image data.
+
+Event-based sensors encode information in the timing, location, and polarity of events, which can be of ‘on’ or ‘off’ type. Because at any point in time an event can either be triggered or not, one can simply view event-based inputs as binary data by discretising time (Figure 1). In this view, the network’s input is a three-dimensional array whose entries describe the number of events at a location $( x , y )$ and in time bin $t$ ; an additional dimension, of length 2, is added due to the polarity of events. If the time discretisation is sufficiently precise, and no more than one event appears in each bin, the data can be treated as binary. A possible approach to attacking these data is exploiting recent work done on attacking binary images, i.e. with either black or white pixels, which are used in the automatic processing of cheques and other documents. Most methods proposed for attacking binary inputs have focused on brute-force approaches that rely on heuristics to reduce the search space (Bagheri et al., 2018; Balkanski et al., 2020). For example, SCAR (Balkanski et al., 2020) is a black-box algorithm that only assumes access to the output probabilities of the network. The algorithm flips bits in areas chosen according to a specific heuristic and keeps flipped those that cause a change in the confidence of the network. Naturally, this algorithm does not scale well to large input sizes, as the number of queries made to the network grows exponentially. In particular, this becomes a serious problem when the time dimension is added, greatly increasing the dimensionality of the input. Instead, in this paper, we chose to focus on the easier problem of white box attacks, where the attacker has full access to the network and can backpropagate gradients through it. This allows us to adapt faster and more effective algorithms to the case of event-based data.
+
+To this end, we chose to adapt existing attack strategies so that they could work with the time dynamics of spiking neural networks, and with the discrete nature of event-based data. We test our attacks on the Neuromorphic MNIST (Orchard et al., 2015) and IBM Gestures (Amir et al., 2017) datasets, which are the most common benchmark datasets within the neuromorphic community. Previous work on adversarial attacks in spiking networks has been reported by Sharmin et al. (2020); however, their work only uses static image data with continuous pixel values converted to Poisson input frequencies, so does not involve dealing with discrete data which was the main challenge in our work. More recently, Liang et al. (2020) did apply attacks to DVS data, using a discretisedgradient technique. They report high success rates, despite some notable problems of vanishing gradients. Concurrently with our work, Marchisio et al. (2021) designed custom algorithms for DVS data, rather than adapting existing ones, but did not report on the magnitudes of the resulting perturbations. None of these validated the effectiveness of their attack strategies against an on-chip model deployed on neuromorphic hardware. Our contributions beyond the existing literature can be summarised as follows:
+
+• We provide detailed results to quantify the effectiveness and scalability of several adversarial attacks strategies, including some not tried before on SNNs.   
+• We show targeted universal attacks on event-based data in the form of adversarial patches, which do not require prior knowledge of the input.   
+• We validate the resulting adversarial examples on an SNN deployed on a convolutional neuromorphic chip. To the best of our knowledge, this is the first time the effectiveness of adversarial examples is demonstrated directly on neuromorphic hardware.
+
+# 2 METHODS
+
+# 2.1 ATTACK STRATEGIES
+
+Projected Gradient Descent As a baseline, we use Projected Gradient Descent (PGD) (Madry et al., 2019), a standard attack algorithm which we use on discrete data in two ways. The first consists in naively rounding the data at each iteration. However, in this case, updates will be retained only if the gradient magnitude is large enough: otherwise, the small changes made to the adversarial input are lost due to the subsequent discretization. Instead, we adopt an approach that prevents this loss of information: we keep a continuous version of the image as a copy, but use the gradients computed on the discretized image to update the continuous version which is kept in memory. To adapt PGD to the scenario where we want to find the smallest perturbation that triggers a misclassification, we sort the values based on how much PGD adjusted them. We then iterate through the sorted list of indices and flip each value until a misclassification is triggered. It should be noted that this step incurs most of the computational overhead, but is necessary to produce good results. Unless stated otherwise, we used the following values for the parameters: the magnitude of the initial random perturbation to the input is set to $\tau = 0 . 0 1$ . The maximum norm of the perturbation was set to $\epsilon = 1 . 5$ . We found that 50 iterations $( N _ { \mathrm { p g d } } )$ of PGD sufficed and the results did not improve by much afterwards.
+
+Probabilistic PGD We also devised an alternative way of using PGD on discrete data, which we call “Probabilistic PGD”. Probabilistic PGD works by assuming that the binary input was generated by sampling from a series of independent Bernoulli random variables. This approach aligns with how the DVS camera generates the binary data: the probability of emitting a spike at time $t$ is proportional to the light intensity, a continuous metric. For each round of PGD, the input is sampled in a differentiable manner by the Gumbel-softmax reparameterization trick (Jang et al., 2017):
+
+$$
+{ \bf x } _ { \mathrm { a d v } } = \sigma \left( \left[ \log ( { \bf r } ) - \log ( { \bf 1 } - { \bf r } ) + \log ( { \bf p } _ { \mathrm { a d v } } ) - \log ( { \bf 1 } - { \bf p } _ { \mathrm { a d v } } ) \right] / T \right) ,
+$$
+
+where $\mathbf { r } \sim \mathcal { U } ( \mathbf { 0 } , \mathbf { 1 } )$ , and $T = 0 . 0 1$ is a temperature parameter. The underlying probabilities $\mathbf { p } _ { \mathrm { a d v } }$ , instead of the pixel values $\mathbf { x } _ { \mathrm { a d v } }$ , are updated using the gradient obtained from the loss function that is minimised by PGD. We saw that this generally improved the performance compared to the PGD version explained above. Gradients are averaged over $N _ { \mathrm { m c } } = 1 0$ samples of $\mathbf { r }$ . It should be noted that the need for a gradient sampling procedure significantly increases the runtime.
+
+SparseFool on discrete data To operate on event-based data efficiently, the ideal adversarial algorithm requires two main properties: sparsity and scalability. Scalability is needed because of the increased dimensionality given by the additional time dimension. Sparsity ensures that the number of events added or removed is kept to a minimum. One approach that combines the above is SparseFool (Modas et al., 2018), which iteratively finds the closest point in $L ^ { 2 }$ on the linearised decision boundary of the network using the DeepFool algorithm (Moosavi-Dezfooli et al., 2015) as a subroutine, followed by a linear solver that enforces sparsity and boundary constraints on the perturbation. Because Spiking Neural Networks (SNNs) have discrete outputs (the number of spikes over time for each output neuron), it is easier to incur in vanishing gradients as the perturbation approaches the decision boundary. Therefore, we had to make changes to the algorithm to take this into account. Firstly, we found that clamping the perturbation at every iteration of DeepFool, so that it was no smaller than a value $\eta$ , offered protection against vanishing gradients. $\eta$ was treated as a hyperpa
+
+![](images/4b95cb9bdbaf2292d125d6d6f63b5beed9e978d640bd72bcd4e7e800349ff99d.jpg)  
+Figure 1: Schematic of the attack procedure on DVS data.
+
+rameter that should be kept as small as it can without incurring in vanishing gradients. Secondly, to account for the discreteness of event-based data, we rounded the output of SparseFool to the nearest integer at each iteration. Finally, SparseFool normally involves upper and lower bounds $l$ and $u$ on pixel values (normally set, for images, to $l = 0 ; u = 2 5 5 )$ . We exploit these to enforce the binary constraint on the data $( l = 0 ; u = 1 )$ , or, in the on-chip experiments, to fix a maximum firing rate in each time bin, which is the same as that of the original input $( l = 0 ; u = \operatorname* { m a x } ( \operatorname* { i n p u t } ) )$ .
+
+Adversarial patches As the name suggests, adversarial patches are perturbations that are accumulated in a certain region of the image. The idea is that these patches are generated in a way that enables the adversary to place them anywhere in the image. This attack is targeted to a desired label, and universal, i.e. not specific to an input. To test a more realistic scenario where an adversary could potentially perform an attack without previous knowledge of the input, we apply these patches to the IBM hand gesture dataset. We note that the prediction of the CNN trained on this dataset is mostly determined by spatial location of the input. For example, the original input of “Right Hand Wave” is not recognised as such if it is shifted or rotated by a substantial amount. In order to simulate effective realistic attacks, we choose to limit both computed and random attack patches to the area of where the actual gesture is performed. As in Brown et al. (2017), we generate the patches using PGD on the log softmax value of the target output neuron. PGD is performed iteratively on different images of the training set and the position of the patch is randomised after each sample. For each item in the training data, the algorithm updates the patch until the target label confidence has reached a pre-defined threshold. The algorithm skips the point if the original label equals the target label. This process is repeated for every training sample and for multiple epochs. To measure the effectiveness of our computed patches, we also generate random patches of the same size, and measure the target success rates. In a random patch, every pixel has a $50 \%$ chance of emitting a spike at each time step.
+
+# 2.2 DATASETS AND DATA PREPARATION
+
+Binarised MNIST We tried our methods on three datasets. The first is a binarised version of MNIST (BMNIST for short), which is derived from the popular MNIST Handwritten Digits database (LeCun & Cortes, 2010), binarised so that pixel values 0 to 127 are mapped to white, and 128 to 255 are mapped to black. No other preprocessing is applied. This is not a dataset of DVS recordings: we use it in order to compare our white box attacks against the SCAR attacks for binary datasets mentioned above (Balkanski et al., 2020).
+
+Neuromorphic MNIST Our first DVS benchmark is NMNIST (Neuromorphic MNIST), which consists of $3 0 0 ~ \mathrm { { m s } }$ -long recordings of MNIST digits that are captured using the saccadic motion of a DVS sensor (Orchard et al., 2015). This is the most commonly used DVS benchmark dataset for simpler tasks: since digits are only translating through the frame without changing, temporal features are not necessary for classification. When testing the spiking network, and for creating adversarial examples, each sample is fed to the network as a sequence of 5 ms-long binary frames. Additional spikes that fall in the same pixel within the same $5 ~ \mathrm { m s }$ window are discarded, so that each bin can contain either 0 or 1 events per pixel. The resulting data is a binary array (referred to as “raster”) of dimensions $( t , p , x , y ) = ( 6 0 , 2 , 3 4 , 3 4 )$ , where $t = 3 0 0 \mathrm { m s } / 5 \mathrm { m s } = 6 0$ is the number of time bins, $p = 2$ are the polarity channels, and $x = y = 3 4$ is the spatial resolution of the recording.
+
+IBM Gestures For a more advanced event-based vision benchmark, we used the IBM Gestures dataset, which consists of recordings of 11 classes of human gestures, captured under three different lighting conditions (Amir et al., 2017). Here, unlike the previous cases, the model must have some ability to process features in time, e.g. to distinguish between clockwise and counterclockwise hand motion in the same spatial position. The length of each gesture recording varies between 4 and 7 seconds. In this work, we never test on the full length of the recording at once, but we use $2 0 0 ~ \mathrm { { m s } }$ slices as the fundamental unit of the dataset. The data fed to the spiking network at test time are the same $2 0 0 ~ \mathrm { { m s } }$ samples, with time discretised in $1 0 ~ \mathrm { m s }$ bins. As above, spikes are capped to 1 per pixel per time bin. The dimensions of the resulting raster are $( t , p , x , y ) = ( 2 0 , 2 , 1 2 8 , 1 2 8 )$ . The experiments designed to run on the chip were binned at a higher time resolution of $2 \mathrm { m s }$ since the neuromorphic hardware is capable to process events in continuous time.
+
+# 2.3 NETWORKS
+
+For the BMNIST experiments, we use a non-spiking network, similar to the one used in Balkanski et al. (2020): two $3 \times 3$ convolutional layers (32 and 64 channels each), with ReLU activations, followed by $2 \times 2$ max-pooling, dropout, and a fully connected layer of 128 features, projecting onto the final layer of 10 output units. The network is trained for 50 epochs at batch size 64, using the Adam (Kingma & Ba, 2014) optimiser with learning rate $1 0 ^ { - 3 }$ on a cross-entropy loss function. The network reached a test accuracy of $9 9 . 1 2 \%$ .
+
+The spiking networks used for the NMNIST and IBM Gestures tasks are simulated using a PyTorchbased SNN library which simulates non-leaky, linear integrate-and-fire neurons with no synaptic dynamics, equivalent to the ones emulated by the neuromorphic chip. In this neuron model, the inputs to each neuron are multiplied by the input weight and simply added to the neuron’s membrane potential. The neuron spikes as soon as its membrane potential reaches a threshold, which is always set to 1. The threshold value is then subtracted from the membrane potential. The network’s output label is the one corresponding to the output neuron that spikes the most, over the timespan during which the input is presented. There are no bias terms in our SNN’s convolutional and linear layers.
+
+The models used for NMNIST were trained using the “weight transfer” method, whereby an equivalent CNN is trained on accumulated frames (i.e. summing the data over the time dimension), and the CNN weights are transferred to the spiking network with thresholds set to 1 (Rueckauer et al., 2017; Sorbaro et al., 2020). The ANN was trained with Adam at batch size 64 with learning rate $1 0 ^ { - 3 }$ for 10 epochs. We then rescaled the weights by layer-wise global factors so that the 99th percentile of activity was the same at each layer, as described by Rueckauer et al. (2017). The model we used consists of three convolutional layers of 20, 32, and 128 channels (kernel size 5 for the first, 3 for the other two), each followed by ReLU activation and $2 \times 2$ average-pooling. The convolutional stack is followed by a fully connected layer with feature size 500, which projects onto the 10 output units. The network achieves $8 4 . 9 3 \%$ classification test accuracy.
+
+For the IBM Gestures task, training is done using backpropagation-through-time (BPTT), required even for feed-forward networks, because of the neurons’ internal states, which persist in time. We make use of a surrogate gradient in the backwards pass to enable learning despite the discontinuous nature of spikes (Neftci et al., 2019): for gradient purposes, the neuron’s nonlinearity is treated as a ReLU with zero-point placed at a value threshold – window. The window value is set to 0.5. For the simulated experiments, we used a network with a convolutional layer of kernel size 2, stride 2, and 8 channels, followed by two convolutional layers of kernel size 3 and 8 channels, and a fully connected layer of 64 channels that projects to the 11 output units. After every convolutional layer, batch-norm, spiking activation, and $2 \times 2$ average pooling are inserted. This network achieves a classification test accuracy of $8 4 . 2 \%$ . The network used for the on-chip experiments has a slightly different architecture and does not have batch-normalisation layers to make it compliant with the hardware.
+
+![](images/3a5b50767dd927dec9ee54e38831b6bb5c037491545e17f5ca9b9f6bb32ff92f.jpg)  
+Figure 2: Examples of adversarial inputs on the BMNIST (top), NMNIST (middle) and IBM Gestures (bottom) datasets, as obtained by the SparseFool method. The captions show the original (true) label, correctly identified, and the class later identified by the model. The data was re-framed in time for convenience of visualisation. Red indicates added spikes. In the BMNIST examples, blue indicates removed pixels. We note that in the lower-dimensional BMNIST case, the effect of the attack is semantically interpretable: for example, adding a stroke that closes the upper left part of a “7” makes it look like a $" 9 "$ not only for the network but also for a human observer. See the supplementary video for more examples and motion visualisation.
+
+# 2.4 EXPERIMENTS ON THE NEUROMORPHIC CHIP
+
+In order to verify our attack strategies in a more realistic scenario, we ran our experiments on neuromorphic hardware1, which is especially suited for SNN inference due to its asynchronous nature. We use a digital, convolutional neuromorphic chip designed for computer vision applications. Weight precision, number of computations per second and throughput are typically reduced as the hardware is optimised for very low power consumption. This can lead to a degradation in prediction accuracy when compared to simulations. Because the networks detailed in the previous sections have to be modified in order to make them suitable for neuromorphic on-chip inference, their weights are rescaled and discretised as required by the chip’s 8-bit weight precision.
+
+<table><tr><td></td><td>Attack</td><td>Success Rate (%)</td><td>Median Elapsed Time (s/sample)</td><td>Median No. Queries</td><td>Median L</td></tr><tr><td rowspan="4">BSIIIY</td><td>SCAR</td><td>100.00</td><td>1.14</td><td>1175</td><td>7</td></tr><tr><td>PGD</td><td>98.89</td><td>0.16</td><td>102</td><td>50</td></tr><tr><td>Probabilistic PGD</td><td>99.70</td><td>0.54</td><td>275</td><td>23</td></tr><tr><td>SparseFool (n = 0.2,λ= 2)</td><td>99.90</td><td>0.08</td><td>11</td><td>14</td></tr><tr><td rowspan="4">LSINNN</td><td>PGD</td><td>48.63</td><td>72.56</td><td>1052</td><td>_t</td></tr><tr><td>Probabilistic PGD</td><td>54.46</td><td>68.35</td><td>774</td><td>522</td></tr><tr><td>SparseFool (n = 0.2,λ = 2)</td><td>99.76</td><td>30.22</td><td>45</td><td>254</td></tr><tr><td>SparseFool (n = 0.5,入= 2)</td><td>99.88</td><td>13.08</td><td>26</td><td>268</td></tr><tr><td rowspan="3"></td><td>SparseFool(n = 0.1,λ= 3)</td><td>100.00</td><td>2.78</td><td>11</td><td>310</td></tr><tr><td>SparseFool (n =0.1,λ= 2)</td><td>99.87</td><td>2.57 3.02</td><td>11</td><td>200</td></tr><tr><td>SparseFool (n =0.1,λ=1)</td><td>97.69</td><td></td><td>17</td><td>116</td></tr></table>
+
+† Samples for which the attack was unsuccessful were considered to have $L ^ { 0 } =$ undefined. Because PGD fails more than half of the time, the median is undefined.
+
+Table 1: Comparison of attack strategies (1000 samples). SCAR was implemented according to the pseudo code in Balkanski et al. (2020) and PGD was run for 50 iterations. SparseFool takes only a fraction of the time compared to PGD while obtaining much sparser results at almost perfect success rate on Neuromorphic MNIST. The input size for this dataset is set to (60,2,34,34). We also use SparseFool to attack samples from the IBM Gestures dataset at different values of $\lambda$ , a parameter trading-off speed and sparsity. The success rate is here defined as the fraction of samples that were initially correctly classified, for which the attack algorithm converged to an adversarial example that the network classifies incorrectly.
+
+As this work focuses on white-box attacks, we first computed the adversarial examples using the network simulation on the computer, then tested both original and attacked spiketrains in simulation and on the chip. The simulation and the attack work in discrete time, while the chip receives events in continuous time. In order to convert the discrete-time attacked raster back to a list of events for the chip, we compared the original and attacked rasters, identifying new events added by the attack and adding them to the original list (Figure 1). We empirically found very few events removed by SparseFool (see supplementary section 1) and chose to ignore removals for on-chip experiments.
+
+# 3 RESULTS
+
+# 3.1 SPARSEFOOL ATTACKS ON BINARY AND DVS DATA
+
+Table 1 compares the different algorithms on Binary-MNIST and shows that SparseFool finds successful adversarial examples with a low median $L ^ { 0 }$ (i.e. number of perturbed pixels), while requiring a very low median execution time. Figure 2 (top) illustrates samples of perturbations found by SparseFool and the corresponding label that was predicted by the network after applying the perturbation. Because of the small sample size and the fact that there is no time dimension, BinaryMNIST enables us to compare SparseFool to other, more inefficient methods. However, more realistic datasets are needed to truly evaluate the feasibility of applying these algorithms.
+
+After having established that SparseFool can efficiently and reliably generate sparse perturbations on discrete data, we evaluated SparseFool’s performance on the DVS benchmarks for different hyperparameters (Table 1). $\eta$ indicates the minimum step size for updates to the perturbation: higher values of $\eta$ find less precise perturbations (larger $L ^ { 0 }$ values), but are sometimes needed in order to prevent zero-gradient issues within the algorithm. $\lambda$ is the sparsity parameter: lower $\lambda$ (with a minimum of 1) yields sparser results, but gives a slightly lower success rate. Overall we consistently found that SparseFool performs better than PGD and Probabilistic PGD, both in terms of success rate and in the number of added or suppressed events. Additionally, it requires far fewer iterations and therefore converges more quickly. Figure 2 and the supplementary video show examples of successful attacks. Supplementary section 1 provides further information on the characteristics of the resulting samples.
+
+![](images/bf44d9285a8f0a54941f40020eea0e435fce080bc3e5f80ce61716ea4aaf1edd.jpg)  
+Figure 3: Examples of adversarial patches successfully applied to a single “right hand clockwise” data sample, with different target classes. See also the supplementary video for motion visualisation and more examples of successful patch attacks.
+
+# 3.2 VALIDATION ON NEUROMORPHIC HARDWARE
+
+We randomly chose 1000 snippets, each $2 0 0 ~ \mathrm { { m s } }$ long, from the IBM Gestures dataset, on which we ran the SparseFool attack. Out of these, 833 were successfully classified by the network and were therefore eligible for an attack; the attacks converged and were successful in simulation in 777 cases. We presented these 777 successful attacks to the chip, alongside the un-attacked original data, finding that $9 6 . 9 \%$ (753) of the originals are successfully classified by the chip, and $8 5 . 3 \%$ of the attacks are able to fool the chip (663) too. A possible reason for this discrepancy lies in how the chip is limited in computing capacity by weight quantization and restricted throughput per time unit, which causes some of the input events to be dropped. The conversion of binned data back into lists of spikes, discussed in the Methods section, is necessarily lossy at this time. In terms of attack efficiency, we observe a median $L ^ { 1 }$ distance (i.e., difference in number of spikes) of 903 among the attacks that were successful on chip, corresponding to a median $9 . 3 \%$ increase in the number of spikes per sample. The full distribution is shown in Figure S1 (bottom left). Figure S1 also shows the time profile of the perturbation and how the network classified the data after the attack.
+
+# 3.3 ADVERSARIAL PATCHES
+
+Although we have demonstrated that one can achieve high success rates on custom spiking hardware that operates with microsecond precision, the applicability of this method is still limited, as the adversary needs to suppress and add events at high spatial and temporal resolution, thus making the assumption that the adversary can modify the event-stream coming from the DVS camera. Furthermore, SparseFool assumes knowledge of the model and requires computing the perturbation offline, which is not feasible in a timely manner. In a more realistic setting, the adversary is assumed to generate perturbations by changing the input the DVS camera receives on the fly.
+
+Using the training data from the IBM Gestures dataset, we generated an adversarial patch for each target class with high temporal precision (event samples of $2 0 0 ~ \mathrm { { m s } }$ were binned using 0.5 ms-wide bins) and evaluated the effectiveness in triggering a targeted misclassification both in simulation and on-chip using the test data. To simulate spatial imprecision during deployment, each test sample was perturbed by a patch that was randomly placed within the area of the original gesture. Table 2 summarises our findings on target success rates for generated and random patches. Simulated results show high success rates, and on-chip performance shows a slight degradation, which can be expected due to weight quantization on the tested specialised hardware. We also found that the chip had trouble processing inputs because most of the added patch events occurred concentrated in the beginning of recordings in a large transient peak. In one case, the targeted attack for label “Arm Roll“ mostly fails on chip as not all events are processed, which makes it harder to discriminate between similar labels such as “Hand Clap“, a similar gesture that occurs in the same central spatial location. This could somewhat be mitigated by limiting the number of events in a patch to ensure that they could all be correctly processed on the chip.
+
+Table 2: Adversarial patches for different target labels were evaluated on– and off–chip. Shown here are the success rates in percent for each target label. An attack is considered successful if the original label is not the target label and the network predicts the target label when the patch is applied.   
+
+<table><tr><td>Target label</td><td>Hand clap</td><td>RH Wave</td><td>LH Wave</td><td>RH Clockwise</td><td>RH Counter Clockwise</td><td>LH Clockwise</td><td>LH Counter Clockwise</td><td>Arm Roll</td><td>Air Drum</td><td>Air Guitar</td><td>Other</td></tr><tr><td>Adversarial patch</td><td>90.3</td><td>99.0</td><td>89.8</td><td>87.3</td><td>79.7</td><td>49.7</td><td>51.5</td><td>63.6</td><td>79.1</td><td>92.3</td><td>64.7</td></tr><tr><td>Adv. patch (on-chip)</td><td>94.0</td><td>89.0</td><td>94.1</td><td>81.3</td><td>65.1</td><td>35.9</td><td>43.8</td><td>5.0</td><td>82.7</td><td>87.3</td><td>66.8</td></tr><tr><td>Random patch</td><td>18.8</td><td>80.7</td><td>77.0</td><td>0</td><td>0</td><td>3.6</td><td>0.6</td><td>0</td><td>0</td><td>12.6</td><td>16.6</td></tr><tr><td>Rand. patch (on-chip)</td><td>43</td><td>76.8</td><td>72.2</td><td>0</td><td>0</td><td>9.0</td><td>2.4</td><td>0</td><td>0</td><td>0</td><td>17.7</td></tr></table>
+
+We compare this result with a baseline of randomly generated patches, and we observe that two labels, namely “Left“ and “Right Hand Wave“ subsume all other attacked labels in this case. This hints that randomly injecting events in various locations is not enough to perturb network prediction to a desired label and that our algorithm succeeds in finding a meaningful patch. To summarise, adversarial patches are effective in triggering a targeted misclassification both on– and off–chip compared to randomly generated ones. Figure 3 and the supplementary video show examples of successful patch attacks. Importantly, these attacks are universal, meaning that they can be applied to any input and do not need to be generated for each sample.
+
+# 4 DISCUSSION
+
+We studied the possibility of fooling spiking neural networks through adversarial perturbations to dynamic vision sensor data, and verified these perturbations on a convolutional neuromorphic chip. There were two main challenges to this endeavour: the discrete nature of event-based data, and their dependence on time. This translated, in practice, in the need for an extra temporal dimension, and in different sparsity requirements, because the magnitude of the perturbation is measured in terms of number of events added or removed. For this purpose, we adapted the sparse adversarial algorithm SparseFool, and showed that it achieves high convergence rates on time-discretised samples of the Neuromorphic MNIST and IBM Gestures datasets. Empirically, we observe that the algorithm mostly resorts to adding, rather than removing, input events, and the number of new events necessary to fool the network varies significantly from sample to sample. In the best cases, the attack requires the addition of less than a hundred events over a $2 0 0 ~ \mathrm { { m s } }$ sample, an increase of a few percent. With this, we have proven adversarial examples in DVS data are possible, and, to the best of our knowledge, we were also the first to show that the perturbation is effective in a network deployed on a neuromorphic chip. As the history of adversarial attack algorithms shows, future research in this field may well find adversarial perturbations that are even less noticeable, detectable, or computationally intensive. One should be aware of this possibility when deploying any neuromorphic devices using DVS technology together with neural network models in all contexts where malicious attacks may have serious consequences, such as autonomous driving, surveillance, or control. For this reason, it is also important to consider how to counter these attacks. Defence mechanisms such as adversarial-aware training exist and can provide better robustness. In preliminary work outlined in supplementary section 2 we apply one such method to SparseFool attacks.
+
+SparseFool computes perturbations offline, and it is currently not obvious how to do this on the fly on a live stream of DVS events. Therefore, we also investigated a more realistic setting, where an adversary can, with low spatial, but high temporal precision, inject spurious events in the form of a patch inserted into the visual field of the DVS camera. We showed that we can generate patches for different target labels, which trigger targeted misclassifications with high precision. Although these patches require a much higher amount of added events, they do not require prior knowledge of the input sample and therefore offer a realistic way of fooling deployed convolutional neuromorphic systems. A natural next step would be to understand whether it is possible to build real-world patches that can fool networks when shown to the DVS camera from a variety of distances and orientations, as Eykholt et al. (2018) did for photographs. Additionally, it will be interesting to see how important knowledge about the architecture is and if one can generate adversarial patches by having access to a network that differs from the deployed ones.
+
+# 5 ETHICS STATEMENT
+
+The authors aim to minimise the impact of potential attacks on deployed SNNs by contributing to overall understanding and supporting public discussion thereof.
+
+A subset of the authors are currently employed by the neuromorphic chip manufacturer, which could be perceived as a conflict of interest. We did our best to counteract this by making available all source code used in the experiments and we encourage other researchers to reproduce our results. The other authors report no current conflicts of interest.
+
+# 6 REPRODUCIBILITY STATEMENT
+
+The authors made available all code that was used to generate results and plots in this paper, which we attach as supplementary material. The code will be made publicly available after the review process. The libraries used for SNN simulation and DVS data management are available as opensource code. The DVS datasets are available online. The neuromorphic chip is available for research purposes. When reproducing experiments on chip, results are expected to differ slightly due to variations in the manufacturing process.
+
+# REFERENCES
+
+Naveed Akhtar and Ajmal Mian. Threat of adversarial attacks on deep learning in computer vision: A survey. IEEE Access, 6:14410–14430, 2018. doi:10.1109/ACCESS.2018.2807385.
+
+Arnon Amir, Brian Taba, David Berg, Timothy Melano, Jeffrey McKinstry, Carmelo Di Nolfo, Tapan Nayak, Alexander Andreopoulos, Guillaume Garreau, Marcela Mendoza, Jeff Kusnitz, Michael Debole, Steve Esser, Tobi Delbruck, Myron Flickner, and Dharmendra Modha. A low power, fully event-based gesture recognition system. In 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 7388–7397, 2017. doi:10.1109/CVPR.2017.781.
+
+Alireza Bagheri, Osvaldo Simeone, and Bipin Rajendran. Adversarial training for probabilistic spiking neural networks, 2018.
+
+Eric Balkanski, Harrison Chase, Kojin Oshiba, Alexander Rilee, Yaron Singer, and Richard Wang. Adversarial attacks on binary image recognition systems. CoRR, abs/2010.11782, 2020. URL https://arxiv.org/abs/2010.11782.
+
+Battista Biggio and Fabio Roli. Wild patterns: Ten years after the rise of adversarial machine learning. Pattern Recognition, 84:317–331, 2018.
+
+Tom B. Brown, Dandelion Mane, Aurko Roy, Mart ´ ´ın Abadi, and Justin Gilmer. Adversarial patch. CoRR, abs/1712.09665, 2017. URL http://arxiv.org/abs/1712.09665.
+
+Stefano Caviglia, Luigi Pinna, Maurizio Valle, and Chiara Bartolozzi. An event-driven posfet taxel for sustained and transient sensing. In 2016 IEEE International Symposium on Circuits and Systems (ISCAS), pp. 349–352. IEEE, 2016.
+
+Vincent Chan, Shih-Chii Liu, and Andre van Schaik. Aer ear: A matched silicon cochlea pair with ´ address event representation interface. IEEE Transactions on Circuits and Systems I: Regular Papers, 54(1):48–59, 2007.
+
+Mike Davies, Narayan Srinivasa, Tsung-Han Lin, Gautham Chinya, Yongqiang Cao, Sri Harsha Choday, Georgios Dimou, Prasad Joshi, Nabil Imam, Shweta Jain, Yuyun Liao, Chit-Kwan Lin, Andrew Lines, Ruokun Liu, Deepak Mathaikutty, Steven McCoy, Arnab Paul, Jonathan Tse, Guruguhanathan Venkataramanan, Yi-Hsin Weng, Andreas Wild, Yoonseok Yang, and Hong Wang. Loihi: A neuromorphic manycore processor with on-chip learning. IEEE Micro, 38(1):82–99, 2018. doi:10.1109/MM.2018.112130359.
+
+Steven K Esser, Paul A Merolla, John V Arthur, Andrew S Cassidy, Rathinakumar Appuswamy, Alexander Andreopoulos, David J Berg, Jeffrey L McKinstry, Timothy Melano, Davis R Barch, et al. Convolutional networks for fast, energy-efficient neuromorphic computing. Proceedings of the national academy of sciences, 113(41):11441–11446, 2016.
+
+Kevin Eykholt, Ivan Evtimov, Earlence Fernandes, Bo Li, Amir Rahmati, Chaowei Xiao, Atul Prakash, Tadayoshi Kohno, and Dawn Song. Robust physical-world attacks on deep learning visual classification. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1625–1634, 2018.
+
+Davide Falanga, Kevin Kleber, and Davide Scaramuzza. Dynamic obstacle avoidance for quadrotors with event cameras. Science Robotics, 5(40), 2020.
+
+Steve B Furber, David R Lester, Luis A Plana, Jim D Garside, Eustace Painkras, Steve Temple, and Andrew D Brown. Overview of the spinnaker system architecture. IEEE Transactions on Computers, 62(12):2454–2467, 2012.
+
+Guillermo Gallego, Tobi Delbruck, Garrick Orchard, Chiara Bartolozzi, Brian Taba, Andrea Censi, Stefan Leutenegger, Andrew Davison, Jorg Conradt, Kostas Daniilidis, et al. Event-based vision: ¨ A survey. arXiv preprint arXiv:1904.08405, 2019.
+
+Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with gumbel-softmax, 2017.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. International Conference on Learning Representations, 12 2014.
+
+Beat Kueng, Elias Mueggler, Guillermo Gallego, and Davide Scaramuzza. Low-latency visual odometry using event-based feature tracks. In 2016 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 16–23. IEEE, 2016.
+
+Yann LeCun and Corinna Cortes. MNIST handwritten digit database. 2010. URL http://yann. lecun.com/exdb/mnist/.
+
+Ling Liang, Xing Hu, Lei Deng, Yujie Wu, Guoqi Li, Yufei Ding, Peng Li, and Yuan Xie. Exploring adversarial attack in spiking neural networks with spike-compatible gradient. CoRR, abs/2001.01587, 2020. URL http://arxiv.org/abs/2001.01587.
+
+Qian Liu, Ole Richter, Carsten Nielsen, Sadique Sheik, Giacomo Indiveri, and Ning Qiao. Live demonstration: face recognition on an ultra-low power event-driven convolutional neural network asic. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pp. 0–0, 2019a.
+
+Shih-Chii Liu and Tobi Delbruck. Neuromorphic sensory systems. Current opinion in neurobiology, 20(3):288–295, 2010.
+
+Shih-Chii Liu, Bodo Rueckauer, Enea Ceolini, Adrian Huber, and Tobi Delbruck. Event-driven sensing for efficient perception: Vision and audition algorithms. IEEE Signal Processing Magazine, 36(6):29–37, 2019b.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks, 2019.
+
+Alberto Marchisio, Giacomo Pira, Maurizio Martina, Guido Masera, and Muhammad Shafique. Dvs-attacks: Adversarial attacks on dynamic vision sensors for spiking neural networks. In 2021 International Joint Conference on Neural Networks (IJCNN), pp. 1–9. IEEE, 2021.
+
+Apostolos Modas, Seyed-Mohsen Moosavi-Dezfooli, and Pascal Frossard. Sparsefool: a few pixels make a big difference. CoRR, abs/1811.02248, 2018. URL http://arxiv.org/abs/ 1811.02248.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. CoRR, abs/1511.04599, 2015. URL http: //arxiv.org/abs/1511.04599.
+
+Emre O Neftci, Hesham Mostafa, and Friedemann Zenke. Surrogate gradient learning in spiking neural networks: Bringing the power of gradient-based optimization to spiking neural networks. IEEE Signal Processing Magazine, 36(6):51–63, 2019.
+
+Garrick Orchard, Ajinkya Jayawant, Gregory K. Cohen, and Nitish Thakor. Converting static image datasets to spiking neuromorphic datasets using saccades. Frontiers in Neuroscience, 9:437, 2015. ISSN 1662-453X. doi:10.3389/fnins.2015.00437. URL https://www.frontiersin. org/article/10.3389/fnins.2015.00437.
+
+Bodo Rueckauer, Iulia-Alexandra Lungu, Yuhuang Hu, Michael Pfeiffer, and Shih-Chii Liu. Conversion of continuous-valued deep networks to efficient event-driven networks for image classification. Frontiers in neuroscience, 11:682, 2017.
+
+Saima Sharmin, Nitin Rathi, Priyadarshini Panda, and Kaushik Roy. Inherent adversarial robustness of deep spiking neural networks: Effects of discrete input encoding and non-linear activations. In European Conference on Computer Vision, pp. 399–414. Springer, 2020.
+
+Martino Sorbaro, Qian Liu, Massimo Bortone, and Sadique Sheik. Optimizing the energy consumption of spiking neural networks for neuromorphic applications. Frontiers in neuroscience, 14:662, 2020.
+
+Jan Stuijt, Manolis Sifalakis, Amirreza Yousefzadeh, and Federico Corradi. µbrain: An event-driven and fully synthesizable architecture for spiking neural networks. Frontiers in neuroscience, 15: 538, 2021.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Hongyang Zhang, Yaodong Yu, Jiantao Jiao, Eric Xing, Laurent El Ghaoui, and Michael Jordan. Theoretically principled trade-off between robustness and accuracy. In International Conference on Machine Learning, pp. 7472–7482. PMLR, 2019.
+
+# SUPPLEMENTARY MATERIAL
+
+# 1 EMPIRICAL ANALYSIS OF THE RESULTING SPARSEFOOL PERTURBATIONS
+
+![](images/444b0c52ae92cd71e1ea6763189dec7f34504600543b5509450acdd88d75a80a.jpg)  
+Figure S1: Properties of the adversarial perturbations found by SparseFool, for two experiments: NMNIST (in simulation, $\eta = 0 . 5 , \lambda = 2 )$ and IBM Gestures (as tested on chip). Top left: Number of events in time within each data sample. The shaded areas represent the 0.1-0.9 interquantile range (not shown for the ‘original’ curve in the bottom panel). The perturbation tends to consist of spikes added at the beginning of the sample, especially for NMNIST which does not rely on temporal structure for inference. Very few spikes are removed, which justifies the choice of ignoring removed spikes in on-chip experiments. The periodic structure of NMNIST samples is intrinsic to the dataset, recorded with saccades. Bottom left: Distribution of increase in number of spikes after the attack, relative to the original number. Right: Matrices showing the label identified by the network when presented with the adversarial examples, given the original label, for the two experiments. Most IBM Gestures classes are perturbed towards the ‘other’ class, while there is no clear structure in the NMNIST case. $\mathrm { L H } =$ Left Hand, $\mathrm { R H } =$ Right Hand, $\mathrm { ( C ) C W = }$ (Counter) ClockWise.
+
+With the aim of gaining more insight into the behaviour of our methods, we studied the characteristics of the perturbations resulting from SparseFool attacks in more detail. For this, we chose two specific experiments: a SparseFool run on NMNIST with hyperparameters $\eta = 0 . 5$ and $\lambda = 2$ ; and the on-chip IBM Gestures experiment. First, we empirically notice that SparseFool-based perturbations rarely involve the removal of events. In the NMNIST experiment considered here, an average of 7.6 events is removed from each sample, compared to an average of 214 spikes added. This justified our choice to ignore removed events in the course of the on-chip experiments.
+
+As is evident from the examples in Figure 2, we also find that SparseFool’s adversarial perturbations tend to consist in the insertion of spikes at the beginning of the sample, with only a few spikes added later in time. The top left panel of figure S1 shows the time profile of the perturbations in detail. We believe this is a consequence of the use of the non-leaky neuron model. In non-leaky neurons, information can be stored indefinitely in the membrane potential, so early spikes have a further chance of contributing to a spike later in time, and are more effective compared to events added later in the sample. This effect is also present in the IBM Gestures experiment, but looks less prominent, possibly because networks trained with BPTT on data with richer features in time have a non-trivial dynamics. In this sense, we expect this phenomenon to be further reduced or disappear entirely when the task is strictly linked to the time evolution of the input signal, such as in auditory speech recognition. The timing of adversarial events could potentially be used for model interpretability purposes, to measure how much the model relies on temporal features.
+
+Further to the median values reported in table 1, the lower left panel of figure S1 reports the full distributions of the number of added or removed events $L ^ { 1 }$ distances). Here, we display the numbers relative to the original number of events in the sample. We notice a minority of cases where the attack is successful only at the cost of a very significant injection of events.
+
+Finally, we analysed the statistics of classes identified by the networks after the attack. SparseFool is used as an “untargeted” algorithm, i.e. it attempts to change the output of the network but without requirements on what the new class should be. Unsurprisingly, the “other gesture” class is a natural target class for many ground truth classes, but there are some exceptions which we find rather natural, such as “left hand wave” gestures being most often converted to “left hand clockwise”. Conversely, we observe no dominant target class in the NMNIST experiment. If the target class structure is undesirable, targeted attacks can be used instead.
+
+# 2 DEFENCE VIA ADVERSARIAL TRAINING
+
+![](images/7e4bd2a1a394038f6dfa9be7fe0f8e1150a1bf522c4c1e23267dedd7f1719380.jpg)  
+Figure S2: Success rate and median $L ^ { 0 }$ of SparseFool for networks trained with TRADES robustness based on PGD attacks.
+
+Once it is known that a model or system is sensitive to a certain type of adversarial attack, it is natural to investigate whether there is a way to build a network that is more resistent to these attacks. We therefore experimented with adversarial training using the TRadeoff-inspired Adversarial DEfense via Surrogate-loss minimization (TRADES) method (Zhang et al., 2019). The method consists of adding a new term to the loss function during training, which minimises the Kullback-Leibler divergence between the output of the network when the original input is presented, and the output when the adversarial example is presented:
+
+$$
+\mathcal { L } _ { \mathrm { r o b } } = \mathcal { L } + \frac { \beta _ { \mathrm { r o b } } } { B } \operatorname { D } _ { \mathrm { K L } } \bigl ( f \bigl ( \mathbf { x } _ { \mathrm { a d v } } \bigr ) ; f \bigl ( \mathbf { x } _ { 0 } \bigr ) \bigr ) .
+$$
+
+Here, $B$ is the batch size, $\beta _ { \mathrm { r o b } }$ is the parameter that defines the trade-off between robustness and accuracy, $f$ is the network and $\mathbf { x } _ { \mathrm { a d v } }$ is the adversarial input. Although networks that were trained using SparseFool would probably be more robust, we opted for PGD at training time, since it can be easily batched — but we attack the resulting networks using SparseFool. We used PGD in the $L ^ { \infty }$ domain and chose $\epsilon = 0 . 5$ as the maximum perturbation, with $N _ { \mathrm { p g d } } = 5$ attack steps. We also did not greedily chose the best indices to flip as described in section 2.1. Even if this was a much simplified version of the PGD attack, we found that this configuration produced perturbations with reasonable Hamming distances while being extremely efficient, and it was sufficient in inducing some level of robustness.
+
+From the results in Figure S2 we note that the success rate is still quite high despite the adversarial training for the choices of $\beta _ { \mathrm { r o b } }$ we considered. However, given the fact that SparseFool aims at finding the smallest perturbation that triggers a misclassification, this is expected, and there is already a noticeable increase in the number of added spikes required, which is indeed a sign of robustness. In other words, the adversarially-trained network requires stronger and less stealthy attacks before it is fooled. Further work is required for a comprehensive investigation of other possible defence strategies.

parse/dev/e0uknAgETh/e0uknAgETh_content_list.json

@@ -0,0 +1,1300 @@
+[
+    {
+        "type": "text",
+        "text": "ADVERSARIAL ATTACKS ON SPIKING CONVOLUTIONAL NETWORKS FOR EVENT-BASED VISION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Event-based sensing using dynamic vision sensors is gaining traction in lowpower vision applications. Spiking neural networks work well with the sparse nature of event-based data and suit deployment on low-power neuromorphic hardware. Being a nascent field, the sensitivity of spiking neural networks to potentially malicious adversarial attacks has received very little attention so far. In this work, we show how white-box adversarial attack algorithms can be adapted to the discrete and sparse nature of event-based visual data, and to the continuous-time setting of spiking neural networks. We test our methods on the N-MNIST and IBM Gestures neuromorphic vision datasets and show adversarial perturbations achieve a high success rate, by injecting a relatively small number of appropriately placed events. We also verify, for the first time, the effectiveness of these perturbations directly on neuromorphic hardware. Finally, we discuss the properties of the resulting perturbations and possible future directions. ",
+        "bbox": [
+            233,
+            280,
+            764,
+            459
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            518,
+            334,
+            535
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Unlike the usual neural networks of contemporary deep learning, spiking neural networks (SNN) resemble the animal brain more closely in at least two main aspects: the way their neurons communicate through impulses (spikes), and their dynamics, which evolve in continuous time. Aside from offering the field of computational neuroscience more biologically plausible neuron models and communication schemes, research in the technological applications of spiking neural networks is currently blooming because of the rise of neuromorphic technology. Neuromorphic hardware is directly compatible with spiking neural networks and enables the design of low-power models for use in battery-operated, always-on devices. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            672
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Adversarial examples are an “intriguing property of neural networks” (Szegedy et al., 2013) by which the network is easily fooled into misclassifying an input which has been altered in an almost imperceptible way by the attacker. This property is usually undesirable in applications: it was proven, for example, that an adversarial attack may pose a threat to self-driving cars, by making them misclassify a stop sign as a speed limit sign; and that this attack can be implemented in the real world through stickers physically placed on the road sign (Eykholt et al., 2018). Because of their relevance to real-world applications, a large amount of work has been published on this subject, typically following a pattern where new attacks are discovered, followed by new defense strategies, in turn followed by proof of other strategies that can still break through them (see Akhtar & Mian (2018) for a review). ",
+        "bbox": [
+            174,
+            680,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "With the advent of real-world applications of spiking networks in neuromorphic devices, it is essential to make sure they work securely and reliably in a variety of contexts. In particular, there is a significant need for research on the possibility of adversarial attacks on spiking network models used for computer sensing tasks. In this paper, we make an attempt at modifying event-based data, by adding and removing events, to generate adversarial examples that fool spiking networks into misclassifying them. This offers important insight into the reliability and security of neuromorphic vision devices, with important implications for commercial applications. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1.1 WHAT IS EVENT-BASED SENSING? ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            103,
+            449,
+            117
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Event-based cameras, usually called Dynamic Vision Sensors (DVS), share many characteristics with the mammalian retina, which make them excel in some circumstances where traditional framebased cameras do not perform well (Liu & Delbruck, 2010; Liu et al., 2019b). First, events are generated only when there are changes in the visual scene, automatically removing redundancies; second, their pixels fire independently of each other which means that there is no frame rate, but rather a continuous stream of asynchronous events, so that the latency can be extremely small; third, they have a very high dynamic range which makes them suitable to detect motion in both bright and dark settings. For these reasons, they have found applications in human-robot interaction, odometry, drone control, tracking, and surveillance, including on devices that are already commercially available (Gallego et al., 2019; Kueng et al., 2016; Falanga et al., 2020). Beyond computer vision, the realm of event-based sensing extends to auditory sensors known as silicon cochleas (Chan et al., 2007), as well as radar (Stuijt et al., 2021) and tactile sensors (Caviglia et al., 2016). ",
+        "bbox": [
+            174,
+            130,
+            825,
+            296
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Neuromorphic sensors make available a new kind of sparse, asynchronous data, which does not suit current high-throughput, synchronous accelerators such as GPUs. To process event-based data efficiently, a new generation of neuromorphic hardware is being developed in parallel to the spiking neural network models that can be trained in software. Spiking neuromorphic implementations include large-scale simulation of neuronal networks for neuroscience research (Furber et al., 2012) and lowpower real-world deployments of machine learning algorithms. In particular, convolutional neural network (CNN) architectures, used for computer vision, have been run on neuromorphic chips such as IBM’s TrueNorth (Esser et al., 2016), Intel’s Loihi (Davies et al., 2018) and SynSense’s Speck and Dynap-CNN hardware (Liu et al., 2019a). The full pipeline of event-based sensors that output sparse data, stateful spiking neural networks which extract semantic meaning and asynchronous hardware backends allows for large gains in power-efficiency when compared to conventional systems. ",
+        "bbox": [
+            174,
+            304,
+            825,
+            455
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.2 ADVERSARIAL ATTACKS ON DISCRETE DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            474,
+            521,
+            488
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The history of attack strategies against various kinds of machine-learning algorithms pre-dates the advent of deep learning (Biggio & Roli, 2018), but the phenomenon received widespread interest when adversarial examples were first found for deep convolutional networks (Szegedy et al., 2013). Generally speaking, given a neural network classifier $C$ and an input $x$ which is correctly classified, finding an adversarial perturbation means finding the smallest $\\delta$ such that $C ( x + \\delta ) \\neq C ( x )$ . Here, “smallest” refers to minimising $\\| \\delta \\|$ , where the norm is chosen arbitrarily depending on the requirements of the experiment. For example, using the $L ^ { \\infty }$ norm (maximum norm) will generally make the perturbation less noticeable to a human eye, since the difference in any pixel value between the original and perturbed images will be below a maximum value that is kept as low as possible. Conversely, the use of the $L ^ { 1 }$ norm will encourage sparsity, i.e. a smaller number of perturbed pixels. The main challenges in transferring existing adversarial algorithms to event-based neuromorphic vision lie in the dynamics of the data and network, which develop in continuous time, and in the discrete nature of events, which can either be present or absent at a given time and location, unlike the continuous pixel values of traditional image data. ",
+        "bbox": [
+            174,
+            501,
+            825,
+            695
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Event-based sensors encode information in the timing, location, and polarity of events, which can be of ‘on’ or ‘off’ type. Because at any point in time an event can either be triggered or not, one can simply view event-based inputs as binary data by discretising time (Figure 1). In this view, the network’s input is a three-dimensional array whose entries describe the number of events at a location $( x , y )$ and in time bin $t$ ; an additional dimension, of length 2, is added due to the polarity of events. If the time discretisation is sufficiently precise, and no more than one event appears in each bin, the data can be treated as binary. A possible approach to attacking these data is exploiting recent work done on attacking binary images, i.e. with either black or white pixels, which are used in the automatic processing of cheques and other documents. Most methods proposed for attacking binary inputs have focused on brute-force approaches that rely on heuristics to reduce the search space (Bagheri et al., 2018; Balkanski et al., 2020). For example, SCAR (Balkanski et al., 2020) is a black-box algorithm that only assumes access to the output probabilities of the network. The algorithm flips bits in areas chosen according to a specific heuristic and keeps flipped those that cause a change in the confidence of the network. Naturally, this algorithm does not scale well to large input sizes, as the number of queries made to the network grows exponentially. In particular, this becomes a serious problem when the time dimension is added, greatly increasing the dimensionality of the input. Instead, in this paper, we chose to focus on the easier problem of white box attacks, where the attacker has full access to the network and can backpropagate gradients through it. This allows us to adapt faster and more effective algorithms to the case of event-based data. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To this end, we chose to adapt existing attack strategies so that they could work with the time dynamics of spiking neural networks, and with the discrete nature of event-based data. We test our attacks on the Neuromorphic MNIST (Orchard et al., 2015) and IBM Gestures (Amir et al., 2017) datasets, which are the most common benchmark datasets within the neuromorphic community. Previous work on adversarial attacks in spiking networks has been reported by Sharmin et al. (2020); however, their work only uses static image data with continuous pixel values converted to Poisson input frequencies, so does not involve dealing with discrete data which was the main challenge in our work. More recently, Liang et al. (2020) did apply attacks to DVS data, using a discretisedgradient technique. They report high success rates, despite some notable problems of vanishing gradients. Concurrently with our work, Marchisio et al. (2021) designed custom algorithms for DVS data, rather than adapting existing ones, but did not report on the magnitudes of the resulting perturbations. None of these validated the effectiveness of their attack strategies against an on-chip model deployed on neuromorphic hardware. Our contributions beyond the existing literature can be summarised as follows: ",
+        "bbox": [
+            174,
+            154,
+            825,
+            347
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• We provide detailed results to quantify the effectiveness and scalability of several adversarial attacks strategies, including some not tried before on SNNs.   \n• We show targeted universal attacks on event-based data in the form of adversarial patches, which do not require prior knowledge of the input.   \n• We validate the resulting adversarial examples on an SNN deployed on a convolutional neuromorphic chip. To the best of our knowledge, this is the first time the effectiveness of adversarial examples is demonstrated directly on neuromorphic hardware. ",
+        "bbox": [
+            217,
+            357,
+            825,
+            463
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            482,
+            290,
+            498
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 ATTACK STRATEGIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            513,
+            361,
+            527
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Projected Gradient Descent As a baseline, we use Projected Gradient Descent (PGD) (Madry et al., 2019), a standard attack algorithm which we use on discrete data in two ways. The first consists in naively rounding the data at each iteration. However, in this case, updates will be retained only if the gradient magnitude is large enough: otherwise, the small changes made to the adversarial input are lost due to the subsequent discretization. Instead, we adopt an approach that prevents this loss of information: we keep a continuous version of the image as a copy, but use the gradients computed on the discretized image to update the continuous version which is kept in memory. To adapt PGD to the scenario where we want to find the smallest perturbation that triggers a misclassification, we sort the values based on how much PGD adjusted them. We then iterate through the sorted list of indices and flip each value until a misclassification is triggered. It should be noted that this step incurs most of the computational overhead, but is necessary to produce good results. Unless stated otherwise, we used the following values for the parameters: the magnitude of the initial random perturbation to the input is set to $\\tau = 0 . 0 1$ . The maximum norm of the perturbation was set to $\\epsilon = 1 . 5$ . We found that 50 iterations $( N _ { \\mathrm { p g d } } )$ of PGD sufficed and the results did not improve by much afterwards. ",
+        "bbox": [
+            173,
+            539,
+            825,
+            734
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Probabilistic PGD We also devised an alternative way of using PGD on discrete data, which we call “Probabilistic PGD”. Probabilistic PGD works by assuming that the binary input was generated by sampling from a series of independent Bernoulli random variables. This approach aligns with how the DVS camera generates the binary data: the probability of emitting a spike at time $t$ is proportional to the light intensity, a continuous metric. For each round of PGD, the input is sampled in a differentiable manner by the Gumbel-softmax reparameterization trick (Jang et al., 2017): ",
+        "bbox": [
+            174,
+            747,
+            825,
+            832
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a213fcc134caaa4ad8ff61e8742d3252b353985cf05c76722f6383bf9dbbb19f.jpg",
+        "text": "$$\n{ \\bf x } _ { \\mathrm { a d v } } = \\sigma \\left( \\left[ \\log ( { \\bf r } ) - \\log ( { \\bf 1 } - { \\bf r } ) + \\log ( { \\bf p } _ { \\mathrm { a d v } } ) - \\log ( { \\bf 1 } - { \\bf p } _ { \\mathrm { a d v } } ) \\right] / T \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            834,
+            715,
+            852
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { r } \\sim \\mathcal { U } ( \\mathbf { 0 } , \\mathbf { 1 } )$ , and $T = 0 . 0 1$ is a temperature parameter. The underlying probabilities $\\mathbf { p } _ { \\mathrm { a d v } }$ , instead of the pixel values $\\mathbf { x } _ { \\mathrm { a d v } }$ , are updated using the gradient obtained from the loss function that is minimised by PGD. We saw that this generally improved the performance compared to the PGD version explained above. Gradients are averaged over $N _ { \\mathrm { m c } } = 1 0$ samples of $\\mathbf { r }$ . It should be noted that the need for a gradient sampling procedure significantly increases the runtime. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "SparseFool on discrete data To operate on event-based data efficiently, the ideal adversarial algorithm requires two main properties: sparsity and scalability. Scalability is needed because of the increased dimensionality given by the additional time dimension. Sparsity ensures that the number of events added or removed is kept to a minimum. One approach that combines the above is SparseFool (Modas et al., 2018), which iteratively finds the closest point in $L ^ { 2 }$ on the linearised decision boundary of the network using the DeepFool algorithm (Moosavi-Dezfooli et al., 2015) as a subroutine, followed by a linear solver that enforces sparsity and boundary constraints on the perturbation. Because Spiking Neural Networks (SNNs) have discrete outputs (the number of spikes over time for each output neuron), it is easier to incur in vanishing gradients as the perturbation approaches the decision boundary. Therefore, we had to make changes to the algorithm to take this into account. Firstly, we found that clamping the perturbation at every iteration of DeepFool, so that it was no smaller than a value $\\eta$ , offered protection against vanishing gradients. $\\eta$ was treated as a hyperpa",
+        "bbox": [
+            174,
+            104,
+            483,
+            463
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/4b95cb9bdbaf2292d125d6d6f63b5beed9e978d640bd72bcd4e7e800349ff99d.jpg",
+        "image_caption": [
+            "Figure 1: Schematic of the attack procedure on DVS data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            498,
+            84,
+            820,
+            410
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "rameter that should be kept as small as it can without incurring in vanishing gradients. Secondly, to account for the discreteness of event-based data, we rounded the output of SparseFool to the nearest integer at each iteration. Finally, SparseFool normally involves upper and lower bounds $l$ and $u$ on pixel values (normally set, for images, to $l = 0 ; u = 2 5 5 )$ . We exploit these to enforce the binary constraint on the data $( l = 0 ; u = 1 )$ , or, in the on-chip experiments, to fix a maximum firing rate in each time bin, which is the same as that of the original input $( l = 0 ; u = \\operatorname* { m a x } ( \\operatorname* { i n p u t } ) )$ . ",
+        "bbox": [
+            174,
+            464,
+            825,
+            547
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Adversarial patches As the name suggests, adversarial patches are perturbations that are accumulated in a certain region of the image. The idea is that these patches are generated in a way that enables the adversary to place them anywhere in the image. This attack is targeted to a desired label, and universal, i.e. not specific to an input. To test a more realistic scenario where an adversary could potentially perform an attack without previous knowledge of the input, we apply these patches to the IBM hand gesture dataset. We note that the prediction of the CNN trained on this dataset is mostly determined by spatial location of the input. For example, the original input of “Right Hand Wave” is not recognised as such if it is shifted or rotated by a substantial amount. In order to simulate effective realistic attacks, we choose to limit both computed and random attack patches to the area of where the actual gesture is performed. As in Brown et al. (2017), we generate the patches using PGD on the log softmax value of the target output neuron. PGD is performed iteratively on different images of the training set and the position of the patch is randomised after each sample. For each item in the training data, the algorithm updates the patch until the target label confidence has reached a pre-defined threshold. The algorithm skips the point if the original label equals the target label. This process is repeated for every training sample and for multiple epochs. To measure the effectiveness of our computed patches, we also generate random patches of the same size, and measure the target success rates. In a random patch, every pixel has a $50 \\%$ chance of emitting a spike at each time step. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            797
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 DATASETS AND DATA PREPARATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            814,
+            460,
+            828
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Binarised MNIST We tried our methods on three datasets. The first is a binarised version of MNIST (BMNIST for short), which is derived from the popular MNIST Handwritten Digits database (LeCun & Cortes, 2010), binarised so that pixel values 0 to 127 are mapped to white, and 128 to 255 are mapped to black. No other preprocessing is applied. This is not a dataset of DVS recordings: we use it in order to compare our white box attacks against the SCAR attacks for binary datasets mentioned above (Balkanski et al., 2020). ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Neuromorphic MNIST Our first DVS benchmark is NMNIST (Neuromorphic MNIST), which consists of $3 0 0 ~ \\mathrm { { m s } }$ -long recordings of MNIST digits that are captured using the saccadic motion of a DVS sensor (Orchard et al., 2015). This is the most commonly used DVS benchmark dataset for simpler tasks: since digits are only translating through the frame without changing, temporal features are not necessary for classification. When testing the spiking network, and for creating adversarial examples, each sample is fed to the network as a sequence of 5 ms-long binary frames. Additional spikes that fall in the same pixel within the same $5 ~ \\mathrm { m s }$ window are discarded, so that each bin can contain either 0 or 1 events per pixel. The resulting data is a binary array (referred to as “raster”) of dimensions $( t , p , x , y ) = ( 6 0 , 2 , 3 4 , 3 4 )$ , where $t = 3 0 0 \\mathrm { m s } / 5 \\mathrm { m s } = 6 0$ is the number of time bins, $p = 2$ are the polarity channels, and $x = y = 3 4$ is the spatial resolution of the recording. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "IBM Gestures For a more advanced event-based vision benchmark, we used the IBM Gestures dataset, which consists of recordings of 11 classes of human gestures, captured under three different lighting conditions (Amir et al., 2017). Here, unlike the previous cases, the model must have some ability to process features in time, e.g. to distinguish between clockwise and counterclockwise hand motion in the same spatial position. The length of each gesture recording varies between 4 and 7 seconds. In this work, we never test on the full length of the recording at once, but we use $2 0 0 ~ \\mathrm { { m s } }$ slices as the fundamental unit of the dataset. The data fed to the spiking network at test time are the same $2 0 0 ~ \\mathrm { { m s } }$ samples, with time discretised in $1 0 ~ \\mathrm { m s }$ bins. As above, spikes are capped to 1 per pixel per time bin. The dimensions of the resulting raster are $( t , p , x , y ) = ( 2 0 , 2 , 1 2 8 , 1 2 8 )$ . The experiments designed to run on the chip were binned at a higher time resolution of $2 \\mathrm { m s }$ since the neuromorphic hardware is capable to process events in continuous time. ",
+        "bbox": [
+            174,
+            260,
+            825,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            431,
+            295,
+            445
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For the BMNIST experiments, we use a non-spiking network, similar to the one used in Balkanski et al. (2020): two $3 \\times 3$ convolutional layers (32 and 64 channels each), with ReLU activations, followed by $2 \\times 2$ max-pooling, dropout, and a fully connected layer of 128 features, projecting onto the final layer of 10 output units. The network is trained for 50 epochs at batch size 64, using the Adam (Kingma & Ba, 2014) optimiser with learning rate $1 0 ^ { - 3 }$ on a cross-entropy loss function. The network reached a test accuracy of $9 9 . 1 2 \\%$ . ",
+        "bbox": [
+            174,
+            457,
+            825,
+            541
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The spiking networks used for the NMNIST and IBM Gestures tasks are simulated using a PyTorchbased SNN library which simulates non-leaky, linear integrate-and-fire neurons with no synaptic dynamics, equivalent to the ones emulated by the neuromorphic chip. In this neuron model, the inputs to each neuron are multiplied by the input weight and simply added to the neuron’s membrane potential. The neuron spikes as soon as its membrane potential reaches a threshold, which is always set to 1. The threshold value is then subtracted from the membrane potential. The network’s output label is the one corresponding to the output neuron that spikes the most, over the timespan during which the input is presented. There are no bias terms in our SNN’s convolutional and linear layers. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            659
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The models used for NMNIST were trained using the “weight transfer” method, whereby an equivalent CNN is trained on accumulated frames (i.e. summing the data over the time dimension), and the CNN weights are transferred to the spiking network with thresholds set to 1 (Rueckauer et al., 2017; Sorbaro et al., 2020). The ANN was trained with Adam at batch size 64 with learning rate $1 0 ^ { - 3 }$ for 10 epochs. We then rescaled the weights by layer-wise global factors so that the 99th percentile of activity was the same at each layer, as described by Rueckauer et al. (2017). The model we used consists of three convolutional layers of 20, 32, and 128 channels (kernel size 5 for the first, 3 for the other two), each followed by ReLU activation and $2 \\times 2$ average-pooling. The convolutional stack is followed by a fully connected layer with feature size 500, which projects onto the 10 output units. The network achieves $8 4 . 9 3 \\%$ classification test accuracy. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            805
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For the IBM Gestures task, training is done using backpropagation-through-time (BPTT), required even for feed-forward networks, because of the neurons’ internal states, which persist in time. We make use of a surrogate gradient in the backwards pass to enable learning despite the discontinuous nature of spikes (Neftci et al., 2019): for gradient purposes, the neuron’s nonlinearity is treated as a ReLU with zero-point placed at a value threshold – window. The window value is set to 0.5. For the simulated experiments, we used a network with a convolutional layer of kernel size 2, stride 2, and 8 channels, followed by two convolutional layers of kernel size 3 and 8 channels, and a fully connected layer of 64 channels that projects to the 11 output units. After every convolutional layer, batch-norm, spiking activation, and $2 \\times 2$ average pooling are inserted. This network achieves a classification test accuracy of $8 4 . 2 \\%$ . The network used for the on-chip experiments has a slightly different architecture and does not have batch-normalisation layers to make it compliant with the hardware. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/3a5b50767dd927dec9ee54e38831b6bb5c037491545e17f5ca9b9f6bb32ff92f.jpg",
+        "image_caption": [
+            "Figure 2: Examples of adversarial inputs on the BMNIST (top), NMNIST (middle) and IBM Gestures (bottom) datasets, as obtained by the SparseFool method. The captions show the original (true) label, correctly identified, and the class later identified by the model. The data was re-framed in time for convenience of visualisation. Red indicates added spikes. In the BMNIST examples, blue indicates removed pixels. We note that in the lower-dimensional BMNIST case, the effect of the attack is semantically interpretable: for example, adding a stroke that closes the upper left part of a “7” makes it look like a $\" 9 \"$ not only for the network but also for a human observer. See the supplementary video for more examples and motion visualisation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            103,
+            820,
+            517
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            672,
+            825,
+            728
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2.4 EXPERIMENTS ON THE NEUROMORPHIC CHIP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            747,
+            526,
+            761
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In order to verify our attack strategies in a more realistic scenario, we ran our experiments on neuromorphic hardware1, which is especially suited for SNN inference due to its asynchronous nature. We use a digital, convolutional neuromorphic chip designed for computer vision applications. Weight precision, number of computations per second and throughput are typically reduced as the hardware is optimised for very low power consumption. This can lead to a degradation in prediction accuracy when compared to simulations. Because the networks detailed in the previous sections have to be modified in order to make them suitable for neuromorphic on-chip inference, their weights are rescaled and discretised as required by the chip’s 8-bit weight precision. ",
+        "bbox": [
+            173,
+            772,
+            825,
+            885
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/ae7c25faea561cd158a73f711f9e9d1f8c0f3858a137f0fa0968f53b8b262e7f.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "† Samples for which the attack was unsuccessful were considered to have $L ^ { 0 } =$ undefined. Because PGD fails more than half of the time, the median is undefined. "
+        ],
+        "table_body": "<table><tr><td></td><td>Attack</td><td>Success Rate (%)</td><td>Median Elapsed Time (s/sample)</td><td>Median No. Queries</td><td>Median L</td></tr><tr><td rowspan=\"4\">BSIIIY</td><td>SCAR</td><td>100.00</td><td>1.14</td><td>1175</td><td>7</td></tr><tr><td>PGD</td><td>98.89</td><td>0.16</td><td>102</td><td>50</td></tr><tr><td>Probabilistic PGD</td><td>99.70</td><td>0.54</td><td>275</td><td>23</td></tr><tr><td>SparseFool (n = 0.2,λ= 2)</td><td>99.90</td><td>0.08</td><td>11</td><td>14</td></tr><tr><td rowspan=\"4\">LSINNN</td><td>PGD</td><td>48.63</td><td>72.56</td><td>1052</td><td>_t</td></tr><tr><td>Probabilistic PGD</td><td>54.46</td><td>68.35</td><td>774</td><td>522</td></tr><tr><td>SparseFool (n = 0.2,λ = 2)</td><td>99.76</td><td>30.22</td><td>45</td><td>254</td></tr><tr><td>SparseFool (n = 0.5,入= 2)</td><td>99.88</td><td>13.08</td><td>26</td><td>268</td></tr><tr><td rowspan=\"3\"></td><td>SparseFool(n = 0.1,λ= 3)</td><td>100.00</td><td>2.78</td><td>11</td><td>310</td></tr><tr><td>SparseFool (n =0.1,λ= 2)</td><td>99.87</td><td>2.57 3.02</td><td>11</td><td>200</td></tr><tr><td>SparseFool (n =0.1,λ=1)</td><td>97.69</td><td></td><td>17</td><td>116</td></tr></table>",
+        "bbox": [
+            215,
+            101,
+            740,
+            280
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Comparison of attack strategies (1000 samples). SCAR was implemented according to the pseudo code in Balkanski et al. (2020) and PGD was run for 50 iterations. SparseFool takes only a fraction of the time compared to PGD while obtaining much sparser results at almost perfect success rate on Neuromorphic MNIST. The input size for this dataset is set to (60,2,34,34). We also use SparseFool to attack samples from the IBM Gestures dataset at different values of $\\lambda$ , a parameter trading-off speed and sparsity. The success rate is here defined as the fraction of samples that were initially correctly classified, for which the attack algorithm converged to an adversarial example that the network classifies incorrectly. ",
+        "bbox": [
+            173,
+            316,
+            825,
+            428
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As this work focuses on white-box attacks, we first computed the adversarial examples using the network simulation on the computer, then tested both original and attacked spiketrains in simulation and on the chip. The simulation and the attack work in discrete time, while the chip receives events in continuous time. In order to convert the discrete-time attacked raster back to a list of events for the chip, we compared the original and attacked rasters, identifying new events added by the attack and adding them to the original list (Figure 1). We empirically found very few events removed by SparseFool (see supplementary section 1) and chose to ignore removals for on-chip experiments. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            564
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            595,
+            281,
+            612
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.1 SPARSEFOOL ATTACKS ON BINARY AND DVS DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            635,
+            568,
+            650
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1 compares the different algorithms on Binary-MNIST and shows that SparseFool finds successful adversarial examples with a low median $L ^ { 0 }$ (i.e. number of perturbed pixels), while requiring a very low median execution time. Figure 2 (top) illustrates samples of perturbations found by SparseFool and the corresponding label that was predicted by the network after applying the perturbation. Because of the small sample size and the fact that there is no time dimension, BinaryMNIST enables us to compare SparseFool to other, more inefficient methods. However, more realistic datasets are needed to truly evaluate the feasibility of applying these algorithms. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            763
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "After having established that SparseFool can efficiently and reliably generate sparse perturbations on discrete data, we evaluated SparseFool’s performance on the DVS benchmarks for different hyperparameters (Table 1). $\\eta$ indicates the minimum step size for updates to the perturbation: higher values of $\\eta$ find less precise perturbations (larger $L ^ { 0 }$ values), but are sometimes needed in order to prevent zero-gradient issues within the algorithm. $\\lambda$ is the sparsity parameter: lower $\\lambda$ (with a minimum of 1) yields sparser results, but gives a slightly lower success rate. Overall we consistently found that SparseFool performs better than PGD and Probabilistic PGD, both in terms of success rate and in the number of added or suppressed events. Additionally, it requires far fewer iterations and therefore converges more quickly. Figure 2 and the supplementary video show examples of successful attacks. Supplementary section 1 provides further information on the characteristics of the resulting samples. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/bf44d9285a8f0a54941f40020eea0e435fce080bc3e5f80ce61716ea4aaf1edd.jpg",
+        "image_caption": [
+            "Figure 3: Examples of adversarial patches successfully applied to a single “right hand clockwise” data sample, with different target classes. See also the supplementary video for motion visualisation and more examples of successful patch attacks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            104,
+            820,
+            299
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.2 VALIDATION ON NEUROMORPHIC HARDWARE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            390,
+            529,
+            404
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We randomly chose 1000 snippets, each $2 0 0 ~ \\mathrm { { m s } }$ long, from the IBM Gestures dataset, on which we ran the SparseFool attack. Out of these, 833 were successfully classified by the network and were therefore eligible for an attack; the attacks converged and were successful in simulation in 777 cases. We presented these 777 successful attacks to the chip, alongside the un-attacked original data, finding that $9 6 . 9 \\%$ (753) of the originals are successfully classified by the chip, and $8 5 . 3 \\%$ of the attacks are able to fool the chip (663) too. A possible reason for this discrepancy lies in how the chip is limited in computing capacity by weight quantization and restricted throughput per time unit, which causes some of the input events to be dropped. The conversion of binned data back into lists of spikes, discussed in the Methods section, is necessarily lossy at this time. In terms of attack efficiency, we observe a median $L ^ { 1 }$ distance (i.e., difference in number of spikes) of 903 among the attacks that were successful on chip, corresponding to a median $9 . 3 \\%$ increase in the number of spikes per sample. The full distribution is shown in Figure S1 (bottom left). Figure S1 also shows the time profile of the perturbation and how the network classified the data after the attack. ",
+        "bbox": [
+            174,
+            417,
+            825,
+            598
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.3 ADVERSARIAL PATCHES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            625,
+            382,
+            637
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Although we have demonstrated that one can achieve high success rates on custom spiking hardware that operates with microsecond precision, the applicability of this method is still limited, as the adversary needs to suppress and add events at high spatial and temporal resolution, thus making the assumption that the adversary can modify the event-stream coming from the DVS camera. Furthermore, SparseFool assumes knowledge of the model and requires computing the perturbation offline, which is not feasible in a timely manner. In a more realistic setting, the adversary is assumed to generate perturbations by changing the input the DVS camera receives on the fly. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            750
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Using the training data from the IBM Gestures dataset, we generated an adversarial patch for each target class with high temporal precision (event samples of $2 0 0 ~ \\mathrm { { m s } }$ were binned using 0.5 ms-wide bins) and evaluated the effectiveness in triggering a targeted misclassification both in simulation and on-chip using the test data. To simulate spatial imprecision during deployment, each test sample was perturbed by a patch that was randomly placed within the area of the original gesture. Table 2 summarises our findings on target success rates for generated and random patches. Simulated results show high success rates, and on-chip performance shows a slight degradation, which can be expected due to weight quantization on the tested specialised hardware. We also found that the chip had trouble processing inputs because most of the added patch events occurred concentrated in the beginning of recordings in a large transient peak. In one case, the targeted attack for label “Arm Roll“ mostly fails on chip as not all events are processed, which makes it harder to discriminate between similar labels such as “Hand Clap“, a similar gesture that occurs in the same central spatial location. This could somewhat be mitigated by limiting the number of events in a patch to ensure that they could all be correctly processed on the chip. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e00cea4399a0652ed5ce8b234c302bc3ee4caa7c9703bd1f784dcf10006542d9.jpg",
+        "table_caption": [
+            "Table 2: Adversarial patches for different target labels were evaluated on– and off–chip. Shown here are the success rates in percent for each target label. An attack is considered successful if the original label is not the target label and the network predicts the target label when the patch is applied. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Target label</td><td>Hand clap</td><td>RH Wave</td><td>LH Wave</td><td>RH Clockwise</td><td>RH Counter Clockwise</td><td>LH Clockwise</td><td>LH Counter Clockwise</td><td>Arm Roll</td><td>Air Drum</td><td>Air Guitar</td><td>Other</td></tr><tr><td>Adversarial patch</td><td>90.3</td><td>99.0</td><td>89.8</td><td>87.3</td><td>79.7</td><td>49.7</td><td>51.5</td><td>63.6</td><td>79.1</td><td>92.3</td><td>64.7</td></tr><tr><td>Adv. patch (on-chip)</td><td>94.0</td><td>89.0</td><td>94.1</td><td>81.3</td><td>65.1</td><td>35.9</td><td>43.8</td><td>5.0</td><td>82.7</td><td>87.3</td><td>66.8</td></tr><tr><td>Random patch</td><td>18.8</td><td>80.7</td><td>77.0</td><td>0</td><td>0</td><td>3.6</td><td>0.6</td><td>0</td><td>0</td><td>12.6</td><td>16.6</td></tr><tr><td>Rand. patch (on-chip)</td><td>43</td><td>76.8</td><td>72.2</td><td>0</td><td>0</td><td>9.0</td><td>2.4</td><td>0</td><td>0</td><td>0</td><td>17.7</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            823,
+            170
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            252,
+            823,
+            281
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We compare this result with a baseline of randomly generated patches, and we observe that two labels, namely “Left“ and “Right Hand Wave“ subsume all other attacked labels in this case. This hints that randomly injecting events in various locations is not enough to perturb network prediction to a desired label and that our algorithm succeeds in finding a meaningful patch. To summarise, adversarial patches are effective in triggering a targeted misclassification both on– and off–chip compared to randomly generated ones. Figure 3 and the supplementary video show examples of successful patch attacks. Importantly, these attacks are universal, meaning that they can be applied to any input and do not need to be generated for each sample. ",
+        "bbox": [
+            174,
+            287,
+            825,
+            400
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            424,
+            310,
+            440
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We studied the possibility of fooling spiking neural networks through adversarial perturbations to dynamic vision sensor data, and verified these perturbations on a convolutional neuromorphic chip. There were two main challenges to this endeavour: the discrete nature of event-based data, and their dependence on time. This translated, in practice, in the need for an extra temporal dimension, and in different sparsity requirements, because the magnitude of the perturbation is measured in terms of number of events added or removed. For this purpose, we adapted the sparse adversarial algorithm SparseFool, and showed that it achieves high convergence rates on time-discretised samples of the Neuromorphic MNIST and IBM Gestures datasets. Empirically, we observe that the algorithm mostly resorts to adding, rather than removing, input events, and the number of new events necessary to fool the network varies significantly from sample to sample. In the best cases, the attack requires the addition of less than a hundred events over a $2 0 0 ~ \\mathrm { { m s } }$ sample, an increase of a few percent. With this, we have proven adversarial examples in DVS data are possible, and, to the best of our knowledge, we were also the first to show that the perturbation is effective in a network deployed on a neuromorphic chip. As the history of adversarial attack algorithms shows, future research in this field may well find adversarial perturbations that are even less noticeable, detectable, or computationally intensive. One should be aware of this possibility when deploying any neuromorphic devices using DVS technology together with neural network models in all contexts where malicious attacks may have serious consequences, such as autonomous driving, surveillance, or control. For this reason, it is also important to consider how to counter these attacks. Defence mechanisms such as adversarial-aware training exist and can provide better robustness. In preliminary work outlined in supplementary section 2 we apply one such method to SparseFool attacks. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            751
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "SparseFool computes perturbations offline, and it is currently not obvious how to do this on the fly on a live stream of DVS events. Therefore, we also investigated a more realistic setting, where an adversary can, with low spatial, but high temporal precision, inject spurious events in the form of a patch inserted into the visual field of the DVS camera. We showed that we can generate patches for different target labels, which trigger targeted misclassifications with high precision. Although these patches require a much higher amount of added events, they do not require prior knowledge of the input sample and therefore offer a realistic way of fooling deployed convolutional neuromorphic systems. A natural next step would be to understand whether it is possible to build real-world patches that can fool networks when shown to the DVS camera from a variety of distances and orientations, as Eykholt et al. (2018) did for photographs. Additionally, it will be interesting to see how important knowledge about the architecture is and if one can generate adversarial patches by having access to a network that differs from the deployed ones. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 ETHICS STATEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            375,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors aim to minimise the impact of potential attacks on deployed SNNs by contributing to overall understanding and supporting public discussion thereof. ",
+        "bbox": [
+            174,
+            132,
+            823,
+            161
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A subset of the authors are currently employed by the neuromorphic chip manufacturer, which could be perceived as a conflict of interest. We did our best to counteract this by making available all source code used in the experiments and we encourage other researchers to reproduce our results. The other authors report no current conflicts of interest. ",
+        "bbox": [
+            174,
+            167,
+            825,
+            223
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 REPRODUCIBILITY STATEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            243,
+            467,
+            260
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors made available all code that was used to generate results and plots in this paper, which we attach as supplementary material. The code will be made publicly available after the review process. The libraries used for SNN simulation and DVS data management are available as opensource code. The DVS datasets are available online. The neuromorphic chip is available for research purposes. When reproducing experiments on chip, results are expected to differ slightly due to variations in the manufacturing process. ",
+        "bbox": [
+            174,
+            275,
+            825,
+            359
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            378,
+            285,
+            393
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Naveed Akhtar and Ajmal Mian. Threat of adversarial attacks on deep learning in computer vision: A survey. IEEE Access, 6:14410–14430, 2018. doi:10.1109/ACCESS.2018.2807385. ",
+        "bbox": [
+            173,
+            401,
+            821,
+            430
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arnon Amir, Brian Taba, David Berg, Timothy Melano, Jeffrey McKinstry, Carmelo Di Nolfo, Tapan Nayak, Alexander Andreopoulos, Guillaume Garreau, Marcela Mendoza, Jeff Kusnitz, Michael Debole, Steve Esser, Tobi Delbruck, Myron Flickner, and Dharmendra Modha. A low power, fully event-based gesture recognition system. In 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 7388–7397, 2017. doi:10.1109/CVPR.2017.781. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            508
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alireza Bagheri, Osvaldo Simeone, and Bipin Rajendran. Adversarial training for probabilistic spiking neural networks, 2018. ",
+        "bbox": [
+            169,
+            515,
+            823,
+            545
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eric Balkanski, Harrison Chase, Kojin Oshiba, Alexander Rilee, Yaron Singer, and Richard Wang. Adversarial attacks on binary image recognition systems. CoRR, abs/2010.11782, 2020. URL https://arxiv.org/abs/2010.11782. ",
+        "bbox": [
+            176,
+            551,
+            821,
+            594
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Battista Biggio and Fabio Roli. Wild patterns: Ten years after the rise of adversarial machine learning. Pattern Recognition, 84:317–331, 2018. ",
+        "bbox": [
+            169,
+            602,
+            823,
+            631
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tom B. Brown, Dandelion Mane, Aurko Roy, Mart ´ ´ın Abadi, and Justin Gilmer. Adversarial patch. CoRR, abs/1712.09665, 2017. URL http://arxiv.org/abs/1712.09665. ",
+        "bbox": [
+            171,
+            638,
+            823,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stefano Caviglia, Luigi Pinna, Maurizio Valle, and Chiara Bartolozzi. An event-driven posfet taxel for sustained and transient sensing. In 2016 IEEE International Symposium on Circuits and Systems (ISCAS), pp. 349–352. IEEE, 2016. ",
+        "bbox": [
+            174,
+            675,
+            823,
+            718
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vincent Chan, Shih-Chii Liu, and Andre van Schaik. Aer ear: A matched silicon cochlea pair with ´ address event representation interface. IEEE Transactions on Circuits and Systems I: Regular Papers, 54(1):48–59, 2007. ",
+        "bbox": [
+            173,
+            726,
+            823,
+            767
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mike Davies, Narayan Srinivasa, Tsung-Han Lin, Gautham Chinya, Yongqiang Cao, Sri Harsha Choday, Georgios Dimou, Prasad Joshi, Nabil Imam, Shweta Jain, Yuyun Liao, Chit-Kwan Lin, Andrew Lines, Ruokun Liu, Deepak Mathaikutty, Steven McCoy, Arnab Paul, Jonathan Tse, Guruguhanathan Venkataramanan, Yi-Hsin Weng, Andreas Wild, Yoonseok Yang, and Hong Wang. Loihi: A neuromorphic manycore processor with on-chip learning. IEEE Micro, 38(1):82–99, 2018. doi:10.1109/MM.2018.112130359. ",
+        "bbox": [
+            174,
+            776,
+            823,
+            859
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Steven K Esser, Paul A Merolla, John V Arthur, Andrew S Cassidy, Rathinakumar Appuswamy, Alexander Andreopoulos, David J Berg, Jeffrey L McKinstry, Timothy Melano, Davis R Barch, et al. Convolutional networks for fast, energy-efficient neuromorphic computing. Proceedings of the national academy of sciences, 113(41):11441–11446, 2016. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kevin Eykholt, Ivan Evtimov, Earlence Fernandes, Bo Li, Amir Rahmati, Chaowei Xiao, Atul Prakash, Tadayoshi Kohno, and Dawn Song. Robust physical-world attacks on deep learning visual classification. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1625–1634, 2018. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Davide Falanga, Kevin Kleber, and Davide Scaramuzza. Dynamic obstacle avoidance for quadrotors with event cameras. Science Robotics, 5(40), 2020. ",
+        "bbox": [
+            173,
+            170,
+            821,
+            199
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Steve B Furber, David R Lester, Luis A Plana, Jim D Garside, Eustace Painkras, Steve Temple, and Andrew D Brown. Overview of the spinnaker system architecture. IEEE Transactions on Computers, 62(12):2454–2467, 2012. ",
+        "bbox": [
+            176,
+            209,
+            823,
+            252
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guillermo Gallego, Tobi Delbruck, Garrick Orchard, Chiara Bartolozzi, Brian Taba, Andrea Censi, Stefan Leutenegger, Andrew Davison, Jorg Conradt, Kostas Daniilidis, et al. Event-based vision: ¨ A survey. arXiv preprint arXiv:1904.08405, 2019. ",
+        "bbox": [
+            176,
+            262,
+            823,
+            304
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with gumbel-softmax, 2017. ",
+        "bbox": [
+            171,
+            314,
+            823,
+            330
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. International Conference on Learning Representations, 12 2014. ",
+        "bbox": [
+            173,
+            340,
+            823,
+            369
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Beat Kueng, Elias Mueggler, Guillermo Gallego, and Davide Scaramuzza. Low-latency visual odometry using event-based feature tracks. In 2016 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 16–23. IEEE, 2016. ",
+        "bbox": [
+            176,
+            378,
+            823,
+            422
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun and Corinna Cortes. MNIST handwritten digit database. 2010. URL http://yann. lecun.com/exdb/mnist/. ",
+        "bbox": [
+            174,
+            431,
+            820,
+            462
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ling Liang, Xing Hu, Lei Deng, Yujie Wu, Guoqi Li, Yufei Ding, Peng Li, and Yuan Xie. Exploring adversarial attack in spiking neural networks with spike-compatible gradient. CoRR, abs/2001.01587, 2020. URL http://arxiv.org/abs/2001.01587. ",
+        "bbox": [
+            173,
+            470,
+            825,
+            513
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Qian Liu, Ole Richter, Carsten Nielsen, Sadique Sheik, Giacomo Indiveri, and Ning Qiao. Live demonstration: face recognition on an ultra-low power event-driven convolutional neural network asic. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pp. 0–0, 2019a. ",
+        "bbox": [
+            173,
+            523,
+            825,
+            580
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shih-Chii Liu and Tobi Delbruck. Neuromorphic sensory systems. Current opinion in neurobiology, 20(3):288–295, 2010. ",
+        "bbox": [
+            171,
+            590,
+            823,
+            621
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shih-Chii Liu, Bodo Rueckauer, Enea Ceolini, Adrian Huber, and Tobi Delbruck. Event-driven sensing for efficient perception: Vision and audition algorithms. IEEE Signal Processing Magazine, 36(6):29–37, 2019b. ",
+        "bbox": [
+            173,
+            630,
+            823,
+            672
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks, 2019. ",
+        "bbox": [
+            173,
+            683,
+            821,
+            712
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alberto Marchisio, Giacomo Pira, Maurizio Martina, Guido Masera, and Muhammad Shafique. Dvs-attacks: Adversarial attacks on dynamic vision sensors for spiking neural networks. In 2021 International Joint Conference on Neural Networks (IJCNN), pp. 1–9. IEEE, 2021. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            765
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Apostolos Modas, Seyed-Mohsen Moosavi-Dezfooli, and Pascal Frossard. Sparsefool: a few pixels make a big difference. CoRR, abs/1811.02248, 2018. URL http://arxiv.org/abs/ 1811.02248. ",
+        "bbox": [
+            171,
+            775,
+            825,
+            818
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. CoRR, abs/1511.04599, 2015. URL http: //arxiv.org/abs/1511.04599. ",
+        "bbox": [
+            173,
+            828,
+            821,
+            871
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emre O Neftci, Hesham Mostafa, and Friedemann Zenke. Surrogate gradient learning in spiking neural networks: Bringing the power of gradient-based optimization to spiking neural networks. IEEE Signal Processing Magazine, 36(6):51–63, 2019. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Garrick Orchard, Ajinkya Jayawant, Gregory K. Cohen, and Nitish Thakor. Converting static image datasets to spiking neuromorphic datasets using saccades. Frontiers in Neuroscience, 9:437, 2015. ISSN 1662-453X. doi:10.3389/fnins.2015.00437. URL https://www.frontiersin. org/article/10.3389/fnins.2015.00437. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bodo Rueckauer, Iulia-Alexandra Lungu, Yuhuang Hu, Michael Pfeiffer, and Shih-Chii Liu. Conversion of continuous-valued deep networks to efficient event-driven networks for image classification. Frontiers in neuroscience, 11:682, 2017. ",
+        "bbox": [
+            176,
+            169,
+            821,
+            212
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Saima Sharmin, Nitin Rathi, Priyadarshini Panda, and Kaushik Roy. Inherent adversarial robustness of deep spiking neural networks: Effects of discrete input encoding and non-linear activations. In European Conference on Computer Vision, pp. 399–414. Springer, 2020. ",
+        "bbox": [
+            174,
+            219,
+            826,
+            263
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Martino Sorbaro, Qian Liu, Massimo Bortone, and Sadique Sheik. Optimizing the energy consumption of spiking neural networks for neuromorphic applications. Frontiers in neuroscience, 14:662, 2020. ",
+        "bbox": [
+            174,
+            272,
+            825,
+            314
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jan Stuijt, Manolis Sifalakis, Amirreza Yousefzadeh, and Federico Corradi. µbrain: An event-driven and fully synthesizable architecture for spiking neural networks. Frontiers in neuroscience, 15: 538, 2021. ",
+        "bbox": [
+            173,
+            323,
+            825,
+            366
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013. ",
+        "bbox": [
+            171,
+            375,
+            825,
+            404
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hongyang Zhang, Yaodong Yu, Jiantao Jiao, Eric Xing, Laurent El Ghaoui, and Michael Jordan. Theoretically principled trade-off between robustness and accuracy. In International Conference on Machine Learning, pp. 7472–7482. PMLR, 2019. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            455
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "SUPPLEMENTARY MATERIAL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            416,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1 EMPIRICAL ANALYSIS OF THE RESULTING SPARSEFOOL PERTURBATIONS ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            135,
+            810,
+            151
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/444b0c52ae92cd71e1ea6763189dec7f34504600543b5509450acdd88d75a80a.jpg",
+        "image_caption": [
+            "Figure S1: Properties of the adversarial perturbations found by SparseFool, for two experiments: NMNIST (in simulation, $\\eta = 0 . 5 , \\lambda = 2 )$ and IBM Gestures (as tested on chip). Top left: Number of events in time within each data sample. The shaded areas represent the 0.1-0.9 interquantile range (not shown for the ‘original’ curve in the bottom panel). The perturbation tends to consist of spikes added at the beginning of the sample, especially for NMNIST which does not rely on temporal structure for inference. Very few spikes are removed, which justifies the choice of ignoring removed spikes in on-chip experiments. The periodic structure of NMNIST samples is intrinsic to the dataset, recorded with saccades. Bottom left: Distribution of increase in number of spikes after the attack, relative to the original number. Right: Matrices showing the label identified by the network when presented with the adversarial examples, given the original label, for the two experiments. Most IBM Gestures classes are perturbed towards the ‘other’ class, while there is no clear structure in the NMNIST case. $\\mathrm { L H } =$ Left Hand, $\\mathrm { R H } =$ Right Hand, $\\mathrm { ( C ) C W = }$ (Counter) ClockWise. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            218,
+            166,
+            781,
+            493
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "With the aim of gaining more insight into the behaviour of our methods, we studied the characteristics of the perturbations resulting from SparseFool attacks in more detail. For this, we chose two specific experiments: a SparseFool run on NMNIST with hyperparameters $\\eta = 0 . 5$ and $\\lambda = 2$ ; and the on-chip IBM Gestures experiment. First, we empirically notice that SparseFool-based perturbations rarely involve the removal of events. In the NMNIST experiment considered here, an average of 7.6 events is removed from each sample, compared to an average of 214 spikes added. This justified our choice to ignore removed events in the course of the on-chip experiments. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            791
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "As is evident from the examples in Figure 2, we also find that SparseFool’s adversarial perturbations tend to consist in the insertion of spikes at the beginning of the sample, with only a few spikes added later in time. The top left panel of figure S1 shows the time profile of the perturbations in detail. We believe this is a consequence of the use of the non-leaky neuron model. In non-leaky neurons, information can be stored indefinitely in the membrane potential, so early spikes have a further chance of contributing to a spike later in time, and are more effective compared to events added later in the sample. This effect is also present in the IBM Gestures experiment, but looks less prominent, possibly because networks trained with BPTT on data with richer features in time have a non-trivial dynamics. In this sense, we expect this phenomenon to be further reduced or disappear entirely when the task is strictly linked to the time evolution of the input signal, such as in auditory speech recognition. The timing of adversarial events could potentially be used for model interpretability purposes, to measure how much the model relies on temporal features. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Further to the median values reported in table 1, the lower left panel of figure S1 reports the full distributions of the number of added or removed events $L ^ { 1 }$ distances). Here, we display the numbers relative to the original number of events in the sample. We notice a minority of cases where the attack is successful only at the cost of a very significant injection of events. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            208
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Finally, we analysed the statistics of classes identified by the networks after the attack. SparseFool is used as an “untargeted” algorithm, i.e. it attempts to change the output of the network but without requirements on what the new class should be. Unsurprisingly, the “other gesture” class is a natural target class for many ground truth classes, but there are some exceptions which we find rather natural, such as “left hand wave” gestures being most often converted to “left hand clockwise”. Conversely, we observe no dominant target class in the NMNIST experiment. If the target class structure is undesirable, targeted attacks can be used instead. ",
+        "bbox": [
+            173,
+            215,
+            825,
+            314
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2 DEFENCE VIA ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            334,
+            535,
+            349
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/7e4bd2a1a394038f6dfa9be7fe0f8e1150a1bf522c4c1e23267dedd7f1719380.jpg",
+        "image_caption": [
+            "Figure S2: Success rate and median $L ^ { 0 }$ of SparseFool for networks trained with TRADES robustness based on PGD attacks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            310,
+            368,
+            686,
+            484
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Once it is known that a model or system is sensitive to a certain type of adversarial attack, it is natural to investigate whether there is a way to build a network that is more resistent to these attacks. We therefore experimented with adversarial training using the TRadeoff-inspired Adversarial DEfense via Surrogate-loss minimization (TRADES) method (Zhang et al., 2019). The method consists of adding a new term to the loss function during training, which minimises the Kullback-Leibler divergence between the output of the network when the original input is presented, and the output when the adversarial example is presented: ",
+        "bbox": [
+            174,
+            544,
+            825,
+            642
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1eabf3c8fb6e50e3b30e7df61dfcc6912e592a6c85bbc64a723152cf7d0a4539.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { r o b } } = \\mathcal { L } + \\frac { \\beta _ { \\mathrm { r o b } } } { B } \\operatorname { D } _ { \\mathrm { K L } } \\bigl ( f \\bigl ( \\mathbf { x } _ { \\mathrm { a d v } } \\bigr ) ; f \\bigl ( \\mathbf { x } _ { 0 } \\bigr ) \\bigr ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            648,
+            627,
+            679
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Here, $B$ is the batch size, $\\beta _ { \\mathrm { r o b } }$ is the parameter that defines the trade-off between robustness and accuracy, $f$ is the network and $\\mathbf { x } _ { \\mathrm { a d v } }$ is the adversarial input. Although networks that were trained using SparseFool would probably be more robust, we opted for PGD at training time, since it can be easily batched — but we attack the resulting networks using SparseFool. We used PGD in the $L ^ { \\infty }$ domain and chose $\\epsilon = 0 . 5$ as the maximum perturbation, with $N _ { \\mathrm { p g d } } = 5$ attack steps. We also did not greedily chose the best indices to flip as described in section 2.1. Even if this was a much simplified version of the PGD attack, we found that this configuration produced perturbations with reasonable Hamming distances while being extremely efficient, and it was sufficient in inducing some level of robustness. ",
+        "bbox": [
+            173,
+            684,
+            825,
+            810
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "From the results in Figure S2 we note that the success rate is still quite high despite the adversarial training for the choices of $\\beta _ { \\mathrm { r o b } }$ we considered. However, given the fact that SparseFool aims at finding the smallest perturbation that triggers a misclassification, this is expected, and there is already a noticeable increase in the number of added spikes required, which is indeed a sign of robustness. In other words, the adversarially-trained network requires stronger and less stealthy attacks before it is fooled. Further work is required for a comprehensive investigation of other possible defence strategies. ",
+        "bbox": [
+            174,
+            816,
+            825,
+            915
+        ],
+        "page_idx": 13
+    }
+]

parse/dev/e42KbIw6Wb/e42KbIw6Wb_content_list.json

@@ -0,0 +1,1951 @@
+[
+    {
+        "type": "text",
+        "text": "PIX2SEQ: A LANGUAGE MODELING FRAMEWORK FOR OBJECT DETECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            776,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ting Chen, Saurabh Saxena, Lala Li, David J. Fleet, Geoffrey Hinton Google Research, Brain Team ",
+        "bbox": [
+            183,
+            170,
+            668,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present Pix2Seq, a simple and generic framework for object detection. Unlike existing approaches that explicitly integrate prior knowledge about the task, we cast object detection as a language modeling task conditioned on the observed pixel inputs. Object descriptions (e.g., bounding boxes and class labels) are expressed as sequences of discrete tokens, and we train a neural network to perceive the image and generate the desired sequence. Our approach is based mainly on the intuition that if a neural network knows about where and what the objects are, we just need to teach it how to read them out. Beyond the use of task-specific data augmentations, our approach makes minimal assumptions about the task, yet it achieves competitive results on the challenging COCO dataset, compared to highly specialized and well optimized detection algorithms.1 ",
+        "bbox": [
+            233,
+            266,
+            764,
+            420
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/eeabc6241e7e4c20b9c68ec0a08a1d07457092fdb01c02959db24a329c809bf4.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of Pix2Seq framework for object detection. The neural net perceives an image and generates a sequence of tokens that correspond to bounding boxes and class labels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            230,
+            449,
+            766,
+            642
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            715,
+            336,
+            732
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Visual object detection systems aim to recognize and localize all objects of pre-defined categories in an image. The detected objects are typically described by a set of bounding boxes and associated class labels. Given the difficulty of the task, most existing methods, such as (Girshick, 2015; Ren et al., 2015; He et al., 2017; Lin et al., 2017b; Carion et al., 2020), are carefully designed and highly customized, with a significant amount of prior knowledge in the choice of architecture and loss function. For example, many architectures are tailored to the use of bounding boxes (e.g., with region proposals (Girshick, 2015; Ren et al., 2015) and RoI pooling (Girshick et al., 2014; He et al., 2017)). Others are tied to the use of object queries for object binding (Carion et al., 2020). Loss functions are often similarly tailored to the use of bounding boxes, such as box regression (Szegedy et al., 2013; Lin et al., 2017b), set-based matching (Erhan et al., 2014; Carion et al., 2020), or by incorporating specific performance metrics, like intersection-over-union on bounding boxes (Rezatofighi et al., 2019). Although existing systems find applications in myriad domains, from self-driving cars (Sun et al., 2020), to medical image analysis (Jaeger et al., 2020), to agriculture (Sa et al., 2016), the specialization and complexity make them difficult to integrate into a larger system, or generalize to a much broader array of tasks associated with general intelligence. ",
+        "bbox": [
+            174,
+            747,
+            825,
+            887
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper advocates a new approach, based on the intuition that if a neural net knows about where and what the objects are, we just need to teach it to read them out. And by learning to “describe” objects the model can learn to ground the “language” on pixel observations, leading to useful object representations. This is realized with our Pix2Seq framework (see Figure 1). Given an image, our model produces a sequence of discrete tokens that correspond to object descriptions (e.g., object bounding boxes and class labels), reminiscent of an image captioning system (Vinyals et al., 2015b; Karpathy & Fei-Fei, 2015; Xu et al., 2015). In essence, we cast object detection as a language modeling task conditioned on pixel inputs, for which the model architecture and loss function are generic and relatively simple, without being engineered specifically for the detection task. As such, one can readily extend the framework to different domains or applications, or incorporate it into a perceptual system supporting general intelligence, for which it provides a language interface to a wide range of vision tasks. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            347
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To tackle the detection task with Pix2Seq, we first propose a quantization and serialization scheme that converts bounding boxes and class labels into sequences of discrete tokens. We then leverage an encoder-decoder architecture for perceiving pixel inputs and generating the target sequence. The objective function is simply the maximum likelihood of tokens conditioned on pixel inputs and the preceding tokens. While both the architecture and loss function are task-agnostic (without assuming prior knowledge about object detection, e.g., bounding boxes), we can still incorporate task-specific prior knowledge with a sequence augmentation technique, proposed below, that alters both input and target sequences during training. Through extensive experimentation, we demonstrate that this simple Pix2Seq framework can achieve competitive results on the COCO dataset compared to highly customized, well established approaches, including Faster R-CNN (Ren et al., 2015) and DETR (Carion et al., 2020). By pretraining our model on a larger object detection dataset, its performance can be further improved. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            520
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 THE PIX2SEQ FRAMEWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            541,
+            436,
+            558
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the proposed Pix2Seq framework we cast object detection as a language modeling task, conditioned on pixel inputs (Figure 1). The system consists of four main components (Figure 2): ",
+        "bbox": [
+            176,
+            574,
+            823,
+            602
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Image Augmentation: As is common in training computer vision models, we use image augmentations to enrich a fixed set of training examples (e.g., with random scaling and crops). • Sequence construction & augmentation: As object annotations for an image are usually represented as a set of bounding boxes and class labels, we convert them into a sequence of discrete tokens. • Architecture: We use an encoder-decoder model, where the encoder perceives pixel inputs, and the decoder generates the target sequence (one token at a time). • Objective/loss function: The model is trained to maximize the log likelihood of tokens conditioned on the image and the preceding tokens (with a softmax cross-entropy loss). ",
+        "bbox": [
+            179,
+            608,
+            826,
+            736
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/90efa70d655a4b173a2944d364ec27088fd401cd17f102b21635dbc065d864b2.jpg",
+        "image_caption": [
+            "Figure 2: Major components of the Pix2Seq learning framework. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            752,
+            772,
+            881
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": ".1 SEQUENCE CONSTRUCTION FROM OBJECT DESCRIPTIONS ",
+        "text_level": 1,
+        "bbox": [
+            183,
+            104,
+            609,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In common object detection datasets, such as Pascal VOC (Everingham et al., 2010), COCO (Lin et al., 2014), and OpenImages (Kuznetsova et al., 2020), images have variable numbers of objects, represented as sets of bounding boxes and class labels. In Pix2Seq we express them as sequences of discrete tokens. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            185
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While class labels are naturally expressed as discrete tokens, bounding boxes are not. A bounding box is determined by two of its corner points (i.e., top-left and bottom-right), or by its center point plus height and width. We propose to discretize the continuous numbers used to specify the $x$ , $y$ coordinates of corner points (similarly for height and width if the other box format is used). Specifically, an object is represented as a sequence of five discrete tokens, i.e. $[ y _ { \\mathrm { m i n } } , x _ { \\mathrm { m i n } } , y _ { \\mathrm { m a x } } , x _ { \\mathrm { m a x } } , c ]$ , where each of the continuous corner coordinates is uniformly discretized into an integer between $[ 1 , n _ { \\mathrm { b i n s } } ]$ , and $c$ is the class index. We use a shared vocabulary for all tokens, so the vocabulary size is equal to number of bins $^ +$ number of classes. This quantization scheme for the bounding boxes allows us to use a small vocabulary while achieving high precision. For example, a $6 0 0 \\times 6 0 0$ image requires only 600 bins to achieve zero quantization error. This is much smaller than modern language models with vocabulary sizes of 32K or higher (Radford et al., 2018; Devlin et al., 2018). The effect of different levels of quantization on the placement of bounding boxes is illustrated in Figure 3. ",
+        "bbox": [
+            174,
+            193,
+            825,
+            359
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "With each object description expressed as a short discrete sequence, we next need to serialize multiple object descriptions to form a single sequence for a given image. Since order of objects does not matter for the detection task per se, we use a random ordering strategy (randomizing the order objects each time an image is shown). We also explore other deterministic ordering strategies, but we hypothesize that random ordering will work just as well as any deterministic ordering, given a capable neural net and autoregressive modeling (where the net can learn to model the distribution of remaining objects conditioned on those observed). ",
+        "bbox": [
+            174,
+            366,
+            825,
+            463
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, because different images often have different numbers of objects, the generated sequences will have different lengths. To indicate the end of a sequence, we therefore incorporate an EOS token.0  0  0  0 The sequence construction process with different ordering strategies is illustrated in Figure 4. ",
+        "bbox": [
+            174,
+            470,
+            825,
+            512
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/e7d853efcb155a13641c6d07c67311db146c4d0dcc754d69ab8d68c9b6e7b63d.jpg",
+        "image_caption": [
+            "Figure 3: Applying the proposed discritization of bounding box on an image of $4 8 0 \\times 6 4 0$ . Only a 200 300 400 500 600 0 100 200 300 400 500 600 0 100 200 300 400 500 600 0 100 200 300 400 500 0 100 200 300 quarter of the image is shown for better clarity. With a small number of bins, such as 500 bins $( \\sim 1$ Truth  Truthpixel/bin), it achieves high precision even for small objects. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            523,
+            816,
+            667
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/18a067c504b06ba5a3509e594c2bb9e3c1ad8cae12197488eac4411657ed5033.jpg",
+        "image_caption": [
+            "Figure 4: Examples of sequence construction with $n _ { \\mathrm { b i n s } } = 1 0 0 0$ , and 0 is EOS token. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            737,
+            429,
+            876
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/6546d73d2a0f3ef2c8df262714154e793b81f6d52121183aa833adc8a48a8d96.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            488,
+            739,
+            812,
+            880
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 ARCHITECTURE, OBJECTIVE AND INFERENCE ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            104,
+            529,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Treating the sequences that we construct from object descriptions as a “dialect”, we turn to generic architectures and objective functions that have been effective in language modeling. ",
+        "bbox": [
+            171,
+            128,
+            823,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Architecture We use an encoder-decoder architecture. The encoder can be a general image encoder that perceives pixels and encodes them into hidden representations, such as a ConvNet (LeCun et al., 1989; Krizhevsky et al., 2012; He et al., 2016), Transformer (Vaswani et al., 2017; Dosovitskiy et al., 2020), or their combination (Carion et al., 2020). For generation we use a Transformer decoder, widely used in modern language modeling (Radford et al., 2018; Raffel et al., 2019). It generates one token at a time, conditioned on the preceding tokens and the encoded image representation. This removes the complexity and customization in architectures of modern object detectors, e.g., bounding box proposal and regression, since tokens are generated from a single vocabulary with a softmax. ",
+        "bbox": [
+            173,
+            172,
+            826,
+            285
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Objective Similar to language modeling, Pix2Seq is trained to predict tokens, given an image and preceding tokens, with a maximum likelihood loss, i.e., ",
+        "bbox": [
+            174,
+            299,
+            821,
+            328
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/172306c122938e64d39b3cae698387306d1ba7b0ef3b406e4d7f67f5a077c10c.jpg",
+        "text": "$$\n\\mathrm { m a x i m i z e } \\sum _ { j = 1 } ^ { L } { \\pmb w } _ { j } \\log P ( \\tilde { \\pmb y } _ { j } | { \\pmb x } , { \\pmb y } _ { 1 : j - 1 } ) ~ ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            334,
+            627,
+            378
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $_ { \\textbf { \\em x } }$ is a given image, $\\textbf {  { y } }$ and $\\tilde { \\pmb { y } }$ are input and target sequences associated with $_ { \\textbf { \\em x } }$ , and $L$ is the target sequence length. $\\textbf {  { y } }$ and $\\tilde { y }$ are identical in the standard language modeling setup, but they can also be different (as in our later augmented sequence construction). Also, ${ \\pmb w } _ { j }$ is a pre-assigned weight for $j$ -th token in the sequence. We set ${ \\pmb w } _ { j } = 1 , \\forall j$ , however it would be possible to weight tokens by their types (e.g., coordinate vs class tokens), or by the size of the corresponding object. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            454
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Inference At inference time, we sample tokens from model likelihood, i.e., $P ( \\pmb { y } _ { j } | \\pmb { x } , \\pmb { y } _ { 1 : j - 1 } )$ . This can be done by either taking the token with the largest likelihood (arg max sampling), or using other stochastic sampling techniques. We find that using nucleus sampling (Holtzman et al., 2019) leads to higher recall than arg max sampling (Appendix C). The sequence ends when the EOS token is generated. Once the sequence is generated, it is straight-forward to extract and de-quantize the object descriptions (i.e., obtaining the predicted bounding boxes and class labels). ",
+        "bbox": [
+            173,
+            468,
+            825,
+            553
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 SEQUENCE AUGMENTATION TO INTEGRATE TASK PRIORS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            570,
+            607,
+            583
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The EOS token allows the model to decide when to terminate generation, but in practice we find that the model tends to finish without predicting all objects. This is likely due to 1) annotation noise (e.g., where annotators did not identify all the objects), and 2) uncertainty in recognizing or localizing some objects. While this only affects the overall performance by a small percentage (e.g., $1 \\%$ in average precision), it has a larger effect on recall. To encourage higher recall rates, one trick is to delay the sampling of the EOS token by artificially decreasing its likelihood. However, this often leads to noisy and duplicated predictions. In part, this difficult trade-off between precision and recall is a consequence of our model being task agnostic, unaware of the detection task per se. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            707
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To mitigate the problem we simply introduce a sequence augmentation technique, thereby incorporating prior knowledge about the task. The target sequence $\\tilde { y }$ in conventional autoregressive language modeling (i.e., with no sequence augmentation) is the same as the input sequence $\\textbf {  { y } }$ . And all tokens in a sequence are real (e.g., converted from human annotations). With sequence augmentation, we instead augment input sequences during training to include both real and synthetic noise tokens. We also modify target sequences so that the model can learn to identify the noise tokens rather than mimic them. This improves the robustness of the model against noisy and duplicated predictions (particularly when the EOS token is delayed to increase recall). The modifications introduced by sequence augmentation are illustrated in Figure 5, and detailed below. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            839
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Altered sequence construction We first create synthetic noise objects to augment input sequences in the following two ways: 1) adding noise to existing ground-truth objects (e.g., random scaling or shifting their bounding boxes), and 2) generating completely random boxes (with randomly associated class labels). It is worth noting that some of these noise objects may be identical to, or overlapping with, some of the ground-truth objects, simulating noisy and duplicated predictions, as demonstrated in Figure 6. After noise objects are synthesised and discretized, we then append them in the end of the original input sequence. As for the target sequence, we set the target tokens of noise objects to “noise” class (not belonging to any of the ground-truth class labels), and the coordinate tokens of noise objects to $\\mathrm { ^ { 6 6 } n / a } ^ { \\prime \\prime }$ , whose loss weights are set to zero, i.e., setting $\\pmb { w } _ { j } = \\mathbb { 1 } _ { [ \\tilde { \\pmb { y } } _ { j } \\neq \\mathbf { \\ \" { n } } / \\mathbf { a } ^ { \\prime \\prime } ] }$ in Eq 1. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/1007b76bce732c368594be63140135714aa955169f7309ffc052b2b2794ab980.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            102,
+            805,
+            286
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/d5dad653c01cd0d23ebe40e03516667a5e3c8128559c56c5d69181dc1c77908c.jpg",
+        "image_caption": [
+            "Figure 5: Illustration of language modeling with / without sequence augmentation. With sequence augmentation, input tokens are constructed to include both real objects (blue) and synthetic noise objects (orange). For the noise objects, the model is trained to identify them as the “noise” class, and we set the loss weight of $\\mathrm { \\ddot { \\Delta } n / a ^ { \\prime } \\mathrm { \\Delta } }$ tokens (corresponding to coordinates of noise objects) to zero since we do not want the model to mimic them. ",
+            "Figure 6: Illustrations of randomly sampled noise objects (in white), vs. ground-truth objects (in red). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            391,
+            808,
+            497
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            569,
+            825,
+            626
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Altered inference With sequence augmentation, we are able to substantially delay the EOS token, improving recall without increasing the frequency of noisy and duplicated predictions. Thus, we let the model predict to a maximum length, yielding a fixed-sized list of objects. When we extract the list of bounding boxes and class labels from the generated sequences, we replace the “noise” class label with a real class label that has the highest likelihood among all real class labels. We use the likelihood of the selected class token as a (ranking) score for the object. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            727
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            751,
+            326,
+            767
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            785,
+            375,
+            799
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the proposed method on the MS-COCO 2017 detection dataset (Lin et al., 2014), containing 118k training images and $5 \\mathrm { k }$ validation images. To compare with DETR and Faster R-CNN, we report average precision (AP), an integral metric over multiple thresholds, on validation set at the last training epoch. We employ two training strategies: 1) training from scratch on COCO in order to compare fairly with the baselines, and also 2) pretraining $^ + .$ finetuning, i.e., pretrain the Pix2Seq model on a larger object detection dataset, namely Objects365 (Shao et al., 2019), and then finetune the model on COCO. Since our approach incorporates zero inductive bias / prior knowledge of the object detection task, we expect the second training strategy to be superior. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/4a21d2e50e912806e6a61906cea42c33ea7d3908d4b709ac5b54d13836d64559.jpg",
+        "table_caption": [
+            "Table 1: Comparison of average precision, over multiple thresholds and object sizes, on COCO validation set. Each section compares different methods of the similar ResNet “backbone”. Our models achieve competitive results to both Faster R-CNN and DETR baselines. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Backbone</td><td>#params</td><td>AP</td><td>AP50</td><td>AP75</td><td>APs</td><td>APm</td><td>APL</td></tr><tr><td>Faster R-CNN</td><td>R50-FPN</td><td>42M</td><td>40.2</td><td>61.0</td><td>43.8</td><td>24.2</td><td>43.5</td><td>52.0</td></tr><tr><td>Faster R-CNN+</td><td>R50-FPN</td><td>42M</td><td>42.0</td><td>62.1</td><td>45.5</td><td>26.6</td><td>45.4</td><td>53.4</td></tr><tr><td>DETR</td><td>R50</td><td>41M</td><td>42.0</td><td>62.4</td><td>44.2</td><td>20.5</td><td>45.8</td><td>61.1</td></tr><tr><td>Pix2seq (Ours)</td><td>R50</td><td>37M</td><td>43.0</td><td>61.0</td><td>45.6</td><td>25.1</td><td>46.9</td><td>59.4</td></tr><tr><td>Faster R-CNN</td><td>R101-FPN</td><td>60M</td><td>42.0</td><td>62.5</td><td>45.9</td><td>25.2</td><td>45.6</td><td>54.6</td></tr><tr><td>Faster R-CNN+</td><td>R101-FPN</td><td>60M</td><td>44.0</td><td>63.9</td><td>47.8</td><td>27.2</td><td>48.1</td><td>56.0</td></tr><tr><td>DETR</td><td>R101</td><td>60M</td><td>43.5</td><td>63.8</td><td>46.4</td><td>21.9</td><td>48.0</td><td>61.8</td></tr><tr><td>Pix2seq (Ours)</td><td>R101</td><td>56M</td><td>44.5</td><td>62.8</td><td>47.5</td><td>26.0</td><td>48.2</td><td>60.3</td></tr><tr><td>Faster R-CNN</td><td>R50-DC5</td><td>166M</td><td>39.0</td><td>60.5</td><td>42.3</td><td>21.4</td><td>43.5</td><td>52.5</td></tr><tr><td>Faster R-CNN+</td><td>R50-DC5</td><td>166M</td><td>41.1</td><td>61.4</td><td>44.3</td><td>22.9</td><td>45.9</td><td>55.0</td></tr><tr><td>DETR</td><td>R50-DC5</td><td>41M</td><td>43.3</td><td>63.1</td><td>45.9</td><td>22.5</td><td>47.3</td><td>61.1</td></tr><tr><td>Pix2seq (Ours)</td><td>R50-DC5</td><td>38M</td><td>43.2</td><td>61.0</td><td>46.1</td><td>26.6</td><td>47.0</td><td>58.6</td></tr><tr><td>DETR</td><td>R101-DC5</td><td>60M</td><td>44.9</td><td>64.7</td><td>47.7</td><td>23.7</td><td>49.5</td><td>62.3</td></tr><tr><td>Pix2seq (Ours)</td><td>R101-DC5</td><td>57M</td><td>45.0</td><td>63.2</td><td>48.6</td><td>28.2</td><td>48.9</td><td>60.4</td></tr></table>",
+        "bbox": [
+            220,
+            155,
+            774,
+            378
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For training from scratch, we follow (Carion et al., 2020) using a ResNet backbone (He et al., 2016), followed by 6 layers of transformer encoder and 6 layers of (causal) transformer decoder (Vaswani et al., 2017). We resize images (with a fixed aspect ratio) so the longer side is 1333 pixels. For sequence construction, we use 2000 quantization bins, and we randomize the order of objects every time an image is shown. We append noise objects to real objects such that each image contains 100 objects in total, and hence a sequence length of 500. The model is trained for 300 epochs with a batch size of 128. ",
+        "bbox": [
+            173,
+            407,
+            825,
+            506
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For pretraining on Objects365 dataset, we use similar settings as above with a few differences. Notably, instead of using the large $1 3 3 3 \\times 1 3 3 3$ image size, we use a smaller image size of $6 4 0 \\times 6 4 0$ , and pretrain the models for 400K steps with batch size of 256. It is worth noting that this pretraining process is even faster than training from scratch due to the use of smaller image size. During the finetuning on COCO dataset, only a small number of epochs (e.g., 20 to 60 epochs) are needed to achieve good results. And we could use larger image size during fine-tuning as well. Due to the use of larger pretraining dataset, we also experiment with larger models with Vision Transformers (Dosovitskiy et al., 2020). ",
+        "bbox": [
+            174,
+            512,
+            825,
+            625
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "More details for both training strategies can be found in Appendix B. As for ablations, we use a ResNet-101 backbone with a smaller image size (the longer side is 640), and we train the model from scratch for 200 epochs. ",
+        "bbox": [
+            176,
+            631,
+            825,
+            672
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 MAIN COMPARISONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            694,
+            359,
+            708
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training from scratch on COCO We mainly compare with two widely recognized baselines: DETR and Faster R-CNN. DETR and our model have comparable architectures, but our Transformer decoder does not require learned “object queries” or separated heads for box regression and classification, since our model generates different types of tokens (e.g., coordinate and class tokens) with a single softmax. Faster R-CNN is a well established method, with optimized architectures such as feature-pyramid networks (FPN) (Lin et al., 2017a). Faster R-CNN is typically trained in fewer epochs than DETR or our model, likely because it explicitly incorporates prior knowledge of the task in the architecture itself. Thus we also include an improved Faster R-CNN baseline, denoted as Faster $\\mathrm { R - C N N + }$ , from (Carion et al., 2020), where Faster R-CNN models are trained with the GIoU loss (Rezatofighi et al., 2019), train-time random crop augmentations, and the long $9 \\mathrm { x }$ training schedule. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results are shown in Table 1, where each section compares different methods of the same ResNet “backbone”. Overall, Pix2Seq achieves competitive results to both baselines. Our model performs comparably to Faster R-CNN on small and medium objects, but better on larger objects. Compared with DETR, our model performs comparably or slightly worse on large and medium objects, but substantially better (4-5 AP) on small objects. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/5f2eade85fc3db8b1eb5e790ce3dc6498e25904c2102e85561e33e1088f082a0.jpg",
+        "table_caption": [
+            "Table 2: Average precision of finetuned Pix2seq models on COCO with different backbone architectures and image sizes. All models are pretrained on Objects365 dataset. As a comparison, our best model without pretraining obtains 45.0 AP (in Table 1) with image size of $1 3 3 3 \\times 1 3 3 3$ . The pretraining is with $6 4 0 \\times 6 4 0$ image size while fine-tuning (a few epochs) can use larger image sizes. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Backbone</td><td rowspan=\"2\"># params</td><td colspan=\"3\">Image size during finetuning</td></tr><tr><td>640×640</td><td>1024×1024</td><td>1333×1333</td></tr><tr><td>R50</td><td>37M</td><td>39.1</td><td>41.7</td><td>42.6</td></tr><tr><td>R50-C4</td><td>85M</td><td>44.7</td><td>46.9</td><td>47.3</td></tr><tr><td>ViT-B</td><td>115M</td><td>44.2</td><td>46.5</td><td>47.1</td></tr><tr><td>ViT-L</td><td>341M</td><td>47.6</td><td>49.0</td><td>50.0</td></tr></table>",
+        "bbox": [
+            290,
+            167,
+            702,
+            261
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            291,
+            825,
+            320
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Pretrain on Objects365 and finetune on COCO As shown in Table 2, the performances of Objects365 pretrained Pix2Seq models are strong across various model sizes and image sizes. The best performance (with 1333 image size) is $5 0 ~ \\mathrm { A P }$ which is $5 \\%$ higher than the best model trained from scratch, and the performance holds up very well even with 640 image size. Notably, with a smaller image size used for pretraining, the pretrain+finetune process is faster than training from scratch, and also generalizes better. Both factors are crucial for training larger and better models. ",
+        "bbox": [
+            173,
+            340,
+            825,
+            425
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 ABLATION ON SEQUENCE CONSTRUCTION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            449,
+            504,
+            462
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 7a explores the effect of coordinate quantization on performance. For this ablation we consider images the longest size of which is 640 pixels. The plot indicates that quantization to 500 bins or more is sufficient; with 500 bins there are approximately 1.3 pixels per bin, which does not introduce significant approximation error. Indeed, as long as one has as many bins as the number of pixels (along the longest side of the image) there should be no significant error due to quantization of the bounding box coordinates. ",
+        "bbox": [
+            173,
+            477,
+            825,
+            560
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also consider different object ordering strategies in sequence construction during training. These include 1) random, 2) area (i.e., descending object size), 3) dist2ori (i.e., the distance of top-left corner of the bounding box to the origin), 4) class (name), 5) class $^ +$ area (i.e., the objects are first ordered by their class, and if there are multiple objects of the same class, they are ordered by area), and 6) class $^ +$ dist2ori. Figure 7b shows average precision (AP) and Figure $\\mathrm { 7 c }$ shows average recall (AR) at the top-100 predictions. Both in terms of precision and recall, the random ordering yields the best performance. We conjecture that with deterministic ordering, it may be difficult for the model to recover from mistakes of missing objects made earlier on, while with random ordering it would still be possible to retrieve them later. ",
+        "bbox": [
+            173,
+            566,
+            826,
+            693
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/a61b92c2f251d36bc2b9c76301682069c7146ed4bebaa07df62fc4f6d5c1dd05.jpg",
+        "image_caption": [
+            "Figure 7: Ablations on sequence construction. (a) Quantization bins vs. performance. (b) and (c) show AP and AR $@ 1 0 0$ for different object ordering strategies. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            713,
+            795,
+            872
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 ABLATION ON SEQUENCE AUGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            506,
+            117
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Here we study the impact of sequence augmentation (i.e., adding the noise objects) for both model training strategies: 1) training from scratch on COCO, and 2) pretraining on Objects365 and finetuning on COCO. Results for training from scratch w/wo sequence augmentation are shown in Figure 8, and we find that without sequence augmentation, the AP is marginally worse if one delays the sampling of EOS token during the inference (via likelihood offsetting), but the recall is significantly worse for the optimal AP. Table 3 shows similar results for pretraining $^ +$ finetuning setting (where we set a loss weight of 0.1 on ending token instead of tuning their likelihood offset), and we find that AP is not significantly affected while recall is significantly worse without sequence augmentation. It is also worth noting that sequence augmentation is mainly effective during the fine-tuning. ",
+        "bbox": [
+            173,
+            136,
+            825,
+            261
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/0c8da224f7f36aed8aedec9c63f2ca22cbc5ee9860169f6e4b59706958628877.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>SeqAug in Pretrain</td><td>SeqAug in Finetune</td><td>AP</td><td>AR@100</td></tr><tr><td>×</td><td>义</td><td>43.7</td><td>55.4</td></tr><tr><td>X</td><td></td><td>44.5</td><td>61.6</td></tr><tr><td>√</td><td>√</td><td>44.7</td><td>61.7</td></tr></table>",
+        "bbox": [
+            514,
+            281,
+            803,
+            361
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0464088e50fd283a641bc6a809a3dddcb169c6298f6ea0e60815952a79dcadff.jpg",
+        "image_caption": [
+            "Figure 8: Impact of sequence augmentation on when training from scratch on COCO. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            285,
+            444,
+            443
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Impact of sequence augmentation when pretraining on Objects365 and finetuning on COCO. Sequence augmentation has a major impact on average recall $( \\ @ 1 0 0 )$ but a smaller influence on AP. Most improvements can be achieved during fine-tuning. ",
+        "bbox": [
+            496,
+            402,
+            825,
+            487
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.5 VISUALIZATION OF DECODER’S CROSS ATTENTION MAP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            521,
+            601,
+            535
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "When generating a new token, the transformer decoder uses self attention over the preceding tokens and cross attention over the encoded visual feature map. Here we visualize the cross attention (averaged over layers and heads) as the model predicts a new token. Figure 9 shows cross attention maps as the first few tokens are generated. One can see that the attention is very diverse when predicting the first coordinate token (i.e $y _ { \\mathrm { m i n . } }$ ), but then quickly concentrates and fixates on the object. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            623
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/c8b7a6ed2f937a297c31036919a883739b7c318cc6c35c120e2bf4d4ba727a64.jpg",
+        "image_caption": [
+            "Figure 9: Decoder’s cross attention to visual feature map when predicting the first 5 objects. (b) we reshape a prediction sequence of 25 into a 5x5 grid, so each row represents a prediction for 5 tokens $[ y _ { \\mathrm { m i n } } , x _ { \\mathrm { m i n } } , y _ { \\mathrm { m a x } } , x _ { \\mathrm { m a x } } , c ]$ . The attention is diverse when selecting the first token of the object, then quickly concentrates on the object. (c) Overlay of the cross attention (when predicting the class token) on the original image. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            655,
+            797,
+            821
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            343,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Object detection. Existing object detection algorithms incorporate explicit prior knowledge about the task in their choice of architecture and loss function. To predict a set of bounding boxes, architectures of modern detectors are specifically designed to produce a large set of proposals (Girshick, 2015; Ren et al., 2015; Cai & Vasconcelos, 2018), anchors (Lin et al., 2017b), or window centers (Tian et al., 2019; Zhou et al., 2019). Non-maximum suppression (Bodla et al., 2017) is often required to prevent duplicate predictions. While DETR (Carion et al., 2020) avoids sophisticated bounding box proposals and non-maximum suppression, it still requires a set of learned “object queries”, specially for object binding. These detectors all require sub-networks (or extra layers) separately for regressing bounding boxes and class labels. Pix2Seq avoids such complexities by having a generic image encoder and sequence decoder, with a single softmax for producing coordinate tokens and class labels. ",
+        "bbox": [
+            174,
+            145,
+            825,
+            284
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Beyond architectures, the loss functions of existing detectors are also highly tailored for matching bounding boxes. For example, the loss function is often based on bounding box regression (Szegedy et al., 2013; Lin et al., 2017b), intersection over union (Rezatofighi et al., 2019), and set-based matching (Erhan et al., 2014; Liu et al., 2016; Redmon et al., 2016; Stewart et al., 2016; Carion et al., 2020). Pix2Seq avoids specialized losses, showing that a straightforward maximum likelihood objective with softmax cross entropy can work well. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            375
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our work is also related to recurrent models in object detection (Stewart et al., 2016; Park & Berg, 2015; Romera-Paredes & Torr, 2016; Salvador et al., 2017; Ren & Zemel, 2017), in which the system learns to predict one object at a time. As above, both architecture and loss functions in these approaches are often tailored to the detection task. Furthermore, these approaches are not based on Transformers, and have not been evaluated against modern baselines on larger datasets. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            450
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Language modeling. Our work is inspired by recent success of modern language modeling (Radford et al., 2019; Raffel et al., 2019; Brown et al., 2020). Although originally intended for natural languages, the underlying methodology has been shown capable of modeling various sequential data, such as machine translation (Sutskever et al., 2014; Bahdanau et al., 2014), image captioning (Vinyals et al., 2015b; Karpathy & Fei-Fei, 2015; Xu et al., 2015), and many others (Vinyals et al., 2015a; Huang et al., 2018; Ramesh et al., 2021; Chen et al., 2021). Our work enriches this portfolio and shows that it works for even non-sequential data (by turning a set of objects into a sequence of tokens). We augment both input and target sequences for our model to incorporate task-specific prior knowledge; similar sequence corruption scheme have been used in language models (Devlin et al., 2018; Clark et al., 2020), and bear some similarity to noise-contrastive learning (Gutmann & Hyvarinen, 2010) and the discriminator in GANs (Goodfellow et al., 2014). ¨ ",
+        "bbox": [
+            173,
+            458,
+            825,
+            611
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            651,
+            486,
+            666
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces Pix2Seq, a simple yet generic framework for object detection. By casting object detection as a language modeling task, our approach largely simplifies the detection pipeline, removing most of the specialization in modern detection algorithms. We believe that our framework not only works for object detection, but can also be applied to other vision tasks where the output can be represented by a relatively concise sequence of discrete tokens (e.g., keypoint detection, image captioning, visual question answering). To this end, we hope to extend Pix2Seq as a generic and unified interface for solving a large variety of vision tasks. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            791
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A major limitation of our approach is that autoregressive modeling is expensive for long sequences (mainly during model inference). Practical measures to mitigate the issue includes: 1) stop inference when the ending token is produced (e.g., in COCO dataset, there are, in average, 7 objects per image, leading to a relatively small number of ${ \\sim } 3 5 $ tokens), 2) applying it to offline inference, or online scenarios where the objects of interest are relatively sparse (e.g. locate a specific object with language description). However, future work is needed to make it faster for real-time object detection applications. Another limitation is that the current approach for training $\\mathrm { P i x 2 S e q }$ is entirely based on human annotation, and by reducing such dependence, it can enable the model to benefit from more unlabeled data. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            367,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We specially thank Xiuye Gu for preparing the Objects365 dataset. We thank Mohammad Norouzi, Simon Kornblith, Tsung-Yi Lin, Allan Jabri, and Kevin Swersky for the helpful discussions. ",
+        "bbox": [
+            176,
+            132,
+            825,
+            161
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            181,
+            287,
+            196
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014. ",
+        "bbox": [
+            176,
+            203,
+            823,
+            229
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Navaneeth Bodla, Bharat Singh, Rama Chellappa, and Larry S Davis. Soft-nms–improving object detection with one line of code. In Proceedings of the IEEE International Conference on Computer Vision, pp. 5561–5569, 2017. ",
+        "bbox": [
+            174,
+            237,
+            825,
+            276
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            324
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhaowei Cai and Nuno Vasconcelos. Cascade r-cnn: Delving into high quality object detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 6154–6162, 2018. ",
+        "bbox": [
+            171,
+            332,
+            823,
+            359
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and Sergey Zagoruyko. End-to-end object detection with transformers. In European Conference on Computer Vision, pp. 213–229. Springer, 2020. ",
+        "bbox": [
+            173,
+            367,
+            825,
+            406
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lili Chen, Kevin Lu, Aravind Rajeswaran, Kimin Lee, Aditya Grover, Michael Laskin, Pieter Abbeel, Aravind Srinivas, and Igor Mordatch. Decision transformer: Reinforcement learning via sequence modeling. arXiv preprint arXiv:2106.01345, 2021. ",
+        "bbox": [
+            176,
+            414,
+            823,
+            454
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In International Conference on Machine Learning, pp. 1597–1607. PMLR, 2020a. ",
+        "bbox": [
+            173,
+            462,
+            825,
+            501
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ting Chen, Simon Kornblith, Kevin Swersky, Mohammad Norouzi, and Geoffrey E Hinton. Big self-supervised models are strong semi-supervised learners. Advances in Neural Information Processing Systems, 33: 22243–22255, 2020b. ",
+        "bbox": [
+            173,
+            508,
+            825,
+            547
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kevin Clark, Minh-Thang Luong, Quoc V. Le, and Christopher D. Manning. ELECTRA: Pre-training text encoders as discriminators rather than generators. In ICLR, 2020. ",
+        "bbox": [
+            173,
+            556,
+            823,
+            583
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018. ",
+        "bbox": [
+            169,
+            590,
+            823,
+            618
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. In International Conference on Learning Representations, 2020. ",
+        "bbox": [
+            176,
+            626,
+            825,
+            665
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dumitru Erhan, Christian Szegedy, Alexander Toshev, and Dragomir Anguelov. Scalable object detection using deep neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2147–2154, 2014. ",
+        "bbox": [
+            171,
+            672,
+            825,
+            712
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "M. Everingham, L. Van Gool, C. K. I. Williams, J. Winn, and A. Zisserman. The pascal visual object classes (voc) challenge. International Journal of Computer Vision, 88(2):303–338, June 2010. ",
+        "bbox": [
+            169,
+            719,
+            823,
+            747
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Golnaz Ghiasi, Yin Cui, Aravind Srinivas, Rui Qian, Tsung-Yi Lin, Ekin D Cubuk, Quoc V Le, and Barret Zoph. Simple copy-paste is a strong data augmentation method for instance segmentation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2918–2928, 2021. ",
+        "bbox": [
+            173,
+            755,
+            823,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ross Girshick. Fast r-cnn. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1440–1448, 2015. ",
+        "bbox": [
+            171,
+            803,
+            825,
+            829
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ross Girshick, Jeff Donahue, Trevor Darrell, and Jitendra Malik. Rich feature hierarchies for accurate object detection and semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 580–587, 2014. ",
+        "bbox": [
+            173,
+            837,
+            823,
+            876
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. Advances in Neural Information Processing Systems, 27, 2014. ",
+        "bbox": [
+            174,
+            885,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Gutmann and Aapo Hyvarinen. Noise-contrastive estimation: A new estimation principle for unnormal-¨ ized statistical models. In Proceedings of the thirteenth International Conference on artificial intelligence and statistics, pp. 297–304. JMLR Workshop and Conference Proceedings, 2010. ",
+        "bbox": [
+            176,
+            104,
+            823,
+            143
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            152,
+            823,
+            180
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Georgia Gkioxari, Piotr Dollar, and Ross Girshick. Mask r-cnn. In ´ Proceedings of the IEEE International Conference on Computer Vision, pp. 2961–2969, 2017. ",
+        "bbox": [
+            171,
+            189,
+            823,
+            217
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Elad Hoffer, Tal Ben-Nun, Itay Hubara, Niv Giladi, Torsten Hoefler, and Daniel Soudry. Augment your batch: Improving generalization through instance repetition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 8129–8138, 2020. ",
+        "bbox": [
+            173,
+            226,
+            823,
+            265
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ari Holtzman, Jan Buys, Li Du, Maxwell Forbes, and Yejin Choi. The curious case of neural text degeneration. arXiv preprint arXiv:1904.09751, 2019. ",
+        "bbox": [
+            173,
+            273,
+            823,
+            301
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew G Howard. Some improvements on deep convolutional neural network based image classification. arXiv preprint arXiv:1312.5402, 2013. ",
+        "bbox": [
+            173,
+            310,
+            825,
+            338
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cheng-Zhi Anna Huang, Ashish Vaswani, Jakob Uszkoreit, Noam Shazeer, Ian Simon, Curtis Hawthorne, Andrew M Dai, Matthew D Hoffman, Monica Dinculescu, and Douglas Eck. Music transformer. arXiv preprint arXiv:1809.04281, 2018. ",
+        "bbox": [
+            173,
+            347,
+            828,
+            387
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q Weinberger. Deep networks with stochastic depth. In European Conference on Computer Vision, pp. 646–661. Springer, 2016. ",
+        "bbox": [
+            173,
+            396,
+            823,
+            424
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Paul F Jaeger, Simon AA Kohl, Sebastian Bickelhaupt, Fabian Isensee, Tristan Anselm Kuder, Heinz-Peter Schlemmer, and Klaus H Maier-Hein. Retina u-net: Embarrassingly simple exploitation of segmentation supervision for medical object detection. In Machine Learning for Health Workshop, pp. 171–183. PMLR, 2020. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            484
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrej Karpathy and Li Fei-Fei. Deep visual-semantic alignments for generating image descriptions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3128–3137, 2015. ",
+        "bbox": [
+            173,
+            494,
+            823,
+            521
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            558
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. Advances in Neural Information Processing Systems, 25:1097–1105, 2012. ",
+        "bbox": [
+            173,
+            566,
+            823,
+            594
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alina Kuznetsova, Hassan Rom, Neil Alldrin, Jasper Uijlings, Ivan Krasin, Jordi Pont-Tuset, Shahab Kamali, Stefan Popov, Matteo Malloci, Alexander Kolesnikov, et al. The open images dataset v4. International Journal of Computer Vision, 128(7):1956–1981, 2020. ",
+        "bbox": [
+            176,
+            603,
+            821,
+            643
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Bernhard Boser, John S Denker, Donnie Henderson, Richard E Howard, Wayne Hubbard, and Lawrence D Jackel. Backpropagation applied to handwritten zip code recognition. Neural computation, 1(4): 541–551, 1989. ",
+        "bbox": [
+            173,
+            652,
+            823,
+            691
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yi Li, Haozhi Qi, Jifeng Dai, Xiangyang Ji, and Yichen Wei. Fully convolutional instance-aware semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2359–2367, 2017. ",
+        "bbox": [
+            173,
+            700,
+            825,
+            741
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and ´ C Lawrence Zitnick. Microsoft coco: Common objects in context. In European Conference on Computer Vision, pp. 740–755. Springer, 2014. ",
+        "bbox": [
+            173,
+            751,
+            823,
+            790
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Piotr Dollar, Ross Girshick, Kaiming He, Bharath Hariharan, and Serge Belongie. Feature ´ pyramid networks for object detection. In Proceedings of the IEEE Conference on Computer Vision and pattern recognition, pp. 2117–2125, 2017a. ",
+        "bbox": [
+            171,
+            799,
+            823,
+            839
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense object detection.´ In Proceedings of the IEEE International Conference on Computer Vision, pp. 2980–2988, 2017b. ",
+        "bbox": [
+            171,
+            848,
+            823,
+            876
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, and Alexander C Berg. Ssd: Single shot multibox detector. In European Conference on Computer Vision, pp. 21–37. Springer, 2016. ",
+        "bbox": [
+            176,
+            885,
+            825,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            171,
+            104,
+            823,
+            131
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Eunbyung Park and Alexander C Berg. Learning to decompose for object detection and instance segmentation. arXiv preprint arXiv:1511.06449, 2015. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            166
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training. 2018. ",
+        "bbox": [
+            174,
+            175,
+            821,
+            203
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, Ilya Sutskever, et al. Language models are unsupervised multitask learners. OpenAI blog, 1(8):9, 2019. ",
+        "bbox": [
+            173,
+            212,
+            823,
+            239
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. arXiv preprint arXiv:1910.10683, 2019. ",
+        "bbox": [
+            174,
+            247,
+            823,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aditya Ramesh, Mikhail Pavlov, Gabriel Goh, Scott Gray, Chelsea Voss, Alec Radford, Mark Chen, and Ilya Sutskever. Zero-shot text-to-image generation. arXiv preprint arXiv:2102.12092, 2021. ",
+        "bbox": [
+            173,
+            295,
+            821,
+            323
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Joseph Redmon, Santosh Divvala, Ross Girshick, and Ali Farhadi. You only look once: Unified, real-time object detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 779–788, 2016. ",
+        "bbox": [
+            174,
+            332,
+            823,
+            371
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mengye Ren and Richard S Zemel. End-to-end instance segmentation with recurrent attention. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 6656–6664, 2017. ",
+        "bbox": [
+            171,
+            380,
+            823,
+            409
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. Advances in Neural Information Processing Systems, 28:91–99, 2015. ",
+        "bbox": [
+            174,
+            416,
+            823,
+            444
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hamid Rezatofighi, Nathan Tsoi, JunYoung Gwak, Amir Sadeghian, Ian Reid, and Silvio Savarese. Generalized intersection over union. June 2019. ",
+        "bbox": [
+            173,
+            452,
+            823,
+            479
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bernardino Romera-Paredes and Philip Hilaire Sean Torr. Recurrent instance segmentation. In European Conference on Computer Vision, pp. 312–329. Springer, 2016. ",
+        "bbox": [
+            174,
+            488,
+            823,
+            515
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Inkyu Sa, Zongyuan Ge, Feras Dayoub, Ben Upcroft, Tristan Perez, and Chris McCool. Deepfruits: A fruit detection system using deep neural networks. sensors, 16(8):1222, 2016. ",
+        "bbox": [
+            173,
+            523,
+            825,
+            551
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Amaia Salvador, Miriam Bellver, Victor Campos, Manel Baradad, Ferran Marques, Jordi Torres, and Xavier Giro-i Nieto. Recurrent neural networks for semantic instance segmentation. arXiv preprint arXiv:1712.00617, 2017. ",
+        "bbox": [
+            173,
+            559,
+            825,
+            598
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shuai Shao, Zeming Li, Tianyuan Zhang, Chao Peng, Gang Yu, Xiangyu Zhang, Jing Li, and Jian Sun. Objects365: A large-scale, high-quality dataset for object detection. In Proceedings of the IEEE/CVF international conference on computer vision, pp. 8430–8439, 2019. ",
+        "bbox": [
+            176,
+            608,
+            823,
+            648
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Russell Stewart, Mykhaylo Andriluka, and Andrew Y Ng. End-to-end people detection in crowded scenes. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2325–2333, 2016. ",
+        "bbox": [
+            171,
+            656,
+            823,
+            684
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pei Sun, Henrik Kretzschmar, Xerxes Dotiwalla, Aurelien Chouard, Vijaysai Patnaik, Paul Tsui, James Guo, Yin Zhou, Yuning Chai, Benjamin Caine, et al. Scalability in perception for autonomous driving: Waymo open dataset. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2446–2454, 2020. ",
+        "bbox": [
+            176,
+            693,
+            823,
+            744
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems, pp. 3104–3112, 2014. ",
+        "bbox": [
+            171,
+            753,
+            823,
+            781
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Alexander Toshev, and Dumitru Erhan. Deep neural networks for object detection. 2013. ",
+        "bbox": [
+            174,
+            789,
+            813,
+            804
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhi Tian, Chunhua Shen, Hao Chen, and Tong He. Fcos: Fully convolutional one-stage object detection. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 9627–9636, 2019. ",
+        "bbox": [
+            173,
+            813,
+            821,
+            840
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017. ",
+        "bbox": [
+            173,
+            848,
+            825,
+            888
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Łukasz Kaiser, Terry Koo, Slav Petrov, Ilya Sutskever, and Geoffrey Hinton. Grammar as a foreign language. Advances in Neural Information Processing Systems, 28:2773–2781, 2015a. ",
+        "bbox": [
+            171,
+            897,
+            826,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Alexander Toshev, Samy Bengio, and Dumitru Erhan. Show and tell: A neural image caption generator. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3156– 3164, 2015b. ",
+        "bbox": [
+            173,
+            104,
+            825,
+            142
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yuxin Wu, Alexander Kirillov, Francisco Massa, Wan-Yen Lo, and Ross Girshick. Detectron2. https: //github.com/facebookresearch/detectron2, 2019. ",
+        "bbox": [
+            173,
+            151,
+            823,
+            179
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhudinov, Rich Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In International Conference on Machine Learning, pp. 2048–2057. PMLR, 2015. ",
+        "bbox": [
+            176,
+            188,
+            823,
+            227
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Xingyi Zhou, Dequan Wang, and Philipp Krahenb ¨ uhl. Objects as points. ¨ arXiv preprint arXiv:1904.07850, 2019. ",
+        "bbox": [
+            176,
+            234,
+            823,
+            261
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A QUANTIZATION AND DEQUANTIZATION OF COORDINATES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            686,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 and 2 illustrate the quantization and dequantization process of (normalized) coordinates. ",
+        "bbox": [
+            171,
+            141,
+            823,
+            156
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Quantization of (normalized) coordinates ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            190,
+            482,
+            217
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Dequantization of discrete tokens of coordinates ",
+        "text_level": 1,
+        "bbox": [
+            516,
+            190,
+            823,
+            215
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "def quantize(x, bins $= 1 0 0 0 ;$ ): # x is a real number between [0, 1] # returns an integer between [0, bins-1] return int(x \\* (bins - 1)) ",
+        "bbox": [
+            174,
+            226,
+            478,
+            265
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "def dequantize(x, bins=1000): # x is an integer between [0, bins-1] # returns a real number between [0, 1] return float(x) / (bins - 1) ",
+        "bbox": [
+            517,
+            226,
+            805,
+            265
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            306,
+            370,
+            321
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Training from scratch on COCO For baseline architectures, we follow (Carion et al., 2020) using a ResNet backbone (He et al., 2016), followed by 6 layers of transformer encoder and 6 layers of (causal) transformer decoder (Vaswani et al., 2017). The main dimension of transformer is set to 256 with 8 attention heads, and the dimension of the feed-forward network is set to 1024. We use the stochastic depth (Huang et al., 2016) with a rate of $10 \\%$ to reduce overfitting. Per (Carion et al., 2020), we also experiment with the DC5 variant of ResNet (Li et al., 2017), which increases the resolution of its output feature map by a factor of two.2 ",
+        "bbox": [
+            173,
+            344,
+            825,
+            443
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For image augmentation during training, we perform scale jittering with random crops (Ghiasi et al., 2021; Wu et al., 2019) with strength of [0.1, 3]. We resize images (with a fixed aspect ratio) so the longer side is 1333 pixels. Following (Howard, 2013; Chen et al., 2020a;b), we also use color distortion with a strength of 0.5. For sequence construction, we use 2000 quantization bins, and we randomize the order of objects every time an image is shown. We append noise objects to real objects such that each image contains 100 objects in total, and hence a sequence length of 500. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            534
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We train the entire network from scratch for 300 epochs with a batch size of 128. For each image in a mini-batch, we perform two independent augmentations, similar to (Hoffer et al., 2020), resulting in a 256 effective batch size, which we find helpful to reduce overfitting. We use AdamW optimizer (Kingma & Ba, 2014; Loshchilov & Hutter, 2018) with a learning rate of 0.003 and weight decay of 0.05. We use a learning rate warmup for 10 epochs and then linearly decay the learning rate over the course of training. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            625
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Pretraining on Objects365 We explore a wider range of architecture variants including both hybrid ResNet and transformer models (Carion et al., 2020), as well as pure transformers based on image patches (Dosovitskiy et al., 2020). The details of the architecture can be found in our released code. Since Objects365 dataset is much larger than COCO (1.7M images vs 118K images), we use a weaker image augmentation (scale jittering range of [0.3, 2] for ViT backbones, and [0.9, 1.2] for ResNet backbones) without color distortion. For sequence construction, we use 1000 quantization bins. And we still apply sequence augmentation with sampled noise objects added by default. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            751
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We use a smaller image size of $6 4 0 \\times 6 4 0$ , and pretrain the models for 400K steps with batch size of 256. We do not perform two augmentations per batch as in training from scratch. And we use a smaller learning rate of 0.001 with the same weight decay of 0.05. We use a cosine learning rate decay with a initial warmup of 20K steps. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            813
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "As for the finetuning on COCO dataset, we use a batch size of 128 for ResNet backbones, and 64 for ViT backbones. Most models are finetuned for 60 epochs with a learning rate of $3 e ^ { - 5 }$ , but even fewer epochs yield similar results. We still use scale jittering with a range of [0.3, 2] for image augmentation. ",
+        "bbox": [
+            174,
+            819,
+            823,
+            876
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Nucleus sampling (Holtzman et al., 2019) has been applied to language modeling to reduce duplication and increase diversity in generated samples. Here we study its impact on sampling from our trained model. ",
+        "bbox": [
+            174,
+            132,
+            823,
+            175
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Given the distribution $P ( \\pmb { y } _ { j } | \\pmb { x } , \\pmb { y } _ { 1 : j - 1 } )$ , to apply nucleus sampling, we first define its top- $p$ vocabulary $V ^ { ( p ) } \\subset V$ as the smallest set such that ",
+        "bbox": [
+            174,
+            181,
+            823,
+            212
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7ba6bfd55dbe3a83edc48313de26f72ced83376297e5b3c473fa28144f71486c.jpg",
+        "text": "$$\n\\sum _ { { \\pmb y } _ { j } \\in V ^ { ( p ) } } P ( { \\pmb y } _ { j } | { \\pmb x } , { \\pmb y } _ { 1 : j - 1 } ) \\geq p .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            214,
+            599,
+            251
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Let $\\begin{array} { r } { p ^ { \\prime } = \\sum _ { { \\pmb y } _ { j } \\in V ^ { ( p ) } } P \\big ( { \\pmb y } _ { j } | { \\pmb x } , { \\pmb y } _ { 1 : j - 1 } \\big ) } \\end{array}$ , and we can re-calibrate the conditional likelihood as following for sampling the next token. ",
+        "bbox": [
+            173,
+            256,
+            825,
+            286
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/45a01c13e0bec24ef4d535871a22d48fbe785d087c9a88acb26df7ca724b2b89.jpg",
+        "text": "$$\nP ^ { \\prime } ( { y } _ { j } | { x } , { y } _ { 1 : j - 1 } ) = \\left\\{ \\begin{array} { l l } { P ( { y } _ { j } | { x } , { y } _ { 1 : i - 1 } ) / p ^ { \\prime } } & { \\mathrm { i f } { y } _ { j } \\in V ^ { ( p ) } } \\\\ { 0 } & { \\mathrm { o t h e r w i s e . } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            291,
+            686,
+            327
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We vary the hyper-parameter $p$ of nucleus sampling used in generating the output sequence (during inference). When $p = 0$ , it corresponds to arg max sampling, otherwise it samples from a truncated ranked list of tokens that has a cumsum larger or equal to $p$ . In Figure 10, we see that use of nucleus sampling (with $p > 0$ ) improves object recall and thus also leads to better average precision. There is a relatively flat region of AP between 0.2 and 0.5, and we select $p$ to be 0.4 as our default value for other experiments. ",
+        "bbox": [
+            173,
+            337,
+            825,
+            421
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/414025bf3a55a11ab0e93ae0f5c468d32d930d45b00ee10a7156bd881b95e784.jpg",
+        "image_caption": [
+            "Figure 10: Varying parameter $p$ in nucleus sampling during inference results in different AP and AR. With $p = 0$ , it is equivalent to argmax sampling. Sampling with $p > 0$ is helpful for increasing recall (and precision). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            436,
+            766,
+            566
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D VISUALIZATION OF SIMILARITY AMONG COORDINATE TOKENS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            654,
+            730,
+            670
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In our model, bounding box coordinates are not represented as floating points, but encoded as discrete tokens. Here we study the similarity among these coordinate tokens via their embeddings. Note that the discrete coordinate tokens and class name tokens are in the same vocabulary and share the same embedding matrix. Specifically, we first slice the learned embedding matrix corresponding to coordinate tokens, and then compute the cosine similarity of embedding vectors for these coordinate tokens. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            767
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Figure 11 shows cosine similarity among embeddings of coordinate tokens. We can see that nearby coordinates have higher similarities in their token embeddings than far away ones. This emergent property of our model is likely due to the noises / uncertainties in bounding box annotations (i.e. a bounding box annotation is a random sample from a distribution over potential bounding boxes which encodes locality of coordinates). ",
+        "bbox": [
+            173,
+            773,
+            825,
+            844
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "E THE ABILITY TO DIRECT THE ATTENTION WITH GIVEN COORDINATES ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            864,
+            782,
+            881
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We explore the model’s ability to pay attention to a pointed region specified via coordinates. We divide an image evenly into an $N \\times N$ grid of rectangular regions, each specified by a sequence of coordinates for its bounding box. We then visualize the decoder’s cross attention to visual feature map after reading the sequence of coordinates for each region, i.e., $[ y _ { \\mathrm { m i n } } , x _ { \\mathrm { m i n } } , y _ { \\mathrm { m a x } } , x _ { \\mathrm { m a x } } ]$ . We shuffle the pixels in the image to remove distraction from existing objects, and remove $2 \\%$ of the top attentions for clarity. Interestingly, as shown in Figure 12, it seems the model can pay attention to the specified region at different scales. ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/ada0a81261f79af4274cd8070ea4644893860bc799707def502632d81544ef86.jpg",
+        "image_caption": [
+            "Figure 11: (a) Cosine similarity among embeddings of coordinate tokens. (b) is part of (a) covering only the first 100 tokens. (c), (d) and (e) are the 500-th, 1000-th and 1500-th rows of (a), respectively. Nearby coordinates have higher similarities in their token embeddings. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            108,
+            787,
+            454
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            535,
+            825,
+            604
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/8df80ab15eb6133d3310161f53e2d79c25285c1d507b8829df00a3ee03862a35.jpg",
+        "image_caption": [
+            "Figure 12: Each grid is a visualization of decoder’s attention after reading a small sequence of coordinates, i.e., $[ y _ { \\mathrm { m i n } } , x _ { \\mathrm { m i n } } , y _ { \\mathrm { m a x } } , x _ { \\mathrm { m a x } } ]$ . Visualization is done for grids of different sizes. The network learns to pay attention to pointed region at different scales. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            622,
+            818,
+            762
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "F MORE VISUALIZATION ON DECODER’S CROSS ATTENTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            849,
+            686,
+            864
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In Figure 13, we overlay the cross attention (when predicting the class token) on the original image for several other images, and it shows that the decoder pays the most attention to the object when predicting the class token. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/43d57fc78b5add04ed0233299e489eb3c616d386dbeced06c84348ea760879cc.jpg",
+        "image_caption": [
+            "Figure 13: Visualization of Transformer decoder’s cross attention (when predicting class tokens) conditioned on the given bounding boxes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            104,
+            807,
+            223
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "G VISUALIZATION OF DETECTION RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            290,
+            550,
+            305
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "In Figure 14, we visualize detection results of one of Pix2seq model (with 46 AP) on a subset of images from COCO validation set that contain a crowded set of objects. ",
+        "bbox": [
+            174,
+            320,
+            825,
+            349
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/b8c017b7082ef97864a53727ec5da2c581eb1e71521f273f41c1c1ed91390ef1.jpg",
+        "image_caption": [
+            "Figure 14: Examples of the model’s predictions (at the score threshold of 0.5). Original images accessed by clicking the images in supported PDF readers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            363,
+            816,
+            859
+        ],
+        "page_idx": 16
+    }
+]

parse/dev/tGbpgz6yOrI/tGbpgz6yOrI_content_list.json

@@ -0,0 +1,1542 @@
+[
+    {
+        "type": "text",
+        "text": "R3M: A Universal Visual Representation for Robot Manipulation ",
+        "text_level": 1,
+        "bbox": [
+            251,
+            102,
+            746,
+            154
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Suraj $\\mathbf { N a i r ^ { 1 , * } }$ , Aravind Rajeswaran2, Vikash Kumar2, Chelsea $\\mathbf { F i n n ^ { 1 } }$ , Abhinav Gupta2 ",
+        "bbox": [
+            199,
+            178,
+            800,
+            195
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Stanford University, 2Meta AI ",
+        "bbox": [
+            397,
+            200,
+            602,
+            215
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract: We study how visual representations pre-trained on diverse human video data can enable data-efficient learning of downstream robotic manipulation tasks. Concretely, we pre-train a visual representation using the Ego4D human video dataset using a combination of time-contrastive learning, video-language alignment, and an L1 penalty to encourage sparse and compact representations. The resulting representation, R3M, can be used as a frozen perception module for downstream policy learning. Across a suite of 12 simulated robot manipulation tasks, we find that R3M improves task success by over $2 0 \\%$ compared to training from scratch and by over $1 0 \\%$ compared to state-of-the-art visual representations like CLIP and MoCo. Furthermore, R3M enables a Franka Emika Panda arm to learn a range of manipulation tasks in a real, cluttered apartment given just 20 demonstrations. ",
+        "bbox": [
+            233,
+            239,
+            766,
+            405
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Keywords: Visual Representation Learning, Robotic Manipulation ",
+        "bbox": [
+            235,
+            421,
+            673,
+            436
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            455,
+            312,
+            473
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "How do we train a robot to complete a manipulation task from images? A standard and widely used approach is to train an end-to-end model from scratch using data from the same domain [1]. However, this can be prohibitively data intensive and severely limits generalization. In contrast, computer vision and natural language processing (NLP) have recently taken a major departure from this “tabula rasa” paradigm. These fields have focused on using diverse, large-scale datasets to build reusable, pre-trained representations. Such models have become ubiquitous; for example, visual representations from ImageNet [2] can be reused for tasks like cancer detection [3], and pre-trained language embeddings like BERT [4] have been used for everything from medical coding [5] to visual question answering [6]. Such an equivalent of an ImageNet [2] or BERT [4] model for robotics, that can be readily downloaded and used for any downstream simulation or real-world manipulation task, has remained elusive. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            650
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Why have we struggled in building this universal representation for robotics? Our conjecture is that we haven’t converged on using the appropriate datasets for robotics. Collecting large and diverse datasets of robots interacting with the physical world can be costly, even without human annotation. Recent attempts at creating such datasets [7, 8, 9, 10], consist of a limited number of tasks in at most a handful of different environments. This lack of diversity and scale makes it difficult to learn representations that are broadly applicable. At the same time, the recent history of computer vision and NLP suggests an alternate route for robotics. The best representations in these fields did not arise out of task-specific and carefully curated datasets, but rather the use of abundant in-the-wild data [4, 11, 12, 13]. Analogously, for robotics and motor control, we have access to videos of humans interacting in semantically interesting ways with their environments [14, 15, 16]. This data is large and diverse, spanning scenes across the globe, and tasks ranging from folding clothes to cooking a meal. While the embodiment present in this data differs from most robots, prior work [17, 18] has found that such human video data can still be useful for learning reward functions. Furthermore, domain gap has not been a major barrier for using pre-trained representations in traditional vision and NLP tasks. In this backdrop, we ask the pertinent question: can visual representations pre-trained on diverse human videos enable efficient downstream learning of robotic manipulation skills? ",
+        "bbox": [
+            174,
+            659,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/a27b2b5e1fbf16cfc1be41aa6486a67ba25e3b2c09ecf54fc9edf13aa8f1f7ee.jpg",
+        "image_caption": [
+            "Figure 1: Pre-Training Reusable Representations for Robot Manipulation (R3M): We pre-train a visual representation using diverse human video datasets like Ego4D [16], and study its effectiveness for downstream robot manipulation tasks. Our representation model, R3M, is trained using a combination of time-contrastive learning, video-language alignment, and an L1 sparsity penalty. We find that R3M enables data efficient imitation learning across several simulated and real-world robot manipulation tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            92,
+            821,
+            231
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We hypothesize that a good representation for vision-based robotic manipulation consists of three components. First, it should contain information necessary for physical interaction, and thus should capture the temporal dynamics of the scene (i.e. how states might transition to other states). Second, it should have a prior over semantic relevance, and should focus on task relevant features like objects and their relationships. Finally, it should be compact, and not include features irrelevant to the above criteria (e.g. backgrounds). Towards satisfying these three criteria, we study a representation learning approach that combines (1) time contrastive learning [19] to learn a representation that captures temporal dynamics, (2) video-language alignment to capture semantically relevant features of the scene, and (3) L1 and L2 penalties to encourage sparsity. Our experimental evaluation in Section 4.4 finds that all three components are important for training highly performant representations. ",
+        "bbox": [
+            174,
+            324,
+            825,
+            474
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work we empirically demonstrate that representations pre-trained on diverse human video datasets like Ego4D [16] can enable efficient downstream policy learning for robotic manipulation. Our core contribution is an artifact – the pre-trained vision model – that can be used readily in other work. Concretely, we pre-train a reusable representation for robotic manipulation (R3M), which can be used as a frozen perception module for downstream policy learning in simulated and real robot manipulation tasks. We demonstrate this via extensive experimental results across three existing benchmark simulation environments (Adroit [20], Franka-Kitchen [21], and MetaWorld [22]) as well as real robot experiments in a cluttered apartment setting. R3M features outperform a wide range of visual representations like CLIP [12], (supervised) ImageNet [2], MoCo [23, 24], and learning from scratch by over $10 \\%$ when evaluated across 12 tasks, 9 viewpoints, and 3 different simulation environments. On a Franka Emika Panda robot, R3M enables learning challenging tasks like putting lettuce in a pan and folding a towel with a $50 \\%$ average success rate, given less than 10 minutes of human demonstrations (see Figure 1), which is nearly double the success rate compared to CLIP features. Overall, on the basis of these results, we believe that R3M has the potential to become a standard vision model for robot manipulation, which can be simply downloaded and used off-the-shelf for any robot manipulation task or environment. See https: //sites.google.com/view/robot-r3m for pre-trained models and code. ",
+        "bbox": [
+            174,
+            482,
+            825,
+            737
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            756,
+            321,
+            773
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Representation Learning for Robotics. Our work is certainly not the first to study the problem of learning general representations for robotics. One line of work focuses on learning representations from in-domain data, that is, using data from the target environment and task for training the representation. Such methods include contrastive learning with data augmentation [25, 26, 27, 28], dynamics prediction [29, 30], bi-simulation [31], temporal or goal distance [32, 33], or domain specific information [34]. However, because they are trained on data exclusively from the target domain and task, the learned representations fail to generalize and cannot be re-used to enable faster learning in unseen tasks and environments. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, there has been growing interest in learning more general representations for motor control from large-scale out-of-domain data like images from the web. This includes the use of CLIP, supervised MS-COCO, supervised ImageNet, MoCo ImageNet features, or data from different robots [35, 36, 37, 38, 23, 39]. In contrast to prior work, we pre-train the representation using diverse human video and language data, as opposed to static frames and/or class labels. Further, in our experimental evaluation, we observe that our pre-trained representation outperforms prior work significantly on a comprehensive evaluation suite. Concurrently, Xiao et al. [40] also explore the use of human interaction data to pre-train visual representations for motor control. However their learned representation only uses static frames from these videos and does not utilize temporal or semantic information like R3M. Furthermore, our evaluation focuses on data efficient imitation learning, and enables real-world learning in cluttered environments with just $\\sim 1 0$ minutes of demonstration data. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            257
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Leveraging Human Videos for Robot Learning. Several prior works have explored using human video data in robot learning, for example to acquire goals [41, 42, 43], to learn visual dynamics models [44, 45, 46, 47], or to learn representations and rewards [19, 48, 49, 50, 51, 52]. However, these prior works typically focus on a small dataset of human videos closely resembling the robot environment. In contrast, our work leverages diverse human video data like Ego4D [16] to learn visual reusable visual representations that generalize broadly. ",
+        "bbox": [
+            173,
+            263,
+            825,
+            354
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Natural Language and Robotic Manipulation. Prior works have explored the use of natural language in robot manipulation, primarily as a means of task specification [53, 54, 36, 55] or reward learning [56]. In contrast, we use diverse human video data and language annotations to learn reusable visual representations for control. Prior work has also found visual representations informed by language, like CLIP [12], to be effective for control [36, 37]. Through empirical evaluations, we find that our R3M representation substantially outperforms CLIP for robot manipulation. ",
+        "bbox": [
+            173,
+            361,
+            825,
+            452
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Learning from Diverse Robot Data. Towards robots that generalize more broadly, there are a number of works that study how to scale up the size and diversity of data robots learn from. Many of these works focus on collecting and learning from robot data itself [57, 58, 7, 8, 9, 10, 59]. However, these works often contain at most a handful of different environments, making generalization across a range of unseen scenes difficult. While we also aim to enable generalization by learning from diverse data, our focus is instead on (1) learning from human video data and hence a larger distribution of environments and tasks, and (2) pre-training a visual representation, as opposed to policies or models. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            564
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Representation Learning from Videos. Finally, there is a rich literature of works that study learning image representations from videos [60, 61, 19, 62, 63, 64] outside of the context of robotics. Additionally, there are a number of works that use language to learn representations from videos [65, 66]. Critically, unlike all of these works, the main contribution of this work is not to propose a novel representation learning approach, but rather in studying if representations trained on diverse video and language of human interaction can enable more efficient learning of robotic manipulation. ",
+        "bbox": [
+            174,
+            571,
+            826,
+            662
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 R3M: Reusable Representations for Robotic Manipulation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            674,
+            692,
+            693
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to use diverse human video data to pre-train a single reusable visual representation for motor control, particularly robotic manipulation, that can enable efficient downstream learning in previously unseen environments and tasks. In this section, we cover the different components of our approach, beginning by describing our problem formulation in Section 3.1, the data sources we use in Section 3.2, and our training objective in Section 3.3. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            777
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            795,
+            307,
+            810
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Formally, we assume that we have access to a dataset $\\mathcal { D }$ of $N$ videos, where each video consists of a sequence of RGB frames $[ I _ { 0 } , I _ { 1 } , . . . , I _ { T } ]$ . Additionally, we assume that each video is paired with a natural language description $l$ , that describes what task is being completed in the video. From this data, our goal is to learn a single image encoder $\\mathcal { F } _ { \\phi }$ , that maps images to a deterministic, continuous embedding, that is $z = \\mathcal { F } _ { \\phi } ( I )$ . Once trained, we want to be able to repeatedly reuse $\\mathcal { F }$ for downstream policy learning. Specifically, the downstream problem will involve an agent sequentially choosing actions given image observations $I$ , and instead of using raw images as input, the agent will use the pre-trained ${ \\mathcal { F } } _ { \\phi } ( I )$ as a state representation. ",
+        "bbox": [
+            174,
+            820,
+            825,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/4ff39fbcdeffd4b029e257b88a5411828ad47288a77ce7e56a2d711d54a0a8bc.jpg",
+        "image_caption": [
+            "Figure 2: Ego4D [16] Video and Language (left). Sample frames and associated language from Grauman et al. [16] used for training R3M. R3M Training (right). We train R3M with time contrastive learning, encouraging states closer in time to be closer in embedding space and video-language alignment to encourage the embeddings to capture semantically relevant features. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            88,
+            790,
+            271
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            330,
+            820,
+            361
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Data Sources ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            371,
+            305,
+            386
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For our learned representation $\\mathcal { F } _ { \\phi }$ to be useful in a wide range of downstream tasks and environments, it should (1) be trained on data that is diverse enough to facilitate generalization, and (2) provide a useful signal for features relevant to robotic manipulation. One approach would be to be use natural images off the web (e.g. ImageNet [2]). While diverse, these images tend to focus on one particular object, and do not capture an agent interacting with multiple objects in a scene. Alternatively, data of humans interacting in the world [14, 65, 16] is both diverse and contains useful interaction in scenes similar to those we would like robots to interact in. Of the many human video datasets, we leverage the Ego4D dataset [16] due to it’s diversity and size, although in principle our method can be used on any suitable video dataset. Ego4D contains videos of people engaging in a wide range of tasks from cooking to socializing to assembling objects from more than 70 locations across the globe, and in total contains more than 3500 hours of data. Each video clip also contains a natural language annotation describing the behavior of the person in the video (See Figure 2 (left)). ",
+        "bbox": [
+            173,
+            391,
+            826,
+            573
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 Training R3M ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            582,
+            316,
+            598
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "What should a good representation for robotic manipulation from human video data capture? We propose three key components: (1) it should capture temporal dynamics, as the agent will be sequentially interacting in the environment to accomplish tasks, (2) it should capture semantically relevant features, and (3) it should be compact. We next describe how we use time contrastive learning to capture (1), video-language alignment for (2), and the use of L1 regularization to encourage (3). See Figure 2 (right) for an overview of our training objective. ",
+        "bbox": [
+            173,
+            603,
+            825,
+            694
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Time Contrastive Learning. To encourage $\\mathcal { F } _ { \\phi }$ to capture features relevant to physical interaction and sequential decision making, the first part of our objective is a time contrastive loss [61]. Given a batch of videos we train the encoder to produce a representation such that the distance between images closer in time is smaller than for images farther in time or from different videos. Specifically, we sample a batch of sequences of frames $[ I _ { i } , I _ { j > i } , I _ { k > j } ] ^ { 1 : B }$ , then minimize the InfoNCE loss [67]: ",
+        "bbox": [
+            173,
+            700,
+            825,
+            777
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a89545bab2818da43c733750a5f6281ebf7faa938bdde3e62df90c9de994a395.jpg",
+        "text": "$$\n\\mathcal { L } _ { t c n } = - \\sum _ { b \\in B } \\log \\frac { e ^ { S ( z _ { i } ^ { b } , z _ { j } ^ { b } ) } } { e ^ { S ( z _ { i } ^ { b } , z _ { j } ^ { b } ) } + e ^ { S ( z _ { i } ^ { b } , z _ { k } ^ { b } ) } + e ^ { S ( z _ { i } ^ { b } , z _ { i } ^ { \\ne b } ) } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            784,
+            671,
+            827
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $z = \\mathcal { F } _ { \\phi } ( I )$ , and $z _ { i } ^ { \\neq b }$ is a negative example sampled from a different video in the batch. $s$   \ndenotes a measure of similarity, which in our case is implemented as the negative L2 distance. ",
+        "bbox": [
+            174,
+            843,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Video-Language Alignment. To encourage $\\mathcal { F } _ { \\phi }$ to capture semantically relevant features, we train a language prediction module from the embedding outputted by $\\mathcal { F } _ { \\phi }$ . Essentially, by capturing features predictive of language, like “putting the apple on the plate”, the learned representation should capture semantically relevant parts of the scene like the plate and apple state, that are likely relevant to downstream manipulation tasks. Following Nair et al. [56], we train a model $\\mathcal { G } _ { \\theta } ( \\mathcal { F } _ { \\phi } ( I _ { 0 } ) , \\mathcal { F } _ { \\phi } ( I _ { i } ) , l )$ that takes in an initial image $I _ { 0 }$ , a future image $I _ { i }$ , language $l$ and outputs a score corresponding to if transitioning from $I _ { 0 }$ to $I _ { i }$ completes the language $l$ . We train the model under the objective that (1) the score should increase over the course of the video, and (2) the score should be higher for correct pairings of video/language than for incorrect pairings. Again we sample a video clip and paired language $[ I _ { i } , I _ { j > i } , l ] ^ { 1 : B }$ , and then train for this objective directly with a contrastive loss, that is: ",
+        "bbox": [
+            174,
+            881,
+            821,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            826,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d6dca46863acc31545c1af1a2e84b47713ecdd7ef5cfb257ae6cae588a60c4eb.jpg",
+        "text": "$$\n\\mathcal { L } _ { l a n g u a g e } = - \\sum _ { b \\in B } \\log \\frac { e ^ { \\mathcal { G } _ { \\theta } ( z _ { 0 } ^ { b } , z _ { j > i } ^ { b } , l ^ { b } ) } } { e ^ { \\mathcal { G } _ { \\theta } ( z _ { 0 } ^ { b } , z _ { j > i } ^ { b } , l ^ { b } ) } + e ^ { \\mathcal { G } _ { \\theta } ( z _ { 0 } ^ { b } , z _ { i } ^ { b } , l ^ { b } ) } + e ^ { \\mathcal { G } _ { \\theta } ( z _ { 0 } ^ { \\ne b } , z _ { j > i } ^ { \\ne b } , l ^ { b } ) } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            219,
+            732,
+            262
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where again $z = \\mathcal { F } _ { \\phi } ( I )$ , and $z ^ { \\neq b }$ is a negative example sampled from a different video in the batch (that does not match the language instruction $l ^ { b }$ ). ",
+        "bbox": [
+            174,
+            271,
+            825,
+            301
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Regularization. Finally, we hypothesize that sparse and compact representations benefit control, particularly in low data imitation learning. State-distribution shift is a well studied failure mode in imitation learning [68], where policies trained with behavior cloning drift off the expert state distribution. Reducing the effective dimensionality of the state space (which we implement with a simple L1 and L2 penalty) can help mitigate this issue, as we demonstrate in Section 4.4. ",
+        "bbox": [
+            174,
+            308,
+            825,
+            385
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "R3M Summary $\\pmb { \\& }$ Implementation. The final objective for training R3M is the weighted sum: ",
+        "bbox": [
+            171,
+            390,
+            802,
+            406
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/231fd6a49833e842e56b0b9bd5560f64016457b1261388b4dd75be14e5cf8b1f.jpg",
+        "text": "$$\n\\mathcal { L } ( \\phi , \\theta ) = \\mathbb { E } _ { I _ { 0 } ^ { 1 ; B } , \\theta , \\boldsymbol { k } \\sim \\mathcal { D } } [ \\lambda _ { 1 } \\mathcal { L } _ { t c n } + \\lambda _ { 2 } \\mathcal { L } _ { l a n g u a g e } + \\lambda _ { 3 } | | \\mathcal { F } _ { \\phi } ( I _ { i } ) | | _ { 1 } + \\lambda _ { 4 } | | \\mathcal { F } _ { \\phi } ( I _ { i } ) | | _ { 2 } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            414,
+            759,
+            435
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In principle, R3M can be implemented on top of any encoding architecture for $\\mathcal { F } _ { \\phi }$ . In our experiments we focus on the ResNet50 architecture, and we release pre-trained R3M models with ResNet18, ResNet34, and ResNet50 architectures [69], as well as the accompanying training code. During training, $\\phi$ and $\\theta$ are trained with an Adam optimizer to minimize Equation 3. Lastly, R3M also trains with random cropping, applied at the video level (that is, within a batch all frames from the same video are cropped identically). Please see the appendix for further implementation details. ",
+        "bbox": [
+            173,
+            441,
+            825,
+            534
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            542,
+            313,
+            560
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we aim to study how the pre-trained R3M representation can be re-used for multiple downstream robot learning tasks. First, we study if R3M enables more data efficient imitation learning on unseen environments and tasks compared to existing visual representations and learning from scratch. Second, again in the data efficient imitation learning setting, we ablate the different components of the R3M training objective and observe that all components are important for final performance. Third, we study if R3M can enable efficient real robot learning in a visually rich household setting. Finally, in the appendix, we take a deeper look at task performance of R3M and prior methods with different amounts of data, different camera viewpoints, and different tasks. ",
+        "bbox": [
+            173,
+            566,
+            826,
+            689
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Imitation Learning Evaluation Framework ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            700,
+            513,
+            715
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our evaluation methodology is loosely inspired by Parisi et al. [23]. We focus on evaluating visual representations as frozen perception modules for downstream policy learning with behavior cloning. Given a pretrained visual representation $\\mathcal { F } _ { \\phi }$ , we form the state representation as a concatenation of the visual embedding $z _ { t } = \\mathcal { F } _ { \\phi } ( I _ { t } )$ and the robot proprioceptive (e.g. joint positions and velocities) reading $p _ { t }$ . The policy, $\\pi$ , is trained with a standard behavior cloning loss $| | a _ { t } - \\pi ( [ z _ { t } , p _ { t } ] ) | | _ { 2 } ^ { 2 }$ . We parameterize $\\pi$ as a two-layer MLP preceded by a BatchNorm at the input. We train the agent for 20,000 steps, evaluate it online in the environment every 1000 steps, and report the best success rate achieved. For each visual representation and each task, we run 3 seeds of behavior cloning. The final success rate reported on a task is the average over multiple seeds, viewpoints, and demo dataset sizes. ",
+        "bbox": [
+            173,
+            723,
+            826,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Comparisons and Baselines. We compare our R3M model to three existing visual representations that have been shown to be effective for control: CLIP [12] which trains image representations to be aligned with paired natural language through contrastive learning and has been shown to be useful for some manipulation [36] and navigation tasks [37], ImNet Supervised which uses features pre-trained for ImageNet classification task [2] and has been shown to be effective for reinforcement learning [38], and MoCo (345) (PVR) [23], which compresses and fuses the third, fourth, and fifth convolutional layers of a ResNet-50 model trained with MoCo [24] on ImageNet, and has been shown to be effective for imitation learning [23]. We note here that our usage of the Moco (345) model differs from the setup in Parisi et al. [23] in aspects like propreoception features, frame stacking etc. As a result, the numerical results are not directly comparable across the two works. At the same time, we emphasize that all visual representations are used in the same way within our evaluation protocol. ",
+        "bbox": [
+            174,
+            866,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/79a21c838d560defeb4a965972e1188e57d21a2e6be3a512c7254c7e8cd2b130.jpg",
+        "image_caption": [
+            "Figure 3: Simulated Evaluation Environments. We consider a comprehensive set of manipulation tasks in simulation (left), including 5 tasks with a Sawyer from MetaWorld [22], 5 tasks from a Franka operating over a Kitchen [21], and 2 dexterous manipulation tasks from Adroit [20], with multiple views per environment (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            92,
+            805,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            290,
+            826,
+            411
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Simulation Environments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            426,
+            390,
+            440
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Next, we describe the environments and tasks used in our evaluations. For a comprehensive evaluation, we use three robot manipulation domains: MetaWorld [22], the Franka Kitchen environment [21], and Adroit [20] (See Figure 3). Note these environments are only used for downstream learning, and these environments and tasks are never seen during R3M training. In the MetaWorld environment we consider the tasks of assembling a ring onto a peg, picking and placing a block between bins, pushing a button, opening a drawer, and hammering a nail. In Franka Kitchen, we learn the tasks of sliding the right door open, opening the left door, turning on the light, turning the stove top knob, and opening the microwave. Finally, in Adroit we consider the tasks of reorienting the pen to the specified position, and picking and moving the ball to specified position. In all tasks, the agent is provided with image observations, as well as proprioceptive data of the robot (end-effector pose, joint positions, etc.) that is concatenated to the encoded image. All tasks involve variation, either by varying the position of the target object in MetaWorld, the positioning of the desk in Franka Kitchen, or the chosen goals in Adroit. For a robust evaluation, we consider multiple views for each environment (See Figure 3), and 3 dataset sizes: [5, 10, 25] in MetaWorld and Franka Kitchen, and [25, 50, 100] in the more challenging Adroit environments. Our comparisons measure performance for each environment and task, averaged over view, dataset size, and object or goal positions. ",
+        "bbox": [
+            174,
+            450,
+            826,
+            691
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Exp. 1: Does R3M enable efficient imitation on unseen environments and tasks? ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            707,
+            764,
+            722
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this first experiment, we measure the success rate of downstream imitation learning using different visual representations. In Figure 4, we first notice that R3M is overall able to learn these vision based manipulation tasks in an extremely low data regime with ${ \\approx } 6 2 \\%$ success rate, despite never seeing any data from the target environments in training the representation, while outperforming learning from scratch by more than $20 \\%$ . Moreover, we observe that R3M outperforms all prior representations by more than $10 \\%$ on average across all 12 tasks. By training on diverse interactive video data, and with objectives that capture temporal structure and language relevance, R3M is the best performing method in all 3 environments, and on 11/12 of the tasks (See appendix for performance breakdown by task). The best two performing comparisons are CLIP and MoCo (345) (PVR), with CLIP performing better on MetaWorld, and MoCo (345) (PVR) performing better on Franka Kitchen and Adroit. Unsurprisingly, learning from scratch performs poorly in the low-data regime we study. Ultimately, we conclude that pre-trained visual representations are essential to good performance in the low-data imitation learning regime, and using R3M with diverse human video data is especially effective for learning representations useful for robotic manipulation. ",
+        "bbox": [
+            173,
+            731,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/a16beebd0a9d2dddef3f5253dfafb27355ef1299f637f58e63b50fe980bb2a2f.jpg",
+        "image_caption": [
+            "Figure 4: Data Efficient Imitation Learning in Unseen Environments/Tasks. We report the success rates of downstream imitation learning with standard error bars. We observe that across 12 tasks R3M outperforms baselines like MoCo (345) (PVR), CLIP, Supervised ImageNet features, and training from scratch. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            89,
+            784,
+            233
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            279,
+            823,
+            309
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we seek to understand the different components of R3M, beginning with the objective. Specifically, we compare the full R3M with R3M(-Aug), which does not use crop augmentations, R3M(-L1), which does not include $L 1$ regularization, and R3M(-Lang), which does not include include the ",
+        "bbox": [
+            173,
+            339,
+            356,
+            520
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/03e353e40424e62c3be3460fa6b83bde578578129ddf437f24a104f819f344c0.jpg",
+        "table_caption": [
+            "4.4 Exp. 2: Which components of R3M are important? "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Environment</td><td colspan=\"3\">Supervised</td><td rowspan=\"2\">Self-Supervised R3M(-Lang)</td></tr><tr><td>R3M</td><td>R3M(-Aug)</td><td>R3M(-L1)</td></tr><tr><td>Franka Kitchen</td><td>53.1 ±2.7%</td><td>51.1 ±2.7%</td><td>46.7 ±2.7%</td><td>47.2±2.9%</td></tr><tr><td>MetaWorld</td><td>69.2 ±2.0%</td><td>68.9 ±2.1%</td><td>65.0 ±2.4%</td><td>67.0±2.0%</td></tr><tr><td>Adroit</td><td>65.0 ±1.7%</td><td>61.3 ±2.1%</td><td>66.5 ±1.6%</td><td>45.6 ±3.3%</td></tr><tr><td>All Domains</td><td>62.4 ±1.3%</td><td>60.4 ±1.4%</td><td>59.4 ±1.5%</td><td>53.2 ±1.5%</td></tr></table>",
+        "bbox": [
+            367,
+            338,
+            834,
+            443
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Ablating Components of R3M. We see report success rate of downstream imitation learning on variants of R3M. We observe that on average, removing the L1 penalty have a negative impact, particularly on the Franka Kitchen and MetaWorld environments. Lastly, removing language grounding has the most significant drop in performance, particularly on the Adroit tasks. ",
+        "bbox": [
+            366,
+            449,
+            826,
+            512
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "video-language alignment loss. In Table 1, we report success rates per environment and averaged over all environments. First, we notice that on average across the three environments, we see a drop in performance of ${ \\approx } 2 \\%$ from removing crop augmentation or from removing the $L 1$ regularization. Interestingly, the impact of removing the sparsity regularization depends on the environment. In Franka Kitchen and MetaWorld, sparsity is helpful, while in Adroit removing sparsity actually helps performance slightly. We suspect this is partly due to the Adroit environment using more demonstrations, mitigating the state distribution shift issue. ",
+        "bbox": [
+            173,
+            521,
+            826,
+            626
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We see that across all environments, removing video-language alignment loss has the largest negative impact on performance, particularly in the Adroit environment. We hypothesize that language alignment plays an important role in better capturing semantic features that might be predictive of objects and useful for object manipulation. Nevertheless, we note that even in the fully self-supervised regime, our R3M model still outperforms prior state of the art visual representations like ImageNet trained MoCo (345) (PVR) [23] and CLIP [12] by a significant margin. ",
+        "bbox": [
+            173,
+            632,
+            825,
+            723
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Next, we seek to answer the question: How important is the data? To do so we include comparisons that disentangles the role of the dataset and the training objective. In particular, we have trained a MoCo model on the exact same frames of the Ego4D dataset used to train our R3M model (See Table 2). Additionally we compare to the MVP model [70], which trains a ViT-B masked auto-encoder on the Ego-soup dataset, which comprises of Ego4D and other egocentric video datasets.. We evaluate these comparisons on the Franka Kitchen and Adroit environments, and find that the MoCo-Ego4D model, which uses the same data and compute as R3M, gets an average success rate $\\sim 1 0 \\%$ lower than R3M in both environments. Moreover, we find the MVP models performs $\\sim 2 0 \\%$ worse than R3M. This suggests that while there is indeed a large benefit coming from diverse human video data compared to static ImageNet images $34 \\% $ $42 \\%$ on Franka), the data is not the only source of improvement, and the R3M objective provides an additional $\\sim 1 0 \\%$ boost in success rate. ",
+        "bbox": [
+            174,
+            731,
+            550,
+            852
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/624c98fa321e632aedb43ae5cc5198793d9d81dd1f2e200a4bd640127672dafb.jpg",
+        "table_caption": [
+            "Table 2: Importance of Data vs. Algorithm. We find that the MoCo-Ego4D and MVP models, which leverage the same or more data and compute as R3M perform more than $10 \\%$ worse. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Franka</td><td rowspan=1 colspan=1>Adroit</td></tr><tr><td rowspan=1 colspan=1>R3M</td><td rowspan=1 colspan=1>53.1(2.7)</td><td rowspan=1 colspan=1>65.0 (1.7)</td></tr><tr><td rowspan=1 colspan=1>MoCo-Ego4D</td><td rowspan=1 colspan=1>42.0 (2.8)</td><td rowspan=1 colspan=1>54.9 (2.7)</td></tr><tr><td rowspan=1 colspan=1>MVP([70])</td><td rowspan=1 colspan=1>27.0 (2.6)</td><td rowspan=1 colspan=1>51.4 (2.7)</td></tr></table>",
+        "bbox": [
+            562,
+            723,
+            825,
+            782
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            852,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f81cc6e7a3927b360d7d61cf04c55603b59e5429a88c4145efe9098aa30e2d85.jpg",
+        "image_caption": [
+            "Figure 5: Real World Robot Learning with R3M. With R3M we are able to learn challenging tasks like putting lettuce in the pan, pushing the cup to the goal, and folding the towel from just 20 demonstrations. See appendix for more examples of real robot tasks and details about the robot setup. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            215,
+            88,
+            789,
+            316
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            364,
+            823,
+            409
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.5 Exp. 3: Does R3M enable data efficient learning in real world environments? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            420,
+            745,
+            435
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, we test if R3M can enable data-efficient robot learning in cluttered real-world environments. To do so, we bring a Franka Emika Panda robot into a real graduate student apartment, and aim to learn household tasks from pixels with just 20 demonstrations per task, using the pre-trained R3M representation. We have the robot complete five tasks: (1) closing a dresser drawer, (2) picking a face mask placed randomly on a desk and placing it in the dresser drawer, (3) picking up lettuce randomly placed on a cutting board and putting in a cooking pan, (4) pushing a mug to a goal location, and (5) folding a towel (See Figure 5). Like in our simulation experiments, we collect a small number of demonstrations and do simple behavior cloning with the pre-trained representation. ",
+        "bbox": [
+            173,
+            440,
+            826,
+            563
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Table 3, we report the success rates comparing R3M and CLIP, one of the stronger baselines from our evaluations in simulation. We observe that while the two perform similarly on the easier task of closing the drawer, R3M consistently performs better on the other four tasks (See Figure 5), which require more precise visual representations, yielding nearly double the success rate on average. ",
+        "bbox": [
+            174,
+            569,
+            550,
+            675
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Limitations and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            683,
+            452,
+            700
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/9703f5c0fbe582443d75f2a0af089d15397c64d841e538d12145f2681265139f.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 3: Real World Success Rates. R3M outperforms CLIP on the challenging real world manipulation tasks. "
+        ],
+        "table_body": "<table><tr><td>Success out of 10 trials</td><td>R3M</td><td>CLIP</td></tr><tr><td>Closing Drawer Putting Mask in Dresser</td><td>80% 30%</td><td>70% 10%</td></tr><tr><td>Putting Lettuce in Pan Pushing Mug to Goal</td><td>60% 70%</td><td>0% 40%</td></tr><tr><td>Folding Towel</td><td>40%</td><td>0%</td></tr><tr><td>Average</td><td>56%</td><td>24%</td></tr></table>",
+        "bbox": [
+            563,
+            564,
+            818,
+            684
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work, we set out to study if pre-training visual representations on diverse human videos can enable efficient learning of downstream robotic manipulation tasks. While we were excited by strong results on a wide set of simulated and real robotic tasks, a number of important limitations remain. Our current evaluation is limited to imitation learning, specifically behavior cloning, with a small number of task demonstrations. While we would hope to see R3M be equally beneficial for other robotic learning settings like reinforcement learning, it could be the case that a good pretrained representation for RL is not the same as a good pre-trained representation for imitation. Studying how R3M performs in RL settings, and changes that may need to made to improve its performance is an exciting next step. The current R3M model also only provides a single-frame state representation. In principle, pre-training on human videos should be able to go beyond state representations (e.g. reward learning and task specification). Studying if R3M embeddings or the language grounding module can provide a useful reward signal is an interesting direction for future work. ",
+        "bbox": [
+            174,
+            707,
+            549,
+            736
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            737,
+            825,
+            902
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            92,
+            303,
+            106
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The authors would like to thank the Ego4D team at Meta AI for assistance in using the dataset. We’d also like to thank Karl Pertsch, Simone Parisi, Sidd Karamcheti, and numerous members of Meta AI and the IRIS labs for valuable discussions. This work is in part supported by ONR grant N00014-22-1-2621. Finally, the authors would also like to thank Evan Coleman for assistance with the robot. ",
+        "bbox": [
+            173,
+            114,
+            826,
+            189
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            200,
+            267,
+            217
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "[1] S. Levine, C. Finn, T. Darrell, and P. Abbeel. End-to-end training of deep visuomotor policies. The Journal of Machine Learning Research, 17(1):1334–1373, 2016.   \n[2] 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.   \n[3] D. Mzurikwao, M. Khan, O. Samuel, J. Cinatl, M. Wass, M. Michaelis, G. Marcelli, and C. S. Ang. Towards image-based cancer cell lines authentication using deep neural networks. Scientific Reports, 10, 11 2020. doi:10.1038/s41598-020-76670-6.   \n[4] J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (NAACL-HLT), Minneapolis, Minnesota, June 2019. Association for Computational Linguistics.   \n[5] Z. Zhang, J. Liu, and N. Razavian. BERT-XML: Large scale automated ICD coding using BERT pretraining. In Proceedings of the 3rd Clinical Natural Language Processing Workshop, pages 24–34, Online, Nov. 2020. Association for Computational Linguistics. doi:10.18653/v1/ 2020.clinicalnlp-1.3. URL https://aclanthology.org/2020.clinicalnlp-1.3.   \n[6] Z. Yang, N. Garcia, C. Chu, M. Otani, Y. Nakashima, and H. Takemura. Bert representations for video question answering. In 2020 IEEE Winter Conference on Applications of Computer Vision (WACV), pages 1545–1554, 2020. doi:10.1109/WACV45572.2020.9093596.   \n[7] S. Dasari, F. Ebert, S. Tian, S. Nair, B. Bucher, K. Schmeckpeper, S. Singh, S. Levine, and C. Finn. Robonet: Large-scale multi-robot learning. In Conference on Robot Learning, 2019.   \n[8] A. Mandlekar, J. Booher, M. Spero, A. Tung, A. Gupta, Y. Zhu, A. Garg, S. Savarese, and L. Fei-Fei. Scaling robot supervision to hundreds of hours with roboturk: Robotic manipulation dataset through human reasoning and dexterity. In 2019 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 1048–1055. IEEE, 2019.   \n[9] S. Young, D. Gandhi, S. Tulsiani, A. Gupta, P. Abbeel, and L. Pinto. Visual imitation made easy. In CoRL, 2020.   \n[10] F. Ebert, Y. Yang, K. Schmeckpeper, B. Bucher, G. Georgakis, K. Daniilidis, C. Finn, and S. Levine. Bridge data: Boosting generalization of robotic skills with cross-domain datasets. ArXiv, abs/2109.13396, 2021.   \n[11] T. B. Brown et al. Language models are few-shot learners. arXiv:2005.14165, 2020.   \n[12] A. Radford, J. W. Kim, C. Hallacy, A. Ramesh, G. Goh, S. Agarwal, G. Sastry, A. Askell, P. Mishkin, J. Clark, G. Krueger, and I. Sutskever. Learning transferable visual models from natural language supervision. In ICML, 2021.   \n[13] P. Goyal, Q. Duval, I. Seessel, M. Caron, I. Misra, L. Sagun, A. Joulin, and P. Bojanowski. Vision models are more robust and fair when pretrained on uncurated images without supervision. ArXiv, abs/2202.08360, 2022.   \n[14] R. Goyal, S. Ebrahimi Kahou, V. Michalski, J. Materzynska, S. Westphal, H. Kim, V. Haenel, I. Fruend, P. Yianilos, M. Mueller-Freitag, et al. The” something something” video database for learning and evaluating visual common sense. In Proceedings of the IEEE International Conference on Computer Vision, pages 5842–5850, 2017.   \n[15] D. Damen, H. Doughty, G. M. Farinella, S. Fidler, A. Furnari, E. Kazakos, D. Moltisanti, J. Munro, T. Perrett, W. Price, and M. Wray. Scaling egocentric vision: The epic-kitchens dataset. In European Conference on Computer Vision (ECCV), 2018.   \n[16] K. Grauman et al. Ego4D: Around the World in 3,000 Hours of Egocentric Video, 2021.   \n[17] L. Shao, T. Migimatsu, Q. Zhang, K. Yang, and J. Bohg. Concept2robot: Learning manipulation concepts from instructions and human demonstrations. In Proceedings of Robotics: Science and Systems (RSS), 2020.   \n[18] A. S. Chen, S. Nair, and C. Finn. Learning generalizable robotic reward functions from ”in-the-wild” human videos. ArXiv, abs/2103.16817, 2021.   \n[19] P. Sermanet, C. Lynch, Y. Chebotar, J. Hsu, E. Jang, S. Schaal, and S. Levine. Time-contrastive networks: Self-supervised learning from video. Proceedings of International Conference in Robotics and Automation (ICRA), 2018.   \n[20] A. Rajeswaran, V. Kumar, A. Gupta, J. Schulman, E. Todorov, and S. Levine. Learning complex dexterous manipulation with deep reinforcement learning and demonstrations. ArXiv, abs/1709.10087, 2018.   \n[21] A. Gupta, V. Kumar, C. Lynch, S. Levine, and K. Hausman. Relay policy learning: Solving long-horizon tasks via imitation and reinforcement learning. In CoRL, 2019.   \n[22] T. Yu, D. Quillen, Z. He, R. Julian, K. Hausman, C. Finn, and S. Levine. Meta-world: A benchmark and evaluation for multi-task and meta reinforcement learning. In Conference on Robot Learning, 2020.   \n[23] S. Parisi, A. Rajeswaran, S. Purushwalkam, and A. K. Gupta. The unsurprising effectiveness of pre-trained vision models for control. 2022.   \n[24] K. He, H. Fan, Y. Wu, S. Xie, and R. B. Girshick. Momentum contrast for unsupervised visual representation learning. 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 9726–9735, 2020.   \n[25] M. Laskin, K. Lee, A. Stooke, L. Pinto, P. Abbeel, and A. Srinivas. Reinforcement learning with augmented data. ArXiv, abs/2004.14990, 2020.   \n[26] A. Srinivas, M. Laskin, and P. Abbeel. Curl: Contrastive unsupervised representations for reinforcement learning. In ICML, 2020.   \n[27] I. Kostrikov, D. Yarats, and R. Fergus. Image augmentation is all you need: Regularizing deep reinforcement learning from pixels. ArXiv, abs/2004.13649, 2021.   \n[28] J. Pari, N. M. M. Shafiullah, S. P. Arunachalam, and L. Pinto. The surprising effectiveness of representation learning for visual imitation. ArXiv, abs/2112.01511, 2021.   \n[29] C. Gelada, S. Kumar, J. Buckman, O. Nachum, and M. G. Bellemare. Deepmdp: Learning continuous latent space models for representation learning. ArXiv, abs/1906.02736, 2019.   \n[30] D. Hafner, T. P. Lillicrap, J. Ba, and M. Norouzi. Dream to control: Learning behaviors by latent imagination. ArXiv, abs/1912.01603, 2020.   \n[31] A. Zhang, R. McAllister, R. Calandra, Y. Gal, and S. Levine. Learning invariant representations for reinforcement learning without reconstruction. ArXiv, abs/2006.10742, 2021.   \n[32] S. Nair, S. Savarese, and C. Finn. Goal-aware prediction: Learning to model what matters. ArXiv, abs/2007.07170, 2020.   \n[33] M. Hong, K. Lee, M. Kang, W. Jung, and S. Oh. Dynamics-aware metric embedding: Metric learning in a latent space for visual planning. IEEE Robotics and Automation Letters, 2022.   \n[34] R. Jonschkowski and O. Brock. Learning state representations with robotic priors. Autonomous Robots, 39:407–428, 10 2015. doi:10.1007/s10514-015-9459-7.   \n[35] Y.-C. Lin, A. Zeng, S. Song, P. Isola, and T.-Y. Lin. Learning to see before learning to act: Visual pre-training for manipulation. 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 7286–7293, 2020.   \n[36] M. Shridhar, L. Manuelli, and D. Fox. Cliport: What and where pathways for robotic manipulation. In CoRL, 2021.   \n[37] A. Khandelwal, L. Weihs, R. Mottaghi, and A. Kembhavi. Simple but effective: Clip embeddings for embodied ai. ArXiv, abs/2111.09888, 2021.   \n[38] R. Shah and V. Kumar. Rrl: Resnet as representation for reinforcement learning. ArXiv, abs/2107.03380, 2021.   \n[39] Y. Seo, K. Lee, S. James, and P. Abbeel. Reinforcement learning with action-free pre-training from videos. ArXiv, abs/2203.13880, 2022.   \n[40] T. Xiao, I. Radosavovic, T. Darrell, and J. Malik. Masked visual pre-training for motor control. 2022.   \n[41] Y. Liu, A. Gupta, P. Abbeel, and S. Levine. Imitation from observation: Learning to imitate behaviors from raw video via context translation. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pages 1118–1125. IEEE, 2018.   \n[42] P. Sharma, D. Pathak, and A. Gupta. Third-person visual imitation learning via decoupled hierarchical controller. In NeurIPS, 2019.   \n[43] L. Smith, N. Dhawan, M. Zhang, P. Abbeel, and S. Levine. AVID: Learning Multi-Stage Tasks via Pixel-Level Translation of Human Videos. In Proceedings of Robotics: Science and Systems, Corvalis, Oregon, USA, July 2020.   \n[44] T. Yu, C. Finn, S. Dasari, A. Xie, T. Zhang, P. Abbeel, and S. Levine. One-shot imitation from observing humans via domain-adaptive meta-learning. In Proceedings of Robotics: Science and Systems, Pittsburgh, Pennsylvania, June 2018.   \n[45] K. Schmeckpeper, A. Xie, O. Rybkin, S. Tian, K. Daniilidis, S. Levine, and C. Finn. Learning predictive models from observation and interaction. In ECCV, 2020.   \n[46] A. D. Edwards and C. L. Isbell. Perceptual values from observation. arXiv preprint arXiv:1905.07861, 2019.   \n[47] K. Schmeckpeper, O. Rybkin, K. Daniilidis, S. Levine, and C. Finn. Reinforcement learning with videos: Combining offline observations with interaction. In CoRL, 2020.   \n[48] R. Scalise, J. Thomason, Y. Bisk, and S. Srinivasa. Improving robot success detection using static object data. In Proceedings of the 2019 IEEE/RSJ International Conference on Intelligent Robots and Systems, 2019.   \n[49] S. Pirk, M. Khansari, Y. Bai, C. Lynch, and P. Sermanet. Online object representations with contrastive learning, 2019.   \n[50] H. Xiong, Q. Li, Y.-C. Chen, H. Bharadhwaj, S. Sinha, and A. Garg. Learning by watching: Physical imitation of manipulation skills from human videos, 2021.   \n[51] N. Das, S. Bechtle, T. Davchev, D. Jayaraman, A. Rai, and F. Meier. Model-based inverse reinforcement learning from visual demonstrations, 2021.   \n[52] K. Zakka, A. Zeng, P. Florence, J. Tompson, J. Bohg, and D. Dwibedi. Xirl: Cross-embodiment inverse reinforcement learning, 2021.   \n[53] S. Stepputtis, J. Campbell, M. Phielipp, S. Lee, C. Baral, and H. B. Amor. Language-conditioned imitation learning for robot manipulation tasks. ArXiv, abs/2010.12083, 2020.   \n[54] C. Lynch and P. Sermanet. Grounding language in play. ArXiv, abs/2005.07648, 2020.   \n[55] Y. Cui, S. Niekum, A. Gupta, V. Kumar, and A. Rajeswaran. Can Foundation Models Perform Zero-Shot Task Specification For Robot Manipulation? In L4DC, 2022.   \n[56] S. Nair, E. Mitchell, K. Chen, B. Ichter, S. Savarese, and C. Finn. Learning language-conditioned robot behavior from offline data and crowd-sourced annotation. In CoRL, 2021.   \n[57] L. Pinto and A. Gupta. Supersizing self-supervision: Learning to grasp from 50k tries and 700 robot hours. In IEEE international conference on robotics and automation (ICRA), 2016.   \n[58] P. Sharma, L. Mohan, L. Pinto, and A. K. Gupta. Multiple interactions made easy (mime): Large scale demonstrations data for imitation. In CoRL, 2018.   \n[59] E. Jang, A. Irpan, M. Khansari, D. Kappler, F. Ebert, C. Lynch, S. Levine, and C. Finn. Bcz: Zero-shot task generalization with robotic imitation learning. In A. Faust, D. Hsu, and G. Neumann, editors, Proceedings of the 5th Conference on Robot Learning, volume 164 of Proceedings of Machine Learning Research, pages 991–1002. PMLR, 08–11 Nov 2022. URL https://proceedings.mlr.press/v164/jang22a.html.   \n[60] X. Wang and A. K. Gupta. Unsupervised learning of visual representations using videos. 2015 IEEE International Conference on Computer Vision (ICCV), pages 2794–2802, 2015.   \n[61] P. Sermanet, K. Xu, and S. Levine. Unsupervised perceptual rewards for imitation learning. Proceedings of Robotics: Science and Systems (RSS), 2017.   \n[62] X. Wang, A. Jabri, and A. A. Efros. Learning correspondence from the cycle-consistency of time. 2019 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 2561–2571, 2019.   \n[63] A. Jabri, A. Owens, and A. A. Efros. Space-time correspondence as a contrastive random walk. ArXiv, abs/2006.14613, 2020.   \n[64] M. Goyal, S. Modi, R. Goyal, and S. Gupta. Human hands as probes for interactive object understanding. In Computer Vision and Pattern Recognition (CVPR), 2022.   \n[65] A. Miech, D. Zhukov, J.-B. Alayrac, M. Tapaswi, I. Laptev, and J. Sivic. Howto100m: Learning a text-video embedding by watching hundred million narrated video clips. 2019 IEEE/CVF International Conference on Computer Vision (ICCV), pages 2630–2640, 2019.   \n[66] H. Xu, G. Ghosh, P.-Y. Huang, D. Okhonko, A. Aghajanyan, and F. M. L. Z. C. Feichtenhofer. Videoclip: Contrastive pre-training for zero-shot video-text understanding. ArXiv, abs/2109.14084, 2021.   \n[67] A. van den Oord, Y. Li, and O. Vinyals. Representation learning with contrastive predictive coding. ArXiv, abs/1807.03748, 2018.   \n[68] S. Ross, G. J. Gordon, and J. A. Bagnell. A reduction of imitation learning and structured prediction to no-regret online learning. In AISTATS, 2011.   \n[69] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 770–778, 2016.   \n[70] I. Radosavovic, T. Xiao, S. James, P. Abbeel, J. Malik, and T. Darrell. Real-world robot learning with masked visual pre-training. CoRL, 2022.   \n[71] V. Sanh, L. Debut, J. Chaumond, and T. Wolf. Distilbert, a distilled version of bert: smaller, faster, cheaper and lighter. ArXiv, abs/1910.01108, 2019. ",
+        "bbox": [
+            168,
+            220,
+            828,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            64,
+            828,
+            915
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            51,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            49,
+            830,
+            921
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            168,
+            90,
+            826,
+            161
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A R3M Training Details ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            393,
+            108
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.1 Data Preprocessing ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            116,
+            352,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The Ego4D dataset consists of several hour long videos within a certain scene. Within each scene, there are many sub-clips, each with a natural language annotation. R3M trains with these shorter video clips paired with language annotations. ",
+        "bbox": [
+            174,
+            140,
+            825,
+            184
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For faster training R3M parses each video clip into frames (Resized and cropped to $2 2 4 \\mathbf { x } 2 2 4 )$ and samples frames from a video clip individually. See the codebase for more details on the implementation of sampling the videos. ",
+        "bbox": [
+            174,
+            191,
+            825,
+            237
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.2 Training Architecture and Hyper-Parameters ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            248,
+            534,
+            263
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "R3M can in principle be trained with any visual encoding architecture for $\\mathcal { F } _ { \\phi }$ . We train with off the shelf ResNet18, 34, and 50 [69], as implemented by torchvision.models. ",
+        "bbox": [
+            176,
+            271,
+            825,
+            301
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The language prediction head is implemented as an 5 layer MLP with sizes $[ 2 ^ { * } E + L$ , 1024, 1024, 1024, 1024] and output a scalar score, where $E$ is the output dimension of $\\mathcal { F } _ { \\phi }$ and $L$ is the output dimension of the DistilBERT [71] sentence encoder (768) from HuggingFace transformers. ",
+        "bbox": [
+            174,
+            308,
+            826,
+            353
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "During training of R3M, we use batch sizes of 16 video clips (where 5 frames are samples from each video clip: an initial image, final image, and sequence of 3 frames). The initial and final frames are sampled from the first and last $20 \\%$ of the video clip. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            405
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "R3M models are trained for one million steps in our experiments, and for 1.5 million steps in our released models, with a learning rate of 0.0001. ",
+        "bbox": [
+            174,
+            412,
+            821,
+            443
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For the training objective in Equation 3, we use hyperparameters $\\lambda _ { 1 } ~ = ~ 1 , \\lambda _ { 2 } ~ = ~ 1 , \\lambda _ { 3 } ~ =$ $0 . 0 0 0 0 1 , \\lambda _ { 4 } = 0 . 0 0 0 0 1$ . ",
+        "bbox": [
+            174,
+            449,
+            823,
+            479
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.3 Additional Implementation Details ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            491,
+            459,
+            506
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In practice, we use more than one negative video example in training Equations 1 and 2. Instead we use 3 negative examples, sampled from different videos in the batch. ",
+        "bbox": [
+            171,
+            513,
+            823,
+            544
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Additionally in training for Equation 2, we consider the following positive pairs within a single batch element: Initial and Final Frames $( I _ { 0 } , I _ { g } )$ , $\\left( I _ { 0 } , I _ { j > i } \\right)$ , and $\\left( I _ { 0 } , I _ { k > j } \\right)$ , with corresponding negatives $( I _ { 0 } , I _ { 0 } )$ , $( I _ { 0 } , I _ { i } )$ , and $( I _ { 0 } , I _ { j } )$ respectively. Using a larger number of positive examples from a single video and multiple negative examples from different videos stabilizes training. ",
+        "bbox": [
+            173,
+            551,
+            825,
+            612
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.4 Example Usage ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            622,
+            325,
+            638
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Using R3M is simple. The codebase is located at https://github.com/facebookresearch/r3m. Simply clone the repo and install via pip install -e . Then R3M can be loaded by running: ",
+        "bbox": [
+            173,
+            646,
+            823,
+            676
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "from r3m import load_r3m 2 r3m $=$ load_r3m (\" resnet50 \") # resnet18 , resnet34 3 r3m . eval () ",
+        "bbox": [
+            160,
+            684,
+            609,
+            724
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B Evaluation Details ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            742,
+            362,
+            760
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B.1 Simulation Environments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            770,
+            395,
+            785
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We focus on three simulation environments: Franka Kitchen, MetaWorld, and Adroit. ",
+        "bbox": [
+            174,
+            791,
+            732,
+            808
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Franka Kitchen. The Franka Kitchen environments used in this paper are modified from the original environment; specifically, we add additional randomization to the scene. We randomly change the position of the kitchen between episodes, making the task significantly more challenging both in perception and control. ",
+        "bbox": [
+            173,
+            814,
+            825,
+            875
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The 5 tasks in the Franka Kitchen involve opening the left door, opening the sliding door, turning on the light, turning the knob, and opening the microwave. All Franka tasks include proprioceptive data of the arm joint positions and gripper positions. The horizon for all Franka tasks is 50 steps, and our imitation experiments use either 5, 10, or 25 demos. ",
+        "bbox": [
+            173,
+            881,
+            821,
+            911
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/3b7ced0832de197b999498df4d487e291caf9cea608c36ac3e4808a43e0ce415.jpg",
+        "image_caption": [
+            "Figure 6: Real World Robot Learning with R3M. With R3M we are able to learn challenging tasks like closing the drawer, putting the mask in the dresser, putting lettuce in the pan, pushing the cup to the goal, and folding the towel from just 20 demonstrations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            217,
+            90,
+            790,
+            470
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            534,
+            821,
+            564
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "MetaWorld. The MetaWorld environments are the standard V2 Button Pressing, Bin Picking, Drawer Opening, Hammer, and Assembly environments available in MetaWorld [22]. In all tasks, the target object (drawer, peg, block, etc.) position is randomized between episodes. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            616
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "All MetaWorld tasks include proprioceptive data of the gripper end effector pose and gripper open/- close. The horizon for all MetaWorld tasks is 500 steps, and our imitation experiments use either 5, 10, or 25 demos. ",
+        "bbox": [
+            173,
+            623,
+            826,
+            667
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Adroit. We use the standard Pen and Relocate tasks in the Adroit hand manipulation suite. The goal position of the pen and the goal position of the ball are randomized between episodes, and specified visually. ",
+        "bbox": [
+            174,
+            675,
+            825,
+            720
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "All Adroit tasks include proprioceptive data of the hand joints, and in the Relocate task also includes the global position of the hand. The horizon for the Pen task is 100 steps and for the Relocate task is 200 steps. Our imitation experiments use either 25, 50, or 100 demos. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            773
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B.2 Real World Environments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            804,
+            397,
+            819
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Our real world experiments involve bringing a Franka Emika Panda robot into a real graduate student apartment. The tasks involve putting lettuce in a pan in the kitchen, pushing a mug to a goal position on a dining table, closing a drawer, putting a mask in a drawer, and folding a towel (See Figure 6). All tasks involve randomization (e.g. the towel/lettuce/mug/mask position or drawer position). The initial state of the gripper is also randomized each episode. ",
+        "bbox": [
+            174,
+            835,
+            825,
+            911
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/789191667ec3f87a5dc905d3b8489fb17f9b44264a3662234df19f530713515f.jpg",
+        "image_caption": [
+            "Figure 7: Real Robot Camera Viewpoints. Camera view used for learning each of the real robot tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            93,
+            792,
+            228
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The robot observation includes RGB images froma USB webcam, positioned differently for each task (See Figure 7). The robot end effector position is also concatenated with the image embedding during imitation learning. ",
+        "bbox": [
+            174,
+            277,
+            825,
+            323
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "B.3 Demo Data Collection ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            335,
+            369,
+            349
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In the Franka Kitchen and Adroit tasks, expert data is generated by training a state based agent with model free RL [20]. The state based trajectories are then replayed and rendered with image observations. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            402
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In the MetaWorld environment, a heuristic policy using state information is used to generate expert data, which is then replayed and rendered with image observations. ",
+        "bbox": [
+            173,
+            410,
+            821,
+            440
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "On the real robot, demonstrations are collected by a human tele-operator with a PlayStation controller. The control is applied directly in the end effector Cartesian space, and the demo trajectories are directly saved with visual observations. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            492
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "B.4 Comparisons ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            503,
+            308,
+            520
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In all experiments all models use a ResNet50 base architecture. ",
+        "bbox": [
+            173,
+            526,
+            588,
+            541
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "CLIP: The CLIP comparison uses the of the shelf CLIP RN50 model available at https://github.   \ncom/openai/CLIP. ",
+        "bbox": [
+            173,
+            547,
+            823,
+            578
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "ImNet Supervised: This comparison uses the default ResNet architecture available from torchvision.models with pretrained $\\cdot ^ { = }$ True. ",
+        "bbox": [
+            173,
+            585,
+            823,
+            616
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "MoCo (345): This comparison uses a pre-trained MoCo model on Imagenet which fuses the third, fourth, and fifth convolutional layers as proposed in [23]. ",
+        "bbox": [
+            174,
+            622,
+            823,
+            654
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Note that our usage of the Moco (345) model differs from the setup in Parisi et al. [23] in aspects like proprioception features, frame stacking etc. As a result, the numerical results are not directly comparable across the two works. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            705
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Scratch: uses the default ResNet architecture available from torchvision.models with pretrained $\\equiv$ False. Additionally, it lets gradients from the behavior cloning MSE loss pass into the visual encoder. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            757
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "MoCo-Ego4D: This comparison uses a pre-trained MoCo model on the samed data as R3M from the Ego4D dataset. ",
+        "bbox": [
+            169,
+            765,
+            823,
+            795
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "MVP: This comparison uses a pretrained MVP [40, 70] model, which trains an MAE with a ViT-B architecture on the Ego-Soup dataset, which consists of Ego4D and other egocentric human video datasets. ",
+        "bbox": [
+            174,
+            801,
+            825,
+            847
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "B.5 Behavior Cloning Hyperparameters ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            858,
+            465,
+            875
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The downstream policy is a 2 layer MLP with hidden sizes [256,256] preceded by a BatchNorm. The input to the policy is the concatenated visual embedding and proprioceptive data, and the output is ",
+        "bbox": [
+            174,
+            881,
+            821,
+            911
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/f7a1c5a5f61715b2ab56840e2bcc414d37baf35815ccf41900561354230647f6.jpg",
+        "image_caption": [
+            "Figure 8: Performance over different views/dataset sizes. We report the success rate of R3M and baseline across each view (left) and dataset size (right). We see that the performance improvement from R3M is consistent across all views. We also observe that while absolute performance increases with more demos, the performance improvement from R3M is consistent across all demo sizes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            93,
+            813,
+            412
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "the action. The policy is trained with a learning rate of 0.001, and a batch size of 32 for 20000 steps, evaluating every 1000. ",
+        "bbox": [
+            173,
+            478,
+            825,
+            507
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "C Additional Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            517,
+            364,
+            535
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "C.1 How does performance vary across viewpoint and demo dataset size? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            544,
+            694,
+            559
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "In our next experiment, we take a closer look at R3M performance compared to prior methods across viewpoints and dataset sizes. In Figure 8, we plot the average success rate of each method across each dataset size and viewpoint. We observe that the performance improvement of R3M is consistent across all viewpoints, and it is the highest performing representation in all cases. Interestingly, we see that the same does not hold amongst the prior methods, where the ranking between MoCo (345) and CLIP changes based on the chosen viewpoint. ",
+        "bbox": [
+            173,
+            565,
+            826,
+            656
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Additionally, we also study the impact of dataset size for imitation learning. Again, we observe that the performance improvement from R3M is consistent, outperforming the baselines across every environment and demo dataset size. We observe that in the Franka Kitchen and Adroit environments, the performance gain from R3M stays consistent with increase in dataset size, even as the absolute performance of all methods improves. Overall, we clearly observe that the performance benefit of R3M is not tied to a specific viewpoint or dataset size. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            753
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "C.2 Performance Breakdown By Task ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            765,
+            449,
+            780
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "In Figure 9 we report the success rate on each task individually. Note each success rate for each method is still the average over 3 views, 3 demo sizes, and 3 seeds. We observe that on 11/12 tasks R3M is the highest performing method. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            832
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/19f22ab8667bc2542e959c946f96a8f6adc68e026fea187148f6dfa6449e439f.jpg",
+        "image_caption": [
+            "Assembly, Bin Picking, Button Pressing, Drawer Opening, Hammering ",
+            "Sliding Door, Turning Light On, Opening Door, Turning Knob, Opening Microwave ",
+            "Figure 9: Per task Success Rate. We observe that R3M is the highest performing method on 11/12 tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            411,
+            812,
+            574
+        ],
+        "page_idx": 17
+    }
+]