Add files using upload-large-folder tool

parse/train/S1enmaVFvS/S1enmaVFvS.md

@@ -0,0 +1,365 @@
+# DATA-DRIVEN APPROACH TO ENCODING AND DECODING 3-D CRYSTAL STRUCTURES
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Generative models have achieved impressive results in many domains including image and text generation. In the natural sciences, generative models have lead to rapid progress in automated drug discovery. Many of the current methods focus on either 1-D or 2-D representations of typically small, drug-like molecules. However, many molecules require 3-D descriptors and exceed the chemical complexity of commonly used datasets. We present a method to encode and decode the position of atoms in 3-D molecules along with a dataset of nearly 50,000 stable crystal unit cells that vary from containing 1 to over 100 atoms. We construct a smooth and continuous 3-D density representation of each crystal based on the positions of different atoms. Two different neural networks were trained on a dataset of over 120,000 three-dimensional samples of single and repeating crystal structures. The first, an Encoder-Decoder pair, constructs a compressed latent space representation of each molecule and then decodes this description into an accurate reconstruction of the input. The second network segments the resulting output into atoms and assigns each atom an atomic number. By generating compressed, continuous latent spaces representations of molecules we are able to decode random samples, interpolate between two molecules, and alter known molecules.
+
+# 1 INTRODUCTION
+
+Generative models have recently seen tremendous success in generating 2-D images of every day objects (Kingma & Welling, 2013; Goodfellow et al., 2014; Brock et al., 2018; Razavi et al., 2019). The size and accuracy of generated results has greatly improved to the point where samples from the latent space decode to photo-realistic samples (Brock et al., 2018; Razavi et al., 2019). A very exciting and important future avenue for generative models is the generation of 3-D structures, like in the world around us. Adversarial networks and autoencoders have been extended into 3-D and have shown they are able to encode useful representations of everyday objects (Wu et al., 2016; Zhu et al., 2018; Brock et al., 2016; Achlioptas et al., 2017; Valsesia et al., 2018; Meng et al., 2019; Maturana & Scherer, 2015). Representations using point clouds have gained popularity as a way to capture the distribution of different types of objects (Achlioptas et al., 2017; Yang et al., 2019; Wu et al., 2018).
+
+As machine learning approaches are able to understand and recreate the underlying distributions for many different types of objects in our world, the application of these tools in the physical sciences is a very exciting direction. A clear field where generative models can have a tremendous impact is in material discovery, which is very important for designing new batteries or carbon capture devices for fighting climate change.
+
+One very successful area of applying generative models to the sciences has been the field of drug discovery (Jin et al., 2018; Gómez-Bombarelli et al., 2018; Assouel et al., 2018) (see Schwalbe-Koda & Gómez-Bombarelli (2019) for an excellent summary of many methods). The success of machine learning in this domain has been enormously helpful as a process that was often painstakingly slow has been rapidly accelerated in searching an unimaginably large space of possible drug compounds, estimate to be up to $1 0 ^ { 6 0 }$ (Polishchuk et al., 2013). Additionally, excellent datasets such as QM9 (Ramakrishnan et al., 2014) and ZINC (Irwin et al., 2012) which contain molecules of interest along with their precomputed properties have allowed for comparing different methods and developing state-of-the-art tools.
+
+![](images/e5d0c45c3fd1f05a755aa39ebe59a8974cd4a06889e59019c5f4e54b12ef09f7.jpg)  
+Figure 1: Examples of crystal unit cells. Each example shows the unit cell of a crystal. Different colors represent different atomic species. A red, green, and blue line represent the 3 axes of the crystal. Note that they vary in length and angle. Additionally, some unit cells have just one or two atoms while others have nearly 100. Visualizations were made with Mercury (Macrae et al., 2008).
+
+By learning a compressed, useful, latent space representation, this enormous space of molecules can be embedded in a simpler latent space that is easier to search Kusner et al. (2017). Using generative models, compounds hypothesized to have specific properties can be rapidly generated and then a targeted subset of these can be experimentally tested. For example, in Gómez-Bombarelli et al. (2018), an auxiliary property prediction task is introduced for a network separate from the encoder/decoder. This allows for optimization of properties in the latent space and then the resulting latent space vector is decoded into a candidate molecule that can undergo more rigorous computational testing before it is experimentally synthesized. Using a graph representation and reinforcement learning, You et al propose a novel method for molecule generation with specific properties You et al. (2018).
+
+Most of the work combining generative models with chemical discovery has focused on molecules that can be represented in either 1 dimension (such as a SMILES string (Weininger, 1988)) or by leveraging a 2 dimensional representation of a molecule, such as a graph. While 1-D and 2-D representations have been very successful for many drug compounds, these representations are not sufficient to describe all molecules. For example, it is possible for different molecules, with very different properties, to have identical graphs (Gebauer et al., 2019). Additionally, there are more complex classes of compounds where the 3-D structure is integral to the molecule’s properties. Therefore, in this work we focus on generating representations of molecules where the 3-D information is essential for reconstruction. Generating 3-D structures is still a relatively nascent field, when compared to image and text generation. The data requirements for modeling 3-D structures are larger than their 2-D counterparts and there are fewer standard datasets (Nguyen-Phuoc et al., 2019). Additionally, to measure the properties of inorganic materials (like those considered here), costly DFT calculations are needed which require precise 3-D locations. There is an extra dimension in 3-D problems, providing additional symmetries that often need to be learned (Weiler et al., 2018). New work from generates adjacency matrices which are, by construction, invariant to rotation Hoffmann & Noé (2019). In either case, for the automatic generation of viable complex 3-D structures of inorganic compounds one needs to accurately generate the locations of many atoms in 3-D space.
+
+In this work, we focus specifically on proposing an effective 3-D representation for this class of molecules that can not be represented in the same ways as many smaller molecules. We hope to promote work in this still nascent field which has yet to see the same level of success as the generation of smaller molecules. In the Appendix, we have provided a clear comparison with 1-D and 2-D representations. Currently, no direct comparisons are possible.
+
+In addition to drug discovery, a promising avenue for molecular design is for minimizing environmental impact through the design of more efficient or more environmentally friendly compounds for a variety of applications. Designing more efficient materials for photo-voltaic panels and more environmentally friendly materials for batteries are both very exciting research directions for using machine learning as a tool towards mitigating climate change (Niu et al., 2015; Tabor et al., 2018; Gebauer et al., 2019; Rolnick et al., 2019). Many of the compounds of interest are crystal structures made of single small sub-units that repeat in all directions. This sub-unit is referred to as a “unit cell” and can vary in size and shape as well as internal arrangement and chemical composition.
+
+In this work, we present a method for encoding and decoding a very important set of 3-D molecules that can not be represented using standard methods used for drug-like molecules. We directly encode and decode 3-D volumes of density from two different data representations. In the first, we use single unit cells, as shown in Fig. 1. Each unit cell is centered in the cube, but randomly rotated. In the second representation, we repeat the unit cell along all three axes such that the resulting sampled cube contains repeated unit cells of crystal structures, like those shown in Fig. 2 (and Fig. S6C). Many very interesting and important molecules, such as materials for solar panels or batteries, are composed of crystalline units. We train a variational autoencoder (VAE) and a network to segment the decoded output based on the true locations of atoms in tandem. By coupling these two tasks, we are able to accurately encode and decode 3-D atomic positions and species. As far as we are aware, this is not an explored direction as a means to represent molecules for encoding and decoding their 3-D arrangement. We summarize our contribution as follows:
+
+• We propose a method for encoding and decoding 3-D molecules that can not be represented by traditional string or graph based approaches. By jointly training a VAE and a segmentation network on the output of the decoder, we train the entire network in an end-to-end fashion. • We consider two different problems: (1) encoding and decoding single unit cells and (2) encoding and decoding repeated unit cells. In both cases we accurately reconstruct the locations of atoms. We also achieve good results in atomic species identification and future work will improve this front. By sampling from $\mathbf { z } \sim \mathcal { N } ( 0 , 1 )$ , we generate complex structures that have physically realistic spacing between atoms.
+
+![](images/104ee9745a030128516aff01dec068a3c52f5f1e3ae3b5a46ab8a19c21a3981b.jpg)  
+Figure 2: Network Architecture. We encode and decode a $3 0 \times 3 0 \times 3 0$ voxel grid representing $1 0 \mathring \mathrm { A }$ on each side. Each voxel contains the value of the density. The output of the decoder is passed into a 3-D U-Net Çiçek et al. (2016). We train the two models in parallel. In the schematic, we show the crystal represented as a repeated unit cell rather than a single unit cell. The black arrows indicate deterministic transformations. From the cif file, the species matrix is constructed. From this, the density matrix is computed.
+
+# 2 PRELIMINARIES AND RELATED WORK
+
+There are many classes of compounds that are of interest for data-driven discovery. There has been significant work exploring the generation of molecules with potential medicinal properties. These molecules tend to be organic molecules and can be represented efficiently using a string or a graph. A more complex class of molecules are inorganic crystal structures which vary in complexity across many different axes. Crystals are materials that are made up of a repeating pattern of a simpler “unit cell.” Crystal structures are of key interest for many environmental problems, such as materials for solar panels and batteries (Niu et al., 2015).
+
+In contrast to problems in drug discovery, many crystals are not composed solely of organic molecules. Crystals commonly contain many heavy (non-Hydrogen) atoms which make various quantum mechanical calculations of their energetic properties very difficult and time consuming. For example, the common benchmark dataset QM9 for predicting quantum mechanical properties includes over 130,000 molecules contains fewer than 9 “heavy” atoms (Ramakrishnan et al., 2014).
+
+![](images/e317eecfd7e520c0280f7a5951d8a0597f0e801dce96c75eea954c4cab6faeda.jpg)  
+Figure 3: Single unit cell accuracy. (A) We show the voxel wise reconstruction error (plotted with mean square error) during training. (B) For random molecules in the test set, we plot the number of true atoms and the number of recovered atoms after segmentation. (C) For the reconstructed atoms, we plot the predicted atomic number versus the atomic number of the nearest true atom. (D) We compute the distance from each true atom to the nearest predicted atom and vice-versa (orange and blue, respectively). (E) For three different crystals we plot the predicted versus reconstructed density at each voxel. We also show 2-D slices through the target and prediction, along with the 3-D reconstructions. For plotting, the density on each figure is normalized between 0 and 1 though is not decoded as such.
+
+There have been two parallel lines of work applying machine learning to material sciences. The first deals with the prediction of physical properties from a compound without performing a computationally expensive density functional theory (DFT) calculation.
+
+Recently, Xie and Grossman introduced crystal graph convolutional networks (CGCNN) for accurate prediction of 8 different DFT-calculated properties of crystal structures (Xie & Grossman, 2018). MatErials Graph Network (MEGNet) uses graph neural networks (Chen et al., 2019) to predict a variety of energetic properties on both the QM9 dataset (Ramakrishnan et al., 2014) as well 69,000 crystal structures from the Materials Project (Jain et al., 2013). Another network, SchNet, uses 3-D spatial information to directly leverage the interactions between separate atoms. They then use a continuous-filter convolution for accurate property prediction (Schütt et al., 2018). These methods, and many more, have all achieved impressive results on many standard benchmark datasets. Cubuk, et al. use transfer learning to search an enormous space of molecules for promising Lithium ion conductors (Cubuk et al., 2019).
+
+Another line of work is concerned with generating molecules, often molecules that have specific properties. In the past decade, generative models for drug discovery have achieved impressive results. Typically a representation of a compound, such as a SMILES string (Gómez-Bombarelli et al., 2018; Segler et al., 2017; Alperstein et al., 2019) or a graph (Jin et al., 2018; Assouel et al., 2018; Mansimov et al., 2019) is encoded and decoded. Then, by sampling the resulting latent space, novel molecules can be generated. Either by performing an auxiliary task with the latent space (as done in Gómez-Bombarelli et al. (2018)) and then performing optimization or by conditioning the latent space on desirable properties, novel chemical structures are obtained.
+
+One possible representation of drug-like molecules is a SMILES string. However, a difficulty faced using the SMILES representation is ensuring that the decoder decoded a valid SMILES string (Gómez-Bombarelli et al., 2018; Kusner et al., 2017). Additionally, there is not a strong notion of distance between molecules and their SMILES representation (Jin et al., 2018). One approach, ChemTS, uses SMILES strings along with recurrent neural networks and Monte Carlo Tree Search to better ensure generated strings decode to real molecules (Yang et al., 2017). By explicitly penalizing invalid SMILES strings in their reward function they are able to bypass the difficulty in their decoded molecules being non-physical.
+
+More recently, graph based methods have proven very successful in generating synthetically attainable molecules. By building a database of molecule fragments (like LEGO bricks), a graph is formed based on the connectivity of different structures (Jin et al., 2018). These methods have far fewer difficulties ensuring that the decoder produces physically valid molecules. For generation of physical molecules, this is a very important consideration, as there are many hard constrains that most be obeyed. Other graph based approaches include flow based models (Madhawa et al., 2019). Also using graph neural networks, E. Manismov and collaborators developed a method to, given a graph, recreate conformations of a 3-D molecule and predict its energetic properties (Mansimov et al., 2019). In Mansimov et al. (2019), the authors propose a graph-based generative method that is able to generate molecules with desired target properties. Impressively, they recover 3-D positional information for the atoms and show they achieve the required accuracy for relaxation.
+
+An additional challenge for generative models in the physical sciences is ensuring that samples from the latent space, z, decode into physically plausible objects. The decoded objects need to obey physical constraints and an object that may appear physical is not certain to actually be experimentally realizable. In many domains this is not of specific concern, for example a generated animal is scored on some likelihood based on its visual appearance, not whether or not the generated creature is genetically possible. Recently, there have been generative models leveraging the 3-D nature of the problem. G-SchNet, a generative model for 3-D molecules (Gebauer et al., 2019) leverages the SchNet architecture- a start-of-the-art property prediction network (Schütt et al., 2018). They show they are able to generate molecules, placing atoms in 3-D space in a rotationally invariant manner. By appropriately conditioning the placement of new molecules based on the location and identity of previous molecules, they ensure the symmetries that are required for the molecules to relax in a DFT calculation. They propose expanding G-SchNet to generating crystal structures as a future direction.
+
+While there is a rich literature in the generation of organic compounds, recently there has been work in the generation of more complex crystal structures, such as CrystalGAN (Nouira et al., 2018). The authors of CrystalGAN introduce geometric constraints and show that their method is able to produce stable structures compared to methods that do not include such domain knowledge such as DiscoGAN (Kim et al., 2017). CrystalGAN uses a dataset with a much larger selection of elements than much previous work, but they limit themselves to molecules of particular chemical structure, nor do they generate a 3-D arrangement. In this work, we do not limit the generated crystals in this way.
+
+# 3 METHODS
+
+We use a dataset containing $4 6 { , } 7 4 4 \mathrm { c i f }$ files which contains the information describing the unit cells of properly relaxed crystal structures from the Materials Project (Jain et al., 2013; Xie & Grossman, 2018). We use $80 \%$ of the data for testing and the other $20 \%$ for training. Using the Python library pymatgen we preprocess all of the data into the density 3-D matrices (Ong et al., 2013) described below. The boundary box of a crystal structure is controlled by six different degrees of freedom (see Fig. 1). Each side can have a different length and the angles between the three sides is also variable. Additionally, the internal complexity of each crystal can also vary widely– some unit cells in our dataset contain a single atom while other unit cells can have over one hundred different atoms. This tremendous variability in structure makes a universal representation difficult.
+
+![](images/a14e135fc66f074fa225d5fe0e75e15f44f183476d9b382bb262610b0b8beec6.jpg)  
+Figure 4: Species reconstruction and latent space interpolation. (A) For five different randomly selected crystal unit cells we show the target and our reconstruction. Atoms are colored using default atomic colors, atoms with similar atomic number do not necessarily have similar colors. (B) We show the reconstruction of latent space interpolation between two molecules for 3 random sets of targets. For a video, see the Appendix.
+
+# 3.1 DATA REPRESENTATION
+
+As a first step for the problem of generating novel, physical crystal structures we begin with the simpler problem of encoding and decoding physical locations of atoms in space. We begin by considering a cube with side length $1 0 \mathrm { ~ \AA ~ }$ , which we represent by $M$ . We divide this cube into 30 equally spaced bins, resulting in a $3 0 \times 3 0 \times 3 0$ cube with each voxel representing $0 . 3 3 \mathring { \mathrm { A } }$ on each side (see Fig. 2 and Fig. 3E). In the appendix, we discuss this choice in more detail. This data representation is similar to many computer vision tasks, so we use similar convolution based network architectures.
+
+We consider the crystal structures in our dataset where the maximum side length is less than $1 0 \mathring \mathrm { A }$ We consider two different data representations of different complexity. In the first, we shift each single unit cell to the center of our grid, then we randomly rotate it. In this representation, we encode and decode a single unit cell. We randomly sample 3 different rotations for each crystal. In this case, the encoded structures typically have between 1 and 30 atoms, with a few reaching between 50 and 100. In the second representation, we repeat these unit cells in each direction infinitely and randomly sample a cube in space. This means that each cube contains at least one unit cell, but some will contain more than one cell, since in all cases a cube with 10 Åsides is chosen. We choose one representation where a unit cell begins at $( 0 , 0 , 0 )$ and randomly sample 2 other cubes in this space resulting in a dataset of over 100,000 examples. In this representation, we typically encode the locations of between 20 to 100 atoms, with some having over 200. An advantage of our representation is that we are agnostic to the number of atoms that we are encoding and decoding, something that is difficult for other approaches such as graphs.
+
+Using both these representations, we compute a density field, where each pixel $( i , j , k )$ is defined to have value
+
+$$
+M _ { i , j , k } = \frac { 1 } { \sigma ^ { 3 } ( 2 \pi ) ^ { 3 / 2 } } \sum _ { m } Z _ { m } \mathrm { e x p } \left( - \frac { d ( \vec { Z } _ { m } , ( i , j , k ) ) ^ { 2 } } { 2 \sigma ^ { 2 } } \right)
+$$
+
+Where $d ( \cdot , \cdot )$ represents the Euclidean distance between the two arguments. $\vec { Z } _ { m }$ represents the 3-D coordinates of atom $Z _ { m }$ . We set $\sigma$ to $1 . 0 \mathring \mathrm { A }$ . When plotting, we multiply the output by $\sigma ^ { 3 } ( 2 \pi ) ^ { 3 / 2 }$ . We do this because when $\sigma = 1$ this results in the value of $Z$ (the atomic number) being present at its location in space. Because of the structure of this representation, when the density of atoms increases, there are more interactions making it harder to reconstruct the true identity of an atom. Ultimately, our aim is to be able to reconstruct the location and species of the different atoms in this grid. To that end, we also construct a species matrix, $_ { s }$ , where each voxel is either a 0 or equal to the atomic number of an atom that is within $0 . 5 \mathring \mathrm { \mathrm { A } }$ . We construct two neural networks that attempt to learn $M$ and $\pmb { S }$ in parallel. These two networks are trained together and are detailed in the following section.
+
+# 3.2 NETWORK ARCHITECTURE
+
+We use a variational autoencoder (Kingma & Welling, 2013) to encode and decode our 3-D density maps, $M$ . We use a $\beta$ multiplier on the Kullback-Leibler (KL) loss term to encourage no correlations between different elements of the latent space (Higgins et al., 2017). Our encoder, $E ( \cdot )$ , is a convolutional neural network. The decoder, $D ( \cdot )$ , uses upsampling and convolutions in favor of transposed convolutions (Odena et al., 2016). We use batch normalization (Ioffe & Szegedy, 2015), LeakyReLU activations, and the code is written in Pytorch (Paszke et al., 2017). The optimization is done using the Adam optimizer (Kingma & Ba, 2014). We use a latent space size of 300 for all experiments.
+
+Simultaneously with training the VAE, we train a 3-D U-Net segmentation model, $\mathrm { U } _ { \mathrm { n e t } } ( \cdot )$ , with an attention mechanism to segment the output of the decoder (Ronneberger et al., 2015; Oktay et al., 2018). For accurate segmentation, especially in the case of a repeating lattice, it is important to be able to capture the dependencies between different atoms. We found that a U-Net model worked well, though future work will explore sequentially classifying atoms. Ideally, the primary work is done by the VAE and the role of U-Net is to perform the tedious optimization problem of recovering the species identity and locations that is most consistent with the reconstructed density field.
+
+We include a weighted (by $\gamma$ ) loss from the segmentation in the loss of the encoder/decoder. In our experiments, we set $\gamma$ to 0.1. We experimented with $\gamma = 0$ and $\gamma = 0 . 3 3$ and found that 0.1 proved an acceptable intermediate. With $\gamma = 0 . 3 3$ we found slightly improved segmentation results but worse density reconstruction results. When we completely removed the effect of the species loss from the density reconstruction, species reconstruction results degraded.This allows us to train the entire network in an end-to-end fashion. The entire model is shown in Fig. 2.
+
+We use three terms in the loss function for the VAE with the most weight given to the reconstruction of the density matrices. The segmentation network is only concerned with the final segmentation of the reconstruction from the decoder. Currently, we treat each atom type as a different class, with an additional (most common) class for “no atom.” The loss function used for the VAE is
+
+$$
+\mathcal { L } _ { \mathrm { V A E } } = L _ { \mathrm { R E } } ( \hat { M } , M ) + \beta ( D _ { \mathrm { K L } } ( q ( \mathbf { z } | M ) | | p ( \mathbf { z } ) ) ) + \gamma L _ { \mathrm { B C E } } ( \hat { S } , S ) .
+$$
+
+The first term is the reconstruction error and the third term is the binary cross entropy loss from the segmentation. The second term is the Kullback-Leibler divergence between the prior (set to $p ( \mathbf { z } ) \stackrel { - } { = } \mathcal { N } ( 0 , 1 ) )$ and $q ( z | M )$ the approximate posterior of the latent vector given input $M$ . We use a loss given by $\mathcal { L } _ { \mathrm { U - N e t } } = L _ { \mathrm { B C E } } ( \hat { S } , S )$ for the segmentation. In the above expression, $M$ is the input density field. $\mathbf { z } = E ( M )$ and $\hat { M } = D ( \pmb { \mathrm { z } } )$ is the reconstructed density field. The variable $_ { s }$ represents a 1-hot species matrix. Lastly, $\hat { \boldsymbol { S } } = \mathrm { U } _ { \mathrm { n e t } } \left( \hat { \boldsymbol { M } } \right)$ represents the probability matrix from the segmentation routine, which will be of shape: [ba $\mathrm { c h } \times \mathrm { c l a s s e s } \times \mathrm { x } \mathrm { - d i m } \times \mathrm { y } \mathrm { - d i m } \times \mathrm { z } \mathrm { - d i m } ]$ .
+
+# 4 RESULTS
+
+We find that we are able to accurately encode and decode 3-D representations of density fields (see Figs. 3 and S8). Using the segmentation network, we segment the output of the decoder into distinct atoms. Using a trained network, we show that random samples from the latent space decode to samples that obey many of the same statistics as the training distribution (see Fig. 5 and Fig. S7). Additionally, in the case of a repeating unit cell, we alter our training routine to condition the generation of crystals on the largest atomic number present.
+
+# 4.1 PLACEMENT OF ATOMS
+
+Using the output of the segmentation network, we take the $\tilde { \bf S } = \mathrm { a r g m a x } ( \hat { \bf S } )$ . From this representation, we find the connected components and use majority voting to assign each cluster an atom identity (see Appendix for details). In Fig. 3 (and Fig.S8) we show the accuracy of all top-1 predictions. We compare the results of our segmented matrix, S˜ with the true values, S. From the center of mass of each predicted atom $i$ , we compute the distance to the nearest true atom as follows
+
+$$
+\begin{array} { r } { \operatorname* { m i n } _ { j } \ d ( \tilde { \bf S } _ { i } , { \bf S } _ { j } ) \forall \ j \ \mathrm { a n d } \operatorname* { m i n } _ { i } \ d ( \tilde { \bf S } _ { i } , { \bf S } _ { j } ) \ \forall \ i . } \end{array}
+$$
+
+Table 1: Location and species reconstruction error. $P$ denotes prediction and $T$ denotes target. Distances in angstrom. For $Z$ reconstruction, we show the percentile at each absolute difference.   
+Locations   
+
+<table><tr><td>Percentile</td><td>P→T(A)</td><td>T→P(A)</td></tr><tr><td>0.</td><td>4.31×10-4</td><td>5.47×10-4</td></tr><tr><td>10.</td><td>5.03 ×10-2</td><td>5.02 × 10-2</td></tr><tr><td>20.</td><td>7.04 × 10-2</td><td>7.05 ×10-2</td></tr><tr><td>30.</td><td>9.12 × 10-2</td><td>9.13 × 10-2</td></tr><tr><td>40.</td><td>1.14 × 10-1</td><td>1.14 × 10-1</td></tr><tr><td>50.</td><td>1.36 × 10-1</td><td>1.37 × 10-1</td></tr><tr><td>60.</td><td>1.60 × 10-1</td><td>1.61 × 10-1 1.94 × 10-1</td></tr><tr><td>70. 80.</td><td>1.94 × 10-1 2.48 × 10-1</td><td>2.50 ×10-1</td></tr><tr><td>90. 100.</td><td>3.94 × 10-1 2.59</td><td>4.03 × 10-1 1.89</td></tr><tr><td>Species Abs.Diff.in Z</td><td>Percent</td><td></td></tr><tr><td>0</td><td>66.8 %</td><td></td></tr><tr><td>1</td><td>25.1 %</td><td></td></tr><tr><td>2</td><td>5.8 %</td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td>&gt;3</td><td>2.2 %</td><td></td></tr></table>
+
+Similarly, we can compute the distance from each true atom to the nearest predicted atom. By computing this metric in both directions, we are able to
+
+verify that our model is placing atoms in the correct locations but only in those locations.
+
+# 4.2 ACCURACY ON A UNIT CELL
+
+In Fig. 3 we plot the results of applying our model to single unit cells of crystals (see also Table 1). We find out model is able to very accurately segment the locations of atoms with nearly $9 9 \%$ of atoms placed within $0 . 5 \mathring \mathrm { \mathrm { A } }$ of their true location. Nearly $90 \%$ of unit cells are reconstructed with the correct number of atoms and $9 7 \%$ of unit cells are reconstructed with less than 2 atoms extra or missing. $66 \%$ of species are correctly classified in the test set, with nearly 100 possible classes. When an atom is incorrectly classified, it is usually by one or two atomic numbers (see Table 1). Often adjacent elements (with atomic numbers that differ by 1) have very different chemical properties. We retrained the network to predict atomic group (where elements in the same group tend to have more similar properties) and found $93 \%$ accuracy. We report accuracy on $Z$ as this is a more difficult problem and in both cases we are still unable to reconstruct crystals with the accuracy to relax in a DFT calculation. Missed atoms typically occur near the boundary.
+
+Next, we will discuss the same network applied to repeating unit cells. In all cases, the results for single unit cells are improvements over the results of multiple unit cells. For most figures, there are corresponding panels between the single unit cell and repeated cell results.
+
+# 4.3 ACCURACY ON REPEATING UNIT CELLS
+
+In Fig. S8C we show the percentiles of all pairwise minimum distances in our reconstructed samples. We find that $50 \%$ of all reconstructed atoms are in $0 . 2 \mathring \mathrm { A }$ . For both directions, the $7 5 ^ { \mathrm { t h } }$ percentile error was under $0 . 2 5 \mathring { \mathrm { A } }$ and the $9 0 ^ { \mathrm { t h } }$ percentile of reconstructed atoms were within $0 . 5 \mathring \mathrm { \mathrm { A } }$ . For predicted atoms that are within $0 . 5 \mathring \mathrm { \mathrm { A } }$ of a true atom’s location, we find that $6 5 . 4 \%$ of the time our prediction matches the atomic number exactly Fig. S8E. Again, nearly all errors occur near the boundary.
+
+![](images/400aaa0bcf44c5422a69c5d6e8694c2f1e369a14faa43f642b44c960c6403cd4.jpg)  
+Figure 5: Decode random latent space vectors. (A) We look at the spacing between nearest atoms from random draws from the latent space compared to those from real crystal structures. In blue we show the distribution of random reconstructions. In red we show the distribution of true inter-atomic spacing. (B) For 5 different random latent space vectors, we show the reconstructed density field and the resulting segmentation. Notice that in some cases small amounts of density are predicted but are not segmented into an atom (for example, in columns 3 and 4).
+
+For 120 randomly selected reconstructed crystals from the test set, we compare the number of atoms after segmentation with the true number (Fig. S8D and Fig. 3B). In Fig. S8E we compare the predicted species compared with the species of the nearest true atom, independent of the distance to the nearest atom. We find that based on the results of Fig. S8, our current model is able to more accurately reconstruct the locations of atoms than obtain their true atomic number. This makes sense, given the enormous number of possible classes. However for repeating unit cells, when an atom is correctly predicted to be within $0 . 3 3 \mathring { \mathrm { A } }$ of a true atom location nearly $70 \%$ of the time the atom is assigned exactly the correct $Z$ value. The correlation between the true and predicted value is 0.98 suggesting that when the network makes an incorrect assessment, it chooses a nearby atomic number.
+
+Further improvements in this placement and identification of atoms is necessary in achieving crystals that will appropriately relax in a DFT simulation for the calculation of quantum mechanical properties. However, a very exciting immediate application of this work is in random structure searching Pickard & Needs (2011).
+
+# 4.4 LATENT SPACE INTERPOLATION
+
+We encode two different true density maps into vectors $\mathbf { z } _ { 1 }$ and $\mathbf { z } _ { 2 }$ , respectively. We then linearly interpolate between these two values in latent space, constructing intermediate vectors $\tilde { \mathbf { z } } _ { i }$ . We decode the resulting latent space vectors which result in predicted density maps, $D ( \tilde { \mathbf { z } } )$ . Passing these into the trained segmentation routine, we find that intermediate results segment into atoms (see results on a single unit cell in Fig. 3 and Fig. 4). See results on a repeating lattice in Figs. S9 and S11)1.
+
+# 4.5 RANDOM DRAWS
+
+We can randomly sample a latent space vector $\mathbf { z } \sim \mathcal { N } ( 0 , 1 )$ and we then decode the output. We do this for both single unit cells as well as for repeating lattices (see Appendix). Random structure searching is an important area of material science research an exciting direction for this work Pickard & Needs (2011). Using the network trained to encode and decode single unit cells, we decode a $\mathbf { z } \sim \mathcal { N } ( 0 , 1 )$ .
+
+In Fig. 5 we show the decoded density fields along with the resulting segmented output. There are a few desirable features: single cells are centered, atoms tend to be of similar atomic number, even in different parts of the reconstructed output, and atoms are not ever too close together.
+
+# 5 CONCLUSIONS AND FUTURE WORK
+
+The ability to encode and decode 3-D structures is a very interesting direction of recent work and increasingly important in helping create models that can understand the world that we live in. In current material design, a lot of focus has been on molecules where the 3-D structure can be safely ignored. However, in many cases this is not the case. We do not know of an effective data representation for these 3-D molecules and find that by directly utilizing a proxy for density we are able to encode and decode the geometry of these molecules.
+
+An important future direction of research is to come up with successful representations for encoding crystal structures such that they can be easily encoded and decoded. Coming up with a representation of crystal unit cells (and 3-D structures in general) so that decoded molecules are physically plausible is an important aspect that needs to be carefully considered.
+
+Our approach is currently unable to generate molecules that are physically stable, but there are promising directions in this direction. Using ideas similar to G-SchNet, using the decoded density field, atoms can be placed sequentially, conditioned on the placement of previous atoms (Gebauer et al., 2019). Working towards decoding molecules that are able to relax is a very exciting direction.
+
+Another improvement would be to alter the structure of our encoder/decoder. Currently, we use standard 3-D convolutions. However, using SE(3) equivariant kernels from M. Weiler et al. is a promising direction for improved performance (Weiler et al., 2018). We feel that our current approach could be extended beyond the domain of material science, as we are able to encode a 3-D distance map, this approach could be broadly applied to many objects. In essence, we are able to learn a distance transform from an object. This is more general than for encoding and decoding atomic structures. To try to facilitate further research in the creation of 3-D representation of more complex atomic structures, we will release the code shortly.
+
+# REFERENCES
+
+Panos Achlioptas, Olga Diamanti, Ioannis Mitliagkas, and Leonidas Guibas. Learning representations and generative models for 3d point clouds. arXiv preprint arXiv:1707.02392, 2017.
+
+Zaccary Alperstein, Artem Cherkasov, and Jason Tyler Rolfe. All smiles variational autoencoder, 2019.
+
+Rim Assouel, Mohamed Ahmed, Marwin H Segler, Amir Saffari, and Yoshua Bengio. Defactor: Differentiable edge factorization-based probabilistic graph generation. arXiv preprint arXiv:1811.09766, 2018.
+
+Andrew Brock, Theodore Lim, James M Ritchie, and Nick Weston. Generative and discriminative voxel modeling with convolutional neural networks. arXiv preprint arXiv:1608.04236, 2016.
+
+Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale gan training for high fidelity natural image synthesis. arXiv preprint arXiv:1809.11096, 2018.
+
+Chi Chen, Weike Ye, Yunxing Zuo, Chen Zheng, and Shyue Ping Ong. Graph networks as a universal machine learning framework for molecules and crystals. Chemistry of Materials, 31(9):3564–3572, 2019.
+
+Ricky TQ Chen, Xuechen Li, Roger Grosse, and David Duvenaud. Isolating sources of disentanglement in vaes.
+
+Xi Chen, Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. InfoGAN: Interpretable representation learning by information maximizing generative adversarial nets. In D. D. Lee, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances In Neural Information Processing Systems 29, pp. 2172–2180. Curran Associates, Inc., 2016.
+
+Özgün Çiçek, Ahmed Abdulkadir, Soeren S Lienkamp, Thomas Brox, and Olaf Ronneberger. 3d u-net: learning dense volumetric segmentation from sparse annotation. In International conference on medical image computing and computer-assisted intervention, pp. 424–432. Springer, 2016.
+
+Ekin D Cubuk, Austin D Sendek, and Evan J Reed. Screening billions of candidates for solid lithium-ion conductors: A transfer learning approach for small data. The Journal of chemical physics, 150(21):214701, 2019.
+
+Niklas WA Gebauer, Michael Gastegger, and Kristof T Schütt. Symmetry-adapted generation of 3d point sets for the targeted discovery of molecules. arXiv preprint arXiv:1906.00957, 2019.
+
+Rafael Gómez-Bombarelli, Jennifer N Wei, David Duvenaud, José Miguel Hernández-Lobato, Benjamín Sánchez-Lengeling, Dennis Sheberla, Jorge Aguilera-Iparraguirre, Timothy D Hirzel, Ryan P Adams, and Alán Aspuru-Guzik. Automatic chemical design using a data-driven continuous representation of molecules. ACS central science, 4(2):268–276, 2018.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.
+
+Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. beta-vae: Learning basic visual concepts with a constrained variational framework. ICLR, 2(5):6, 2017.
+
+Moritz Hoffmann and Frank Noé. Generating valid euclidean distance matrices, 2019.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+John J Irwin, Teague Sterling, Michael M Mysinger, Erin S Bolstad, and Ryan G Coleman. Zinc: a free tool to discover chemistry for biology. Journal of chemical information and modeling, 52(7): 1757–1768, 2012.
+
+Anubhav Jain, Shyue Ping Ong, Geoffroy Hautier, Wei Chen, William Davidson Richards, Stephen Dacek, Shreyas Cholia, Dan Gunter, David Skinner, Gerbrand Ceder, et al. Commentary: The materials project: A materials genome approach to accelerating materials innovation. Apl Materials, 1(1):011002, 2013.
+
+Wengong Jin, Regina Barzilay, and Tommi Jaakkola. Junction tree variational autoencoder for molecular graph generation. arXiv preprint arXiv:1802.04364, 2018.
+
+Hyunjik Kim and Andriy Mnih. Disentangling by factorising. arXiv preprint arXiv:1802.05983, 2018.
+
+Taeksoo Kim, Moonsu Cha, Hyunsoo Kim, Jung Kwon Lee, and Jiwon Kim. Learning to discover cross-domain relations with generative adversarial networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1857–1865. JMLR. org, 2017.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Matt J Kusner, Brooks Paige, and José Miguel Hernández-Lobato. Grammar variational autoencoder. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1945– 1954. JMLR.org, 2017.
+
+Clare F Macrae, Ian J Bruno, James A Chisholm, Paul R Edgington, Patrick McCabe, Elna Pidcock, Lucia Rodriguez-Monge, Robin Taylor, J van de Streek, and Peter A Wood. Mercury csd 2.0– new features for the visualization and investigation of crystal structures. Journal of Applied Crystallography, 41(2):466–470, 2008.
+
+Kaushalya Madhawa, Katushiko Ishiguro, Kosuke Nakago, and Motoki Abe. Graphnvp: An invertible flow model for generating molecular graphs. arXiv preprint arXiv:1905.11600, 2019.
+
+Elman Mansimov, Omar Mahmood, Seokho Kang, and Kyunghyun Cho. Molecular geometry prediction using a deep generative graph neural network. arXiv preprint arXiv:1904.00314, 2019.
+
+Daniel Maturana and Sebastian Scherer. Voxnet: A 3d convolutional neural network for real-time object recognition. In 2015 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 922–928. IEEE, 2015.
+
+Hsien-Yu Meng, Lin Gao, Yu-Kun Lai, and Dinesh Manocha. Vv-net: Voxel vae net with group convolutions for point cloud segmentation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 8500–8508, 2019.
+
+Thu Nguyen-Phuoc, Chuan Li, Lucas Theis, Christian Richardt, and Yong-Liang Yang. Hologan: Unsupervised learning of 3d representations from natural images. arXiv preprint arXiv:1904.01326, 2019.
+
+Guangda Niu, Xudong Guo, and Liduo Wang. Review of recent progress in chemical stability of perovskite solar cells. Journal of Materials Chemistry A, 3(17):8970–8980, 2015.
+
+Asma Nouira, Jean-Claude Crivello, and Nataliya Sokolovska. Crystalgan: Learning to discover crystallographic structures with generative adversarial networks. arXiv preprint arXiv:1810.11203, 2018.
+
+Augustus Odena, Vincent Dumoulin, and Chris Olah. Deconvolution and checkerboard artifacts. Distill, 2016. doi: 10.23915/distill.00003. URL http://distill.pub/2016/ deconv-checkerboard.
+
+Ozan Oktay, Jo Schlemper, Loic Le Folgoc, Matthew Lee, Mattias Heinrich, Kazunari Misawa, Kensaku Mori, Steven McDonagh, Nils Y Hammerla, Bernhard Kainz, et al. Attention u-net: Learning where to look for the pancreas. arXiv preprint arXiv:1804.03999, 2018.
+
+Shyue Ping Ong, William Davidson Richards, Anubhav Jain, Geoffroy Hautier, Michael Kocher, Shreyas Cholia, Dan Gunter, Vincent L Chevrier, Kristin A Persson, and Gerbrand Ceder. Python materials genomics (pymatgen): A robust, open-source python library for materials analysis. Computational Materials Science, 68:314–319, 2013.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017.
+
+Chris J Pickard and RJ Needs. Ab initio random structure searching. Journal of Physics: Condensed Matter, 23(5):053201, 2011.
+
+Pavel G Polishchuk, Timur I Madzhidov, and Alexandre Varnek. Estimation of the size of drug-like chemical space based on gdb-17 data. Journal of computer-aided molecular design, 27(8):675–679, 2013.
+
+Raghunathan Ramakrishnan, Pavlo O Dral, Matthias Rupp, and O Anatole Von Lilienfeld. Quantum chemistry structures and properties of 134 kilo molecules. Scientific data, 1:140022, 2014.
+
+Ali Razavi, Aaron van den Oord, and Oriol Vinyals. Generating diverse high-fidelity images with vq-vae-2. arXiv preprint arXiv:1906.00446, 2019.
+
+David Rolnick, Priya L Donti, Lynn H Kaack, Kelly Kochanski, Alexandre Lacoste, Kris Sankaran, Andrew Slavin Ross, Nikola Milojevic-Dupont, Natasha Jaques, Anna Waldman-Brown, et al. Tackling climate change with machine learning. arXiv preprint arXiv:1906.05433, 2019.
+
+O. Ronneberger, P.Fischer, and T. Brox. U-net: Convolutional networks for biomedical image segmentation. In Medical Image Computing and Computer-Assisted Intervention (MICCAI), volume 9351 of LNCS, pp. 234–241. Springer, 2015. URL http://lmb.informatik.uni-freiburg. de/Publications/2015/RFB15a. (available on arXiv:1505.04597 [cs.CV]).
+
+Kristof T Schütt, Huziel E Sauceda, P-J Kindermans, Alexandre Tkatchenko, and K-R Müller. Schnet–a deep learning architecture for molecules and materials. The Journal of Chemical Physics, 148(24):241722, 2018.
+
+Daniel Schwalbe-Koda and Rafael Gómez-Bombarelli. Generative models for automatic chemical design. arXiv preprint arXiv:1907.01632, 2019.
+
+Marwin HS Segler, Thierry Kogej, Christian Tyrchan, and Mark P Waller. Generating focused molecule libraries for drug discovery with recurrent neural networks. ACS central science, 4(1): 120–131, 2017.
+
+Kihyuk Sohn, Honglak Lee, and Xinchen Yan. Learning structured output representation using deep conditional generative models. In Advances in neural information processing systems, pp. 3483–3491, 2015.
+
+Daniel P Tabor, Loïc M Roch, Semion K Saikin, Christoph Kreisbeck, Dennis Sheberla, Joseph H Montoya, Shyam Dwaraknath, Muratahan Aykol, Carlos Ortiz, Hermann Tribukait, et al. Accelerating the discovery of materials for clean energy in the era of smart automation. Nature Reviews Materials, 3(5):5, 2018.
+
+Diego Valsesia, Giulia Fracastoro, and Enrico Magli. Learning localized generative models for 3d point clouds via graph convolution. 2018.
+
+Maurice Weiler, Mario Geiger, Max Welling, Wouter Boomsma, and Taco Cohen. 3d steerable cnns: Learning rotationally equivariant features in volumetric data. In Advances in Neural Information Processing Systems, pp. 10381–10392, 2018.
+
+David Weininger. Smiles, a chemical language and information system. 1. introduction to methodology and encoding rules. Journal of chemical information and computer sciences, 28(1):31–36, 1988.
+
+Jiajun Wu, Chengkai Zhang, Tianfan Xue, William T Freeman, and Joshua B Tenenbaum. Learning a probabilistic latent space of object shapes via 3d generative-adversarial modeling. In Advances in Neural Information Processing Systems, pp. 82–90, 2016.
+
+Wenxuan Wu, Zhongang Qi, and Li Fuxin. Pointconv: Deep convolutional networks on 3d point clouds, 2018.
+
+Tian Xie and Jeffrey C Grossman. Crystal graph convolutional neural networks for an accurate and interpretable prediction of material properties. Physical review letters, 120(14):145301, 2018.
+
+Guandao Yang, Xun Huang, Zekun Hao, Ming-Yu Liu, Serge Belongie, and Bharath Hariharan. Pointflow: 3d point cloud generation with continuous normalizing flows. arXiv preprint arXiv:1906.12320, 2019.
+
+Xiufeng Yang, Jinzhe Zhang, Kazuki Yoshizoe, Kei Terayama, and Koji Tsuda. Chemts: an efficient python library for de novo molecular generation. Science and technology of advanced materials, 18(1):972–976, 2017.
+
+Jiaxuan You, Bowen Liu, Zhitao Ying, Vijay Pande, and Jure Leskovec. Graph convolutional policy network for goal-directed molecular graph generation. In Advances in Neural Information Processing Systems, pp. 6410–6421, 2018.
+
+Jun-Yan Zhu, Zhoutong Zhang, Chengkai Zhang, Jiajun Wu, Antonio Torralba, Josh Tenenbaum, and Bill Freeman. Visual object networks: image generation with disentangled 3d representations. In Advances in Neural Information Processing Systems, pp. 118–129, 2018.
+
+# A SUPPLEMENTAL INFORMATION
+
+A.1 VIDEOS
+
+See anonymoized project site at: https://sites.google.com/view/ encode-decode-3d-crystals/home.
+
+# B CHOICE OF DATA REPRESENTATION
+
+We choose to use a 10 Angstrom cutoff as it kept over $90 \%$ of the data we had available without becoming too computationally demanding, as we needed to maintain a relatively small grid spacing between voxels (0.33 Angstrom). Because the problem is 3-D, a $3 0 ^ { 3 }$ input is equivalent to a $1 6 4 \times$ 164 image, in terms of pixels.
+
+# C COMPARISON OF 1-D, 2-D, AND 3-D REPRESENTATIONS
+
+For small molecules, 1-D SMILES and 2-D graph based representations have been very effectively used for property prediction and for molecule generation tasks. In a SMILES representation, a specific grammar is learned but from a valid string, a specific molecule is generated based on the bond arrangement Weininger (1988); Gómez-Bombarelli et al. (2018). Similarly, a graph based representation is able to place atoms in space without specifically assigning each atom a specific coordinate Jin et al. (2018). Additionally, graph representations have been shown to be successful for property prediction of crystals Xie & Grossman (2018), but not for generating crystals. For small molecules, these representations have proved very effective, especially since both these representations effectively reduce the dimension of the problem.
+
+Specifically, SMILES and graph representations both do not encode the specific spatial arrangement of atoms. Instead, these representations are cleverly created in such a way that the spatial arrangements can reconstructed. Unfortunately, for many larger molecules these representations are not sufficient. Therefore, we focus on developing a representation that is able to directly reconstruct both species and locations in a 3-D space.
+
+# D SPECIES PREDICTION
+
+Each voxel is assigned an identity based on the argmax of the U-Net. The background has label 0. First, we find all connected components of non-background voxels. For each connected component, we tabulate the species predicted at each voxel and each cluster is assigned an identity baased on the majority vote. The location is based on the centroid of the cluster. We experimented with more complicated procedures (such as weighting by the probability vector) and did not find a meaningful improvement.
+
+# E TRAINING DETAILS
+
+We used a Tesla V100 for training. We used a learning rate of 1e-5 and a batch size of 24.
+
+# E.1 NETWORK DETAILS
+
+# E.1.1 ENCODER
+
+3D convolution, kernel size of 5 and stride of 2. 16 channels.   
+Batch Norm and LeakyReLU activation.   
+3D convolution, kernel size of 3 and stride of 1. 32 channels.   
+Batch Norm and LeakyReLU activation.   
+3D convolution, kernel size of 3 and stride of 1. 64 channels.   
+Batch Norm and LeakyReLU activation.   
+3D convolution, kernel size of 3 and stride of 2. 128 channels. Batch Norm and LeakyReLU activation.   
+Fully connected layer with a bottleneck size 300.
+
+# E.1.2 DECODER
+
+Fully connected layer.   
+Reshape to 128 5,5,5 Trlinear upsample by a factor of two.   
+Conv3D with 64 channels, kernel size of 5, leakyReLU.   
+Trlinear upsample by a factor of two.   
+Conv3D with 32 channels, kernel size of 5, leakyReLU.   
+Trlinear upsample by a factor of two.   
+Conv3D with 16 channels, kernel size of 4, leakyReLU.   
+Conv3D with 1 channels, kernel size of 4, ReLU.
+
+# F RESULTS FROM THE ENCODER-DECODER
+
+Our encoder-decoder architecture is able to accurately reconstruct the voxel-wise density (Fig. S8A and Fig. S6). We find a strong correlation between the predicted and target voxel value (Fig. S6A). This is essential for achieving an accurate segmentation of the correct atoms and their corresponding positions. Due to the strong penalty on the KL term we find that there is an increased spread in the resulting predictions when attempting to encode and decode repeating unit cells. This is less of an issue when encoding and decoding single unit cells.
+
+# G ACCURACY OF RANDOM DRAWS IN A REPEATING LATTICE
+
+To test whether random samples from the latent space, $\tilde { \mathbf { z } }$ , decode to physically realistic molecules, we trained a discriminator. We trained an auto-encoder that was able to very accurately reconstruct molecules by greatly reducing the penalty on $\beta$ (see Fig. S12). Then, we compute real latent space representations of our different molecules, $\mathbf { z }$ . We then draw a $\lambda \sim U ( 0 , 1 )$ and construct a new latent space vector
+
+$$
+\hat { \mathbf { z } } = \lambda \widetilde { \mathbf { z } } _ { \mathcal { N } ( 0 , 1 ) } + ( 1 - \lambda ) \mathbf { z } _ { \mathrm { r e a l } }
+$$
+
+where $\tilde { \mathbf { z } }$ is a random sample from a unit normal and $\mathbf { z } _ { \mathrm { r e a l } }$ is a random “true” latent space. We pass this through the decoder and provide this a label $( 1 - \lambda , \lambda )$ . We then randomly draw $\mathbf { z } \sim \mathcal { N } ( 0 , 1 )$ from our trained network and pass this reconstruction $\tilde { D }$ into the discriminator network, which outputs a prediction of the distance from a true crystal reconstruction versus a random draw from a latent space of a previously trained network. Applying this network to random samples from $\mathbf { z } \sim \mathcal { N } ( 0 , 1 )$ we get a mean value of 0.84 with a standard deviation of 0.05. For true decoded samples, we find a mean value of 0.90 with a standard deviation of 0.01. In Fig. S13, we show results of the trained network and predictions on three different datasets. We find that the target latent space decodes to high-scoring samples (see Fig. S13B) and that out of distribution samples typically decode to much lower scores.
+
+# G.1 CONDITIONAL VAE
+
+Moving forward, an important step will be creating structures that have specific chemical properties. Moving towards this direction, we attempt to condition the generation of molecules on the largest species present (Sohn et al., 2015). To do this, we multiply the input and output of the bottleneck by the largest present density. By doing this, we are still able to get the network to train but find that we are able to control the magnitude of the resulting density field without perturbing the geometry (see Fig. S10B). We attempted to condition the encoder and decoder by concatenation though we found this was not sufficient to generate density fields with the desired property.
+
+The ability to condition on specific properties has obvious applications in the targeted generation of molecules. In this case, we choose to condition on the largest present density as a way to generate molecules that do not have an atom with more than a specified maximum atomic number present. We find that by varying different parameters in the latent space, some vary the field in such a way that appears to correlate with the location of atoms (see Fig. S10C,D). However, unlike as in work on 2-D problems, the changes in the 3-D scalar field are much harder to interpret (Chen et al., 2016; Higgins et al., 2017). Future work will attempt to use improved factorizing techniques (Kim & Mnih, 2018; Chen et al.). Additionally, one could seek to condition the generation of single unit cells on quantum mechanical properties or by adding an auxiliary loss using the latent space to predict quantum mechanical properties.
+
+![](images/be19653bcf2385458ab0ac12318d2df8c79a55720a0a35e8282bab936bc1eea6.jpg)  
+Figure S6: Accuracy of Model. (A) For each position in 3-D space, we plot the predicted and target density for 4 different random crystals from the test set. The red dashed line is an identity line. (B) For each of the panels in (A), we show 4 different $z$ -slices through the true and predicted density fields. (C) We show the full 3-D reconstruction of the prediction and the true density field.
+
+![](images/1b139b5b1107a8b870c8c2d3fdca120045256bd847635d211975a104fa2e11df.jpg)  
+Figure S7: Random Decoded Samples. We randomly sample the latent space17 $z \sim N ( 0 , 1 )$ . We show a series of examples (from three different views) of different complexity. Note that while symmetry is not preserved, various geometric motifs are.
+
+![](images/2715fa0dbbb0eb4b2e3cfb3e172f54caa3891c68ab33d72ae7e72a19ccbc9435.jpg)  
+Figure S8: Repeating unit cell accuracy. (A) For each position in 3-D space, we compute the difference between the truth and the reconstruction. We show different percentile bands of the reconstruction error between the target and predicted density, plotted using the mean square error (MSE). (B) For the species matrix from U-Net we ask what the error of top-1 predictions is between our predictions and the ground truth. (C) For our segmented matrices, we ask the distance from the nearest segmented atom to the ground truth. We show the distance errors by percentile for both the nearest true atom to each predicted atom and vice-versa (orange and blue, respectively). (D) After segmenting the reconstructed density maps we show the predicted and true number of atoms. (E) We plot the predicted nearest atom species versus the true species of the closest corresponding atom, as long as the distance is less than $0 . 5 \mathring \mathrm { \mathrm { A } }$ . We find $6 5 . 4 \%$ are correctly predicted.
+
+![](images/fec1c70feef090b9665cce8067981581ca15dee97b8ce3a537cf76b0d6cb21e5.jpg)  
+Figure S9: Interpolation between two molecules. In (A) we show the interpolation between two crystal density maps. We show three equally spaced intermediates the corresponding segmentation. In (B), we show the same interpolation but highlight different two dimensional slices (y-axis). Along the $\mathbf { X }$ -axis we label the fraction of the way between the two latent space vectors.
+
+![](images/0e74fa5ac1d8b18c6b8605a9ed9975dcf1137f638af2f6d2e30043233ec50c04.jpg)  
+Figure S10: Conditional generation of molecules. We multiply the input and output of the bottleneck by the maximum density during training. Then, randomly decoding samples of $\alpha \mathbf { z }$ where $\mathbf { z } \sim \mathcal { N } ( 0 , 1 )$ and $\alpha$ is a random target, we find we are able to generate density maps that decode appropriately. If we take a true decoded value and re-scale the output we find we are able to control scale without affecting geometry. (A) We show the target and generated max value. (B) Using an encoded $\mathbf { z }$ , we multiply it by different target values and decode them. We find that we are able to change scale without affecting the geometry. (C) We show a decoded sample. We cut away the right most corner facing the viewer. $\mathbf { \eta } ^ { ( \mathbf { D } ) }$ For the molecule shown in (C), we show the results of varying one value in the latent space from -3 to 3. We plot the difference in the slice when compared the unaltered, decoded, $\mathbf { z }$ for a slice that is in-plane with many atoms.
+
+![](images/d41bbb33b763cb8f62862c4c5f2a3af9df0ae401a41a28355085dcaed57d5822.jpg)  
+Figure S11: Interpolation between two molecules. From $i - v$ we show two views of the output from the segmentation routine decoding the latent space between two different molecules. In the primed corresponding figures we show the density fields that are output by the decoder. We show the output of each grid normalized between 0-1 in blue-green and on a fixed color map in magma. We also vary the opacity to show the locations of predicted atoms.
+
+![](images/c65b020d6341425a2323154867c6b9dc320c173c64607cbc4760c5da8d95cc22.jpg)  
+Figure S12: Results with smaller $\beta$ . We decrease $\beta$ by a factor of 10. By reducing the penalty on the KullbackLeibler (KL) term we are able to generate more accurate reconstructions. However, sampling $\mathbf { z } \sim \mathcal { N } ( 0 , 1 )$ does not fully sample the encoded space of molecules.
+
+![](images/74d7ac4d6d4a712619001bbfdab66d8b49e2b430271ef077a6324faf7e074e45.jpg)  
+Figure S13: $\lambda$ prediction for different samples. Using the network in Fig. S12 we train a discriminator network to predict the “distance” from a real crystal. We apply this discriminator to real decoded samples, random latent space draws, and out of distribution draws (right).
+
+![](images/a2d4e3798b857c00e00b5ddc63e4aa7ddbf927b4e7ead002db0de8bb464bf04d.jpg)  
+Figure S14: Decoded samples of repeating unit cells. Results from the encoder-decoder.
+
+![](images/9e97401d7f06566be399ea91e6d0acb6ec429d04f7c6b3fff01713fa27acdf4f.jpg)  
+Figure S15: Segmented Output from the decoded samples. The segmented output from Fig. S14.

parse/train/S1enmaVFvS/S1enmaVFvS_content_list.json

@@ -0,0 +1,1950 @@
+[
+    {
+        "type": "text",
+        "text": "DATA-DRIVEN APPROACH TO ENCODING AND DECODING 3-D CRYSTAL STRUCTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            826,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative models have achieved impressive results in many domains including image and text generation. In the natural sciences, generative models have lead to rapid progress in automated drug discovery. Many of the current methods focus on either 1-D or 2-D representations of typically small, drug-like molecules. However, many molecules require 3-D descriptors and exceed the chemical complexity of commonly used datasets. We present a method to encode and decode the position of atoms in 3-D molecules along with a dataset of nearly 50,000 stable crystal unit cells that vary from containing 1 to over 100 atoms. We construct a smooth and continuous 3-D density representation of each crystal based on the positions of different atoms. Two different neural networks were trained on a dataset of over 120,000 three-dimensional samples of single and repeating crystal structures. The first, an Encoder-Decoder pair, constructs a compressed latent space representation of each molecule and then decodes this description into an accurate reconstruction of the input. The second network segments the resulting output into atoms and assigns each atom an atomic number. By generating compressed, continuous latent spaces representations of molecules we are able to decode random samples, interpolate between two molecules, and alter known molecules. ",
+        "bbox": [
+            233,
+            270,
+            766,
+            505
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            541,
+            336,
+            556
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative models have recently seen tremendous success in generating 2-D images of every day objects (Kingma & Welling, 2013; Goodfellow et al., 2014; Brock et al., 2018; Razavi et al., 2019). The size and accuracy of generated results has greatly improved to the point where samples from the latent space decode to photo-realistic samples (Brock et al., 2018; Razavi et al., 2019). A very exciting and important future avenue for generative models is the generation of 3-D structures, like in the world around us. Adversarial networks and autoencoders have been extended into 3-D and have shown they are able to encode useful representations of everyday objects (Wu et al., 2016; Zhu et al., 2018; Brock et al., 2016; Achlioptas et al., 2017; Valsesia et al., 2018; Meng et al., 2019; Maturana & Scherer, 2015). Representations using point clouds have gained popularity as a way to capture the distribution of different types of objects (Achlioptas et al., 2017; Yang et al., 2019; Wu et al., 2018). ",
+        "bbox": [
+            174,
+            575,
+            825,
+            715
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As machine learning approaches are able to understand and recreate the underlying distributions for many different types of objects in our world, the application of these tools in the physical sciences is a very exciting direction. A clear field where generative models can have a tremendous impact is in material discovery, which is very important for designing new batteries or carbon capture devices for fighting climate change. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One very successful area of applying generative models to the sciences has been the field of drug discovery (Jin et al., 2018; Gómez-Bombarelli et al., 2018; Assouel et al., 2018) (see Schwalbe-Koda & Gómez-Bombarelli (2019) for an excellent summary of many methods). The success of machine learning in this domain has been enormously helpful as a process that was often painstakingly slow has been rapidly accelerated in searching an unimaginably large space of possible drug compounds, estimate to be up to $1 0 ^ { 6 0 }$ (Polishchuk et al., 2013). Additionally, excellent datasets such as QM9 (Ramakrishnan et al., 2014) and ZINC (Irwin et al., 2012) which contain molecules of interest along with their precomputed properties have allowed for comparing different methods and developing state-of-the-art tools. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/e5d0c45c3fd1f05a755aa39ebe59a8974cd4a06889e59019c5f4e54b12ef09f7.jpg",
+        "image_caption": [
+            "Figure 1: Examples of crystal unit cells. Each example shows the unit cell of a crystal. Different colors represent different atomic species. A red, green, and blue line represent the 3 axes of the crystal. Note that they vary in length and angle. Additionally, some unit cells have just one or two atoms while others have nearly 100. Visualizations were made with Mercury (Macrae et al., 2008). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            279,
+            111,
+            727,
+            270
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "By learning a compressed, useful, latent space representation, this enormous space of molecules can be embedded in a simpler latent space that is easier to search Kusner et al. (2017). Using generative models, compounds hypothesized to have specific properties can be rapidly generated and then a targeted subset of these can be experimentally tested. For example, in Gómez-Bombarelli et al. (2018), an auxiliary property prediction task is introduced for a network separate from the encoder/decoder. This allows for optimization of properties in the latent space and then the resulting latent space vector is decoded into a candidate molecule that can undergo more rigorous computational testing before it is experimentally synthesized. Using a graph representation and reinforcement learning, You et al propose a novel method for molecule generation with specific properties You et al. (2018). ",
+        "bbox": [
+            174,
+            375,
+            825,
+            500
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Most of the work combining generative models with chemical discovery has focused on molecules that can be represented in either 1 dimension (such as a SMILES string (Weininger, 1988)) or by leveraging a 2 dimensional representation of a molecule, such as a graph. While 1-D and 2-D representations have been very successful for many drug compounds, these representations are not sufficient to describe all molecules. For example, it is possible for different molecules, with very different properties, to have identical graphs (Gebauer et al., 2019). Additionally, there are more complex classes of compounds where the 3-D structure is integral to the molecule’s properties. Therefore, in this work we focus on generating representations of molecules where the 3-D information is essential for reconstruction. Generating 3-D structures is still a relatively nascent field, when compared to image and text generation. The data requirements for modeling 3-D structures are larger than their 2-D counterparts and there are fewer standard datasets (Nguyen-Phuoc et al., 2019). Additionally, to measure the properties of inorganic materials (like those considered here), costly DFT calculations are needed which require precise 3-D locations. There is an extra dimension in 3-D problems, providing additional symmetries that often need to be learned (Weiler et al., 2018). New work from generates adjacency matrices which are, by construction, invariant to rotation Hoffmann & Noé (2019). In either case, for the automatic generation of viable complex 3-D structures of inorganic compounds one needs to accurately generate the locations of many atoms in 3-D space. ",
+        "bbox": [
+            173,
+            507,
+            825,
+            756
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus specifically on proposing an effective 3-D representation for this class of molecules that can not be represented in the same ways as many smaller molecules. We hope to promote work in this still nascent field which has yet to see the same level of success as the generation of smaller molecules. In the Appendix, we have provided a clear comparison with 1-D and 2-D representations. Currently, no direct comparisons are possible. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In addition to drug discovery, a promising avenue for molecular design is for minimizing environmental impact through the design of more efficient or more environmentally friendly compounds for a variety of applications. Designing more efficient materials for photo-voltaic panels and more environmentally friendly materials for batteries are both very exciting research directions for using machine learning as a tool towards mitigating climate change (Niu et al., 2015; Tabor et al., 2018; Gebauer et al., 2019; Rolnick et al., 2019). Many of the compounds of interest are crystal structures made of single small sub-units that repeat in all directions. This sub-unit is referred to as a “unit cell” and can vary in size and shape as well as internal arrangement and chemical composition. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this work, we present a method for encoding and decoding a very important set of 3-D molecules that can not be represented using standard methods used for drug-like molecules. We directly encode and decode 3-D volumes of density from two different data representations. In the first, we use single unit cells, as shown in Fig. 1. Each unit cell is centered in the cube, but randomly rotated. In the second representation, we repeat the unit cell along all three axes such that the resulting sampled cube contains repeated unit cells of crystal structures, like those shown in Fig. 2 (and Fig. S6C). Many very interesting and important molecules, such as materials for solar panels or batteries, are composed of crystalline units. We train a variational autoencoder (VAE) and a network to segment the decoded output based on the true locations of atoms in tandem. By coupling these two tasks, we are able to accurately encode and decode 3-D atomic positions and species. As far as we are aware, this is not an explored direction as a means to represent molecules for encoding and decoding their 3-D arrangement. We summarize our contribution as follows: ",
+        "bbox": [
+            174,
+            138,
+            825,
+            304
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• We propose a method for encoding and decoding 3-D molecules that can not be represented by traditional string or graph based approaches. By jointly training a VAE and a segmentation network on the output of the decoder, we train the entire network in an end-to-end fashion. • We consider two different problems: (1) encoding and decoding single unit cells and (2) encoding and decoding repeated unit cells. In both cases we accurately reconstruct the locations of atoms. We also achieve good results in atomic species identification and future work will improve this front. By sampling from $\\mathbf { z } \\sim \\mathcal { N } ( 0 , 1 )$ , we generate complex structures that have physically realistic spacing between atoms. ",
+        "bbox": [
+            215,
+            318,
+            825,
+            438
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/104ee9745a030128516aff01dec068a3c52f5f1e3ae3b5a46ab8a19c21a3981b.jpg",
+        "image_caption": [
+            "Figure 2: Network Architecture. We encode and decode a $3 0 \\times 3 0 \\times 3 0$ voxel grid representing $1 0 \\mathring \\mathrm { A }$ on each side. Each voxel contains the value of the density. The output of the decoder is passed into a 3-D U-Net Çiçek et al. (2016). We train the two models in parallel. In the schematic, we show the crystal represented as a repeated unit cell rather than a single unit cell. The black arrows indicate deterministic transformations. From the cif file, the species matrix is constructed. From this, the density matrix is computed. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            462,
+            803,
+            598
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 PRELIMINARIES AND RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            717,
+            524,
+            733
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There are many classes of compounds that are of interest for data-driven discovery. There has been significant work exploring the generation of molecules with potential medicinal properties. These molecules tend to be organic molecules and can be represented efficiently using a string or a graph. A more complex class of molecules are inorganic crystal structures which vary in complexity across many different axes. Crystals are materials that are made up of a repeating pattern of a simpler “unit cell.” Crystal structures are of key interest for many environmental problems, such as materials for solar panels and batteries (Niu et al., 2015). ",
+        "bbox": [
+            174,
+            750,
+            825,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In contrast to problems in drug discovery, many crystals are not composed solely of organic molecules. Crystals commonly contain many heavy (non-Hydrogen) atoms which make various quantum mechanical calculations of their energetic properties very difficult and time consuming. For example, the common benchmark dataset QM9 for predicting quantum mechanical properties includes over 130,000 molecules contains fewer than 9 “heavy” atoms (Ramakrishnan et al., 2014). ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/e317eecfd7e520c0280f7a5951d8a0597f0e801dce96c75eea954c4cab6faeda.jpg",
+        "image_caption": [
+            "Figure 3: Single unit cell accuracy. (A) We show the voxel wise reconstruction error (plotted with mean square error) during training. (B) For random molecules in the test set, we plot the number of true atoms and the number of recovered atoms after segmentation. (C) For the reconstructed atoms, we plot the predicted atomic number versus the atomic number of the nearest true atom. (D) We compute the distance from each true atom to the nearest predicted atom and vice-versa (orange and blue, respectively). (E) For three different crystals we plot the predicted versus reconstructed density at each voxel. We also show 2-D slices through the target and prediction, along with the 3-D reconstructions. For plotting, the density on each figure is normalized between 0 and 1 though is not decoded as such. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            99,
+            787,
+            542
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "There have been two parallel lines of work applying machine learning to material sciences. The first deals with the prediction of physical properties from a compound without performing a computationally expensive density functional theory (DFT) calculation. ",
+        "bbox": [
+            174,
+            700,
+            826,
+            742
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Recently, Xie and Grossman introduced crystal graph convolutional networks (CGCNN) for accurate prediction of 8 different DFT-calculated properties of crystal structures (Xie & Grossman, 2018). MatErials Graph Network (MEGNet) uses graph neural networks (Chen et al., 2019) to predict a variety of energetic properties on both the QM9 dataset (Ramakrishnan et al., 2014) as well 69,000 crystal structures from the Materials Project (Jain et al., 2013). Another network, SchNet, uses 3-D spatial information to directly leverage the interactions between separate atoms. They then use a continuous-filter convolution for accurate property prediction (Schütt et al., 2018). These methods, and many more, have all achieved impressive results on many standard benchmark datasets. Cubuk, et al. use transfer learning to search an enormous space of molecules for promising Lithium ion conductors (Cubuk et al., 2019). ",
+        "bbox": [
+            174,
+            750,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Another line of work is concerned with generating molecules, often molecules that have specific properties. In the past decade, generative models for drug discovery have achieved impressive results. Typically a representation of a compound, such as a SMILES string (Gómez-Bombarelli et al., 2018; Segler et al., 2017; Alperstein et al., 2019) or a graph (Jin et al., 2018; Assouel et al., 2018; Mansimov et al., 2019) is encoded and decoded. Then, by sampling the resulting latent space, novel molecules can be generated. Either by performing an auxiliary task with the latent space (as done in Gómez-Bombarelli et al. (2018)) and then performing optimization or by conditioning the latent space on desirable properties, novel chemical structures are obtained. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "One possible representation of drug-like molecules is a SMILES string. However, a difficulty faced using the SMILES representation is ensuring that the decoder decoded a valid SMILES string (Gómez-Bombarelli et al., 2018; Kusner et al., 2017). Additionally, there is not a strong notion of distance between molecules and their SMILES representation (Jin et al., 2018). One approach, ChemTS, uses SMILES strings along with recurrent neural networks and Monte Carlo Tree Search to better ensure generated strings decode to real molecules (Yang et al., 2017). By explicitly penalizing invalid SMILES strings in their reward function they are able to bypass the difficulty in their decoded molecules being non-physical. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            305
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "More recently, graph based methods have proven very successful in generating synthetically attainable molecules. By building a database of molecule fragments (like LEGO bricks), a graph is formed based on the connectivity of different structures (Jin et al., 2018). These methods have far fewer difficulties ensuring that the decoder produces physically valid molecules. For generation of physical molecules, this is a very important consideration, as there are many hard constrains that most be obeyed. Other graph based approaches include flow based models (Madhawa et al., 2019). Also using graph neural networks, E. Manismov and collaborators developed a method to, given a graph, recreate conformations of a 3-D molecule and predict its energetic properties (Mansimov et al., 2019). In Mansimov et al. (2019), the authors propose a graph-based generative method that is able to generate molecules with desired target properties. Impressively, they recover 3-D positional information for the atoms and show they achieve the required accuracy for relaxation. ",
+        "bbox": [
+            174,
+            313,
+            825,
+            465
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "An additional challenge for generative models in the physical sciences is ensuring that samples from the latent space, z, decode into physically plausible objects. The decoded objects need to obey physical constraints and an object that may appear physical is not certain to actually be experimentally realizable. In many domains this is not of specific concern, for example a generated animal is scored on some likelihood based on its visual appearance, not whether or not the generated creature is genetically possible. Recently, there have been generative models leveraging the 3-D nature of the problem. G-SchNet, a generative model for 3-D molecules (Gebauer et al., 2019) leverages the SchNet architecture- a start-of-the-art property prediction network (Schütt et al., 2018). They show they are able to generate molecules, placing atoms in 3-D space in a rotationally invariant manner. By appropriately conditioning the placement of new molecules based on the location and identity of previous molecules, they ensure the symmetries that are required for the molecules to relax in a DFT calculation. They propose expanding G-SchNet to generating crystal structures as a future direction. ",
+        "bbox": [
+            174,
+            472,
+            825,
+            638
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While there is a rich literature in the generation of organic compounds, recently there has been work in the generation of more complex crystal structures, such as CrystalGAN (Nouira et al., 2018). The authors of CrystalGAN introduce geometric constraints and show that their method is able to produce stable structures compared to methods that do not include such domain knowledge such as DiscoGAN (Kim et al., 2017). CrystalGAN uses a dataset with a much larger selection of elements than much previous work, but they limit themselves to molecules of particular chemical structure, nor do they generate a 3-D arrangement. In this work, we do not limit the generated crystals in this way. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            743
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            765,
+            290,
+            781
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use a dataset containing $4 6 { , } 7 4 4 \\mathrm { c i f }$ files which contains the information describing the unit cells of properly relaxed crystal structures from the Materials Project (Jain et al., 2013; Xie & Grossman, 2018). We use $80 \\%$ of the data for testing and the other $20 \\%$ for training. Using the Python library pymatgen we preprocess all of the data into the density 3-D matrices (Ong et al., 2013) described below. The boundary box of a crystal structure is controlled by six different degrees of freedom (see Fig. 1). Each side can have a different length and the angles between the three sides is also variable. Additionally, the internal complexity of each crystal can also vary widely– some unit cells in our dataset contain a single atom while other unit cells can have over one hundred different atoms. This tremendous variability in structure makes a universal representation difficult. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/a14e135fc66f074fa225d5fe0e75e15f44f183476d9b382bb262610b0b8beec6.jpg",
+        "image_caption": [
+            "Figure 4: Species reconstruction and latent space interpolation. (A) For five different randomly selected crystal unit cells we show the target and our reconstruction. Atoms are colored using default atomic colors, atoms with similar atomic number do not necessarily have similar colors. (B) We show the reconstruction of latent space interpolation between two molecules for 3 random sets of targets. For a video, see the Appendix. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            107,
+            810,
+            547
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 DATA REPRESENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            647,
+            382,
+            661
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As a first step for the problem of generating novel, physical crystal structures we begin with the simpler problem of encoding and decoding physical locations of atoms in space. We begin by considering a cube with side length $1 0 \\mathrm { ~ \\AA ~ }$ , which we represent by $M$ . We divide this cube into 30 equally spaced bins, resulting in a $3 0 \\times 3 0 \\times 3 0$ cube with each voxel representing $0 . 3 3 \\mathring { \\mathrm { A } }$ on each side (see Fig. 2 and Fig. 3E). In the appendix, we discuss this choice in more detail. This data representation is similar to many computer vision tasks, so we use similar convolution based network architectures. ",
+        "bbox": [
+            173,
+            675,
+            825,
+            776
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We consider the crystal structures in our dataset where the maximum side length is less than $1 0 \\mathring \\mathrm { A }$ We consider two different data representations of different complexity. In the first, we shift each single unit cell to the center of our grid, then we randomly rotate it. In this representation, we encode and decode a single unit cell. We randomly sample 3 different rotations for each crystal. In this case, the encoded structures typically have between 1 and 30 atoms, with a few reaching between 50 and 100. In the second representation, we repeat these unit cells in each direction infinitely and randomly sample a cube in space. This means that each cube contains at least one unit cell, but some will contain more than one cell, since in all cases a cube with 10 Åsides is chosen. We choose one representation where a unit cell begins at $( 0 , 0 , 0 )$ and randomly sample 2 other cubes in this space resulting in a dataset of over 100,000 examples. In this representation, we typically encode the locations of between 20 to 100 atoms, with some having over 200. An advantage of our representation is that we are agnostic to the number of atoms that we are encoding and decoding, something that is difficult for other approaches such as graphs. ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Using both these representations, we compute a density field, where each pixel $( i , j , k )$ is defined to have value ",
+        "bbox": [
+            171,
+            152,
+            823,
+            179
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/32c4509842b38714178771c069c17784c143b9b83a65a5ba0a741877473fb328.jpg",
+        "text": "$$\nM _ { i , j , k } = \\frac { 1 } { \\sigma ^ { 3 } ( 2 \\pi ) ^ { 3 / 2 } } \\sum _ { m } Z _ { m } \\mathrm { e x p } \\left( - \\frac { d ( \\vec { Z } _ { m } , ( i , j , k ) ) ^ { 2 } } { 2 \\sigma ^ { 2 } } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            179,
+            684,
+            222
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Where $d ( \\cdot , \\cdot )$ represents the Euclidean distance between the two arguments. $\\vec { Z } _ { m }$ represents the 3-D coordinates of atom $Z _ { m }$ . We set $\\sigma$ to $1 . 0 \\mathring \\mathrm { A }$ . When plotting, we multiply the output by $\\sigma ^ { 3 } ( 2 \\pi ) ^ { 3 / 2 }$ . We do this because when $\\sigma = 1$ this results in the value of $Z$ (the atomic number) being present at its location in space. Because of the structure of this representation, when the density of atoms increases, there are more interactions making it harder to reconstruct the true identity of an atom. Ultimately, our aim is to be able to reconstruct the location and species of the different atoms in this grid. To that end, we also construct a species matrix, $_ { s }$ , where each voxel is either a 0 or equal to the atomic number of an atom that is within $0 . 5 \\mathring \\mathrm { \\mathrm { A } }$ . We construct two neural networks that attempt to learn $M$ and $\\pmb { S }$ in parallel. These two networks are trained together and are detailed in the following section. ",
+        "bbox": [
+            173,
+            229,
+            826,
+            359
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 NETWORK ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            378,
+            403,
+            392
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use a variational autoencoder (Kingma & Welling, 2013) to encode and decode our 3-D density maps, $M$ . We use a $\\beta$ multiplier on the Kullback-Leibler (KL) loss term to encourage no correlations between different elements of the latent space (Higgins et al., 2017). Our encoder, $E ( \\cdot )$ , is a convolutional neural network. The decoder, $D ( \\cdot )$ , uses upsampling and convolutions in favor of transposed convolutions (Odena et al., 2016). We use batch normalization (Ioffe & Szegedy, 2015), LeakyReLU activations, and the code is written in Pytorch (Paszke et al., 2017). The optimization is done using the Adam optimizer (Kingma & Ba, 2014). We use a latent space size of 300 for all experiments. ",
+        "bbox": [
+            173,
+            405,
+            826,
+            517
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Simultaneously with training the VAE, we train a 3-D U-Net segmentation model, $\\mathrm { U } _ { \\mathrm { n e t } } ( \\cdot )$ , with an attention mechanism to segment the output of the decoder (Ronneberger et al., 2015; Oktay et al., 2018). For accurate segmentation, especially in the case of a repeating lattice, it is important to be able to capture the dependencies between different atoms. We found that a U-Net model worked well, though future work will explore sequentially classifying atoms. Ideally, the primary work is done by the VAE and the role of U-Net is to perform the tedious optimization problem of recovering the species identity and locations that is most consistent with the reconstructed density field. ",
+        "bbox": [
+            173,
+            522,
+            825,
+            621
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We include a weighted (by $\\gamma$ ) loss from the segmentation in the loss of the encoder/decoder. In our experiments, we set $\\gamma$ to 0.1. We experimented with $\\gamma = 0$ and $\\gamma = 0 . 3 3$ and found that 0.1 proved an acceptable intermediate. With $\\gamma = 0 . 3 3$ we found slightly improved segmentation results but worse density reconstruction results. When we completely removed the effect of the species loss from the density reconstruction, species reconstruction results degraded.This allows us to train the entire network in an end-to-end fashion. The entire model is shown in Fig. 2. ",
+        "bbox": [
+            173,
+            627,
+            825,
+            712
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use three terms in the loss function for the VAE with the most weight given to the reconstruction of the density matrices. The segmentation network is only concerned with the final segmentation of the reconstruction from the decoder. Currently, we treat each atom type as a different class, with an additional (most common) class for “no atom.” The loss function used for the VAE is ",
+        "bbox": [
+            173,
+            718,
+            825,
+            775
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/41d0e08dab8d8393c6f46184576263b31aa0af45b63816cc3f2a9c7cb8af75f1.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { V A E } } = L _ { \\mathrm { R E } } ( \\hat { M } , M ) + \\beta ( D _ { \\mathrm { K L } } ( q ( \\mathbf { z } | M ) | | p ( \\mathbf { z } ) ) ) + \\gamma L _ { \\mathrm { B C E } } ( \\hat { S } , S ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            782,
+            717,
+            803
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The first term is the reconstruction error and the third term is the binary cross entropy loss from the segmentation. The second term is the Kullback-Leibler divergence between the prior (set to $p ( \\mathbf { z } ) \\stackrel { - } { = } \\mathcal { N } ( 0 , 1 ) )$ and $q ( z | M )$ the approximate posterior of the latent vector given input $M$ . We use a loss given by $\\mathcal { L } _ { \\mathrm { U - N e t } } = L _ { \\mathrm { B C E } } ( \\hat { S } , S )$ for the segmentation. In the above expression, $M$ is the input density field. $\\mathbf { z } = E ( M )$ and $\\hat { M } = D ( \\pmb { \\mathrm { z } } )$ is the reconstructed density field. The variable $_ { s }$ represents a 1-hot species matrix. Lastly, $\\hat { \\boldsymbol { S } } = \\mathrm { U } _ { \\mathrm { n e t } } \\left( \\hat { \\boldsymbol { M } } \\right)$ represents the probability matrix from the segmentation routine, which will be of shape: [ba $\\mathrm { c h } \\times \\mathrm { c l a s s e s } \\times \\mathrm { x } \\mathrm { - d i m } \\times \\mathrm { y } \\mathrm { - d i m } \\times \\mathrm { z } \\mathrm { - d i m } ]$ . ",
+        "bbox": [
+            173,
+            810,
+            825,
+            925
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            281,
+            117
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We find that we are able to accurately encode and decode 3-D representations of density fields (see Figs. 3 and S8). Using the segmentation network, we segment the output of the decoder into distinct atoms. Using a trained network, we show that random samples from the latent space decode to samples that obey many of the same statistics as the training distribution (see Fig. 5 and Fig. S7). Additionally, in the case of a repeating unit cell, we alter our training routine to condition the generation of crystals on the largest atomic number present. ",
+        "bbox": [
+            174,
+            133,
+            506,
+            286
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1 PLACEMENT OF ATOMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            304,
+            375,
+            318
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Using the output of the segmentation network, we take the $\\tilde { \\bf S } = \\mathrm { a r g m a x } ( \\hat { \\bf S } )$ . From this representation, we find the connected components and use majority voting to assign each cluster an atom identity (see Appendix for details). In Fig. 3 (and Fig.S8) we show the accuracy of all top-1 predictions. We compare the results of our segmented matrix, S˜ with the true values, S. From the center of mass of each predicted atom $i$ , we compute the distance to the nearest true atom as follows ",
+        "bbox": [
+            174,
+            330,
+            506,
+            472
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b1e924241f7b2cca2ec2bcded7b933459f6cb52938b27c1831c28b2dc83f4885.jpg",
+        "text": "$$\n\\begin{array} { r } { \\operatorname* { m i n } _ { j } \\ d ( \\tilde { \\bf S } _ { i } , { \\bf S } _ { j } ) \\forall \\ j \\ \\mathrm { a n d } \\operatorname* { m i n } _ { i } \\ d ( \\tilde { \\bf S } _ { i } , { \\bf S } _ { j } ) \\ \\forall \\ i . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            477,
+            472,
+            497
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/c7aca0e31e7cbb381946489393790c5c700b5ddd5d73b2a9d540f8d247fc5e63.jpg",
+        "table_caption": [
+            "Table 1: Location and species reconstruction error. $P$ denotes prediction and $T$ denotes target. Distances in angstrom. For $Z$ reconstruction, we show the percentile at each absolute difference. ",
+            "Locations "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Percentile</td><td>P→T(A)</td><td>T→P(A)</td></tr><tr><td>0.</td><td>4.31×10-4</td><td>5.47×10-4</td></tr><tr><td>10.</td><td>5.03 ×10-2</td><td>5.02 × 10-2</td></tr><tr><td>20.</td><td>7.04 × 10-2</td><td>7.05 ×10-2</td></tr><tr><td>30.</td><td>9.12 × 10-2</td><td>9.13 × 10-2</td></tr><tr><td>40.</td><td>1.14 × 10-1</td><td>1.14 × 10-1</td></tr><tr><td>50.</td><td>1.36 × 10-1</td><td>1.37 × 10-1</td></tr><tr><td>60.</td><td>1.60 × 10-1</td><td>1.61 × 10-1 1.94 × 10-1</td></tr><tr><td>70. 80.</td><td>1.94 × 10-1 2.48 × 10-1</td><td>2.50 ×10-1</td></tr><tr><td>90. 100.</td><td>3.94 × 10-1 2.59</td><td>4.03 × 10-1 1.89</td></tr><tr><td>Species Abs.Diff.in Z</td><td>Percent</td><td></td></tr><tr><td>0</td><td>66.8 %</td><td></td></tr><tr><td>1</td><td>25.1 %</td><td></td></tr><tr><td>2</td><td>5.8 %</td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td>&gt;3</td><td>2.2 %</td><td></td></tr></table>",
+        "bbox": [
+            517,
+            234,
+            848,
+            498
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Similarly, we can compute the distance from each true atom to the nearest predicted atom. By computing this metric in both directions, we are able to ",
+        "bbox": [
+            174,
+            503,
+            508,
+            545
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "verify that our model is placing atoms in the correct locations but only in those locations. ",
+        "bbox": [
+            176,
+            546,
+            754,
+            560
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 ACCURACY ON A UNIT CELL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            578,
+            411,
+            590
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 3 we plot the results of applying our model to single unit cells of crystals (see also Table 1). We find out model is able to very accurately segment the locations of atoms with nearly $9 9 \\%$ of atoms placed within $0 . 5 \\mathring \\mathrm { \\mathrm { A } }$ of their true location. Nearly $90 \\%$ of unit cells are reconstructed with the correct number of atoms and $9 7 \\%$ of unit cells are reconstructed with less than 2 atoms extra or missing. $66 \\%$ of species are correctly classified in the test set, with nearly 100 possible classes. When an atom is incorrectly classified, it is usually by one or two atomic numbers (see Table 1). Often adjacent elements (with atomic numbers that differ by 1) have very different chemical properties. We retrained the network to predict atomic group (where elements in the same group tend to have more similar properties) and found $93 \\%$ accuracy. We report accuracy on $Z$ as this is a more difficult problem and in both cases we are still unable to reconstruct crystals with the accuracy to relax in a DFT calculation. Missed atoms typically occur near the boundary. ",
+        "bbox": [
+            173,
+            603,
+            825,
+            757
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Next, we will discuss the same network applied to repeating unit cells. In all cases, the results for single unit cells are improvements over the results of multiple unit cells. For most figures, there are corresponding panels between the single unit cell and repeated cell results. ",
+        "bbox": [
+            176,
+            763,
+            823,
+            806
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 ACCURACY ON REPEATING UNIT CELLS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            824,
+            486,
+            838
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Fig. S8C we show the percentiles of all pairwise minimum distances in our reconstructed samples. We find that $50 \\%$ of all reconstructed atoms are in $0 . 2 \\mathring \\mathrm { A }$ . For both directions, the $7 5 ^ { \\mathrm { t h } }$ percentile error was under $0 . 2 5 \\mathring { \\mathrm { A } }$ and the $9 0 ^ { \\mathrm { t h } }$ percentile of reconstructed atoms were within $0 . 5 \\mathring \\mathrm { \\mathrm { A } }$ . For predicted atoms that are within $0 . 5 \\mathring \\mathrm { \\mathrm { A } }$ of a true atom’s location, we find that $6 5 . 4 \\%$ of the time our prediction matches the atomic number exactly Fig. S8E. Again, nearly all errors occur near the boundary. ",
+        "bbox": [
+            174,
+            849,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/400aaa0bcf44c5422a69c5d6e8694c2f1e369a14faa43f642b44c960c6403cd4.jpg",
+        "image_caption": [
+            "Figure 5: Decode random latent space vectors. (A) We look at the spacing between nearest atoms from random draws from the latent space compared to those from real crystal structures. In blue we show the distribution of random reconstructions. In red we show the distribution of true inter-atomic spacing. (B) For 5 different random latent space vectors, we show the reconstructed density field and the resulting segmentation. Notice that in some cases small amounts of density are predicted but are not segmented into an atom (for example, in columns 3 and 4). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            107,
+            799,
+            367
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For 120 randomly selected reconstructed crystals from the test set, we compare the number of atoms after segmentation with the true number (Fig. S8D and Fig. 3B). In Fig. S8E we compare the predicted species compared with the species of the nearest true atom, independent of the distance to the nearest atom. We find that based on the results of Fig. S8, our current model is able to more accurately reconstruct the locations of atoms than obtain their true atomic number. This makes sense, given the enormous number of possible classes. However for repeating unit cells, when an atom is correctly predicted to be within $0 . 3 3 \\mathring { \\mathrm { A } }$ of a true atom location nearly $70 \\%$ of the time the atom is assigned exactly the correct $Z$ value. The correlation between the true and predicted value is 0.98 suggesting that when the network makes an incorrect assessment, it chooses a nearby atomic number. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            609
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Further improvements in this placement and identification of atoms is necessary in achieving crystals that will appropriately relax in a DFT simulation for the calculation of quantum mechanical properties. However, a very exciting immediate application of this work is in random structure searching Pickard & Needs (2011). ",
+        "bbox": [
+            174,
+            616,
+            825,
+            672
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 LATENT SPACE INTERPOLATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            690,
+            436,
+            704
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We encode two different true density maps into vectors $\\mathbf { z } _ { 1 }$ and $\\mathbf { z } _ { 2 }$ , respectively. We then linearly interpolate between these two values in latent space, constructing intermediate vectors $\\tilde { \\mathbf { z } } _ { i }$ . We decode the resulting latent space vectors which result in predicted density maps, $D ( \\tilde { \\mathbf { z } } )$ . Passing these into the trained segmentation routine, we find that intermediate results segment into atoms (see results on a single unit cell in Fig. 3 and Fig. 4). See results on a repeating lattice in Figs. S9 and S11)1. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            786
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 RANDOM DRAWS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            803,
+            336,
+            818
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We can randomly sample a latent space vector $\\mathbf { z } \\sim \\mathcal { N } ( 0 , 1 )$ and we then decode the output. We do this for both single unit cells as well as for repeating lattices (see Appendix). Random structure searching is an important area of material science research an exciting direction for this work Pickard & Needs (2011). Using the network trained to encode and decode single unit cells, we decode a $\\mathbf { z } \\sim \\mathcal { N } ( 0 , 1 )$ . ",
+        "bbox": [
+            174,
+            829,
+            825,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 5 we show the decoded density fields along with the resulting segmented output. There are a few desirable features: single cells are centered, atoms tend to be of similar atomic number, even in different parts of the reconstructed output, and atoms are not ever too close together. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            166,
+            504,
+            183
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The ability to encode and decode 3-D structures is a very interesting direction of recent work and increasingly important in helping create models that can understand the world that we live in. In current material design, a lot of focus has been on molecules where the 3-D structure can be safely ignored. However, in many cases this is not the case. We do not know of an effective data representation for these 3-D molecules and find that by directly utilizing a proxy for density we are able to encode and decode the geometry of these molecules. ",
+        "bbox": [
+            174,
+            198,
+            825,
+            281
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "An important future direction of research is to come up with successful representations for encoding crystal structures such that they can be easily encoded and decoded. Coming up with a representation of crystal unit cells (and 3-D structures in general) so that decoded molecules are physically plausible is an important aspect that needs to be carefully considered. ",
+        "bbox": [
+            174,
+            289,
+            823,
+            344
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our approach is currently unable to generate molecules that are physically stable, but there are promising directions in this direction. Using ideas similar to G-SchNet, using the decoded density field, atoms can be placed sequentially, conditioned on the placement of previous atoms (Gebauer et al., 2019). Working towards decoding molecules that are able to relax is a very exciting direction. ",
+        "bbox": [
+            176,
+            352,
+            825,
+            407
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Another improvement would be to alter the structure of our encoder/decoder. Currently, we use standard 3-D convolutions. However, using SE(3) equivariant kernels from M. Weiler et al. is a promising direction for improved performance (Weiler et al., 2018). We feel that our current approach could be extended beyond the domain of material science, as we are able to encode a 3-D distance map, this approach could be broadly applied to many objects. In essence, we are able to learn a distance transform from an object. This is more general than for encoding and decoding atomic structures. To try to facilitate further research in the creation of 3-D representation of more complex atomic structures, we will release the code shortly. ",
+        "bbox": [
+            174,
+            415,
+            825,
+            526
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            547,
+            285,
+            563
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Panos Achlioptas, Olga Diamanti, Ioannis Mitliagkas, and Leonidas Guibas. Learning representations and generative models for 3d point clouds. arXiv preprint arXiv:1707.02392, 2017. ",
+        "bbox": [
+            174,
+            570,
+            823,
+            599
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zaccary Alperstein, Artem Cherkasov, and Jason Tyler Rolfe. All smiles variational autoencoder, 2019. ",
+        "bbox": [
+            173,
+            608,
+            823,
+            637
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rim Assouel, Mohamed Ahmed, Marwin H Segler, Amir Saffari, and Yoshua Bengio. Defactor: Differentiable edge factorization-based probabilistic graph generation. arXiv preprint arXiv:1811.09766, 2018. ",
+        "bbox": [
+            173,
+            647,
+            823,
+            689
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Brock, Theodore Lim, James M Ritchie, and Nick Weston. Generative and discriminative voxel modeling with convolutional neural networks. arXiv preprint arXiv:1608.04236, 2016. ",
+        "bbox": [
+            173,
+            699,
+            823,
+            729
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale gan training for high fidelity natural image synthesis. arXiv preprint arXiv:1809.11096, 2018. ",
+        "bbox": [
+            173,
+            738,
+            821,
+            767
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chi Chen, Weike Ye, Yunxing Zuo, Chen Zheng, and Shyue Ping Ong. Graph networks as a universal machine learning framework for molecules and crystals. Chemistry of Materials, 31(9):3564–3572, 2019. ",
+        "bbox": [
+            176,
+            776,
+            823,
+            819
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ricky TQ Chen, Xuechen Li, Roger Grosse, and David Duvenaud. Isolating sources of disentanglement in vaes. ",
+        "bbox": [
+            171,
+            829,
+            825,
+            858
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xi Chen, Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. InfoGAN: Interpretable representation learning by information maximizing generative adversarial nets. In D. D. Lee, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances In Neural Information Processing Systems 29, pp. 2172–2180. Curran Associates, Inc., 2016. ",
+        "bbox": [
+            176,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Özgün Çiçek, Ahmed Abdulkadir, Soeren S Lienkamp, Thomas Brox, and Olaf Ronneberger. 3d u-net: learning dense volumetric segmentation from sparse annotation. In International conference on medical image computing and computer-assisted intervention, pp. 424–432. Springer, 2016. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ekin D Cubuk, Austin D Sendek, and Evan J Reed. Screening billions of candidates for solid lithium-ion conductors: A transfer learning approach for small data. The Journal of chemical physics, 150(21):214701, 2019. ",
+        "bbox": [
+            174,
+            156,
+            825,
+            199
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Niklas WA Gebauer, Michael Gastegger, and Kristof T Schütt. Symmetry-adapted generation of 3d point sets for the targeted discovery of molecules. arXiv preprint arXiv:1906.00957, 2019. ",
+        "bbox": [
+            173,
+            209,
+            823,
+            238
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rafael Gómez-Bombarelli, Jennifer N Wei, David Duvenaud, José Miguel Hernández-Lobato, Benjamín Sánchez-Lengeling, Dennis Sheberla, Jorge Aguilera-Iparraguirre, Timothy D Hirzel, Ryan P Adams, and Alán Aspuru-Guzik. Automatic chemical design using a data-driven continuous representation of molecules. ACS central science, 4(2):268–276, 2018. ",
+        "bbox": [
+            173,
+            247,
+            826,
+            305
+        ],
+        "page_idx": 10
+    },
+    {
+        "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. In Advances in neural information processing systems, pp. 2672–2680, 2014. ",
+        "bbox": [
+            174,
+            314,
+            825,
+            358
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. beta-vae: Learning basic visual concepts with a constrained variational framework. ICLR, 2(5):6, 2017. ",
+        "bbox": [
+            173,
+            367,
+            826,
+            411
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Moritz Hoffmann and Frank Noé. Generating valid euclidean distance matrices, 2019. ",
+        "bbox": [
+            173,
+            421,
+            738,
+            436
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015. ",
+        "bbox": [
+            174,
+            446,
+            826,
+            476
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John J Irwin, Teague Sterling, Michael M Mysinger, Erin S Bolstad, and Ryan G Coleman. Zinc: a free tool to discover chemistry for biology. Journal of chemical information and modeling, 52(7): 1757–1768, 2012. ",
+        "bbox": [
+            174,
+            484,
+            826,
+            527
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anubhav Jain, Shyue Ping Ong, Geoffroy Hautier, Wei Chen, William Davidson Richards, Stephen Dacek, Shreyas Cholia, Dan Gunter, David Skinner, Gerbrand Ceder, et al. Commentary: The materials project: A materials genome approach to accelerating materials innovation. Apl Materials, 1(1):011002, 2013. ",
+        "bbox": [
+            176,
+            537,
+            826,
+            594
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wengong Jin, Regina Barzilay, and Tommi Jaakkola. Junction tree variational autoencoder for molecular graph generation. arXiv preprint arXiv:1802.04364, 2018. ",
+        "bbox": [
+            171,
+            604,
+            825,
+            633
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hyunjik Kim and Andriy Mnih. Disentangling by factorising. arXiv preprint arXiv:1802.05983, 2018. ",
+        "bbox": [
+            171,
+            643,
+            825,
+            672
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Taeksoo Kim, Moonsu Cha, Hyunsoo Kim, Jung Kwon Lee, and Jiwon Kim. Learning to discover cross-domain relations with generative adversarial networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1857–1865. JMLR. org, 2017. ",
+        "bbox": [
+            174,
+            683,
+            826,
+            727
+        ],
+        "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": [
+            173,
+            736,
+            823,
+            765
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013. ",
+        "bbox": [
+            171,
+            775,
+            825,
+            804
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matt J Kusner, Brooks Paige, and José Miguel Hernández-Lobato. Grammar variational autoencoder. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1945– 1954. JMLR.org, 2017. ",
+        "bbox": [
+            173,
+            814,
+            826,
+            857
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Clare F Macrae, Ian J Bruno, James A Chisholm, Paul R Edgington, Patrick McCabe, Elna Pidcock, Lucia Rodriguez-Monge, Robin Taylor, J van de Streek, and Peter A Wood. Mercury csd 2.0– new features for the visualization and investigation of crystal structures. Journal of Applied Crystallography, 41(2):466–470, 2008. ",
+        "bbox": [
+            174,
+            867,
+            826,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaushalya Madhawa, Katushiko Ishiguro, Kosuke Nakago, and Motoki Abe. Graphnvp: An invertible flow model for generating molecular graphs. arXiv preprint arXiv:1905.11600, 2019. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Elman Mansimov, Omar Mahmood, Seokho Kang, and Kyunghyun Cho. Molecular geometry prediction using a deep generative graph neural network. arXiv preprint arXiv:1904.00314, 2019. ",
+        "bbox": [
+            171,
+            141,
+            825,
+            171
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel Maturana and Sebastian Scherer. Voxnet: A 3d convolutional neural network for real-time object recognition. In 2015 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 922–928. IEEE, 2015. ",
+        "bbox": [
+            178,
+            179,
+            823,
+            223
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hsien-Yu Meng, Lin Gao, Yu-Kun Lai, and Dinesh Manocha. Vv-net: Voxel vae net with group convolutions for point cloud segmentation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 8500–8508, 2019. ",
+        "bbox": [
+            173,
+            231,
+            826,
+            275
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Thu Nguyen-Phuoc, Chuan Li, Lucas Theis, Christian Richardt, and Yong-Liang Yang. Hologan: Unsupervised learning of 3d representations from natural images. arXiv preprint arXiv:1904.01326, 2019. ",
+        "bbox": [
+            174,
+            284,
+            826,
+            327
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Guangda Niu, Xudong Guo, and Liduo Wang. Review of recent progress in chemical stability of perovskite solar cells. Journal of Materials Chemistry A, 3(17):8970–8980, 2015. ",
+        "bbox": [
+            173,
+            335,
+            823,
+            366
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Asma Nouira, Jean-Claude Crivello, and Nataliya Sokolovska. Crystalgan: Learning to discover crystallographic structures with generative adversarial networks. arXiv preprint arXiv:1810.11203, 2018. ",
+        "bbox": [
+            173,
+            373,
+            826,
+            416
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Augustus Odena, Vincent Dumoulin, and Chris Olah. Deconvolution and checkerboard artifacts. Distill, 2016. doi: 10.23915/distill.00003. URL http://distill.pub/2016/ deconv-checkerboard. ",
+        "bbox": [
+            174,
+            426,
+            823,
+            469
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ozan Oktay, Jo Schlemper, Loic Le Folgoc, Matthew Lee, Mattias Heinrich, Kazunari Misawa, Kensaku Mori, Steven McDonagh, Nils Y Hammerla, Bernhard Kainz, et al. Attention u-net: Learning where to look for the pancreas. arXiv preprint arXiv:1804.03999, 2018. ",
+        "bbox": [
+            178,
+            478,
+            823,
+            522
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shyue Ping Ong, William Davidson Richards, Anubhav Jain, Geoffroy Hautier, Michael Kocher, Shreyas Cholia, Dan Gunter, Vincent L Chevrier, Kristin A Persson, and Gerbrand Ceder. Python materials genomics (pymatgen): A robust, open-source python library for materials analysis. Computational Materials Science, 68:314–319, 2013. ",
+        "bbox": [
+            174,
+            530,
+            826,
+            587
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017. ",
+        "bbox": [
+            174,
+            597,
+            826,
+            638
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chris J Pickard and RJ Needs. Ab initio random structure searching. Journal of Physics: Condensed Matter, 23(5):053201, 2011. ",
+        "bbox": [
+            173,
+            648,
+            825,
+            678
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pavel G Polishchuk, Timur I Madzhidov, and Alexandre Varnek. Estimation of the size of drug-like chemical space based on gdb-17 data. Journal of computer-aided molecular design, 27(8):675–679, 2013. ",
+        "bbox": [
+            173,
+            686,
+            826,
+            729
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Raghunathan Ramakrishnan, Pavlo O Dral, Matthias Rupp, and O Anatole Von Lilienfeld. Quantum chemistry structures and properties of 134 kilo molecules. Scientific data, 1:140022, 2014. ",
+        "bbox": [
+            169,
+            738,
+            823,
+            768
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ali Razavi, Aaron van den Oord, and Oriol Vinyals. Generating diverse high-fidelity images with vq-vae-2. arXiv preprint arXiv:1906.00446, 2019. ",
+        "bbox": [
+            171,
+            776,
+            825,
+            806
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Rolnick, Priya L Donti, Lynn H Kaack, Kelly Kochanski, Alexandre Lacoste, Kris Sankaran, Andrew Slavin Ross, Nikola Milojevic-Dupont, Natasha Jaques, Anna Waldman-Brown, et al. Tackling climate change with machine learning. arXiv preprint arXiv:1906.05433, 2019. ",
+        "bbox": [
+            174,
+            814,
+            826,
+            858
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "O. Ronneberger, P.Fischer, and T. Brox. U-net: Convolutional networks for biomedical image segmentation. In Medical Image Computing and Computer-Assisted Intervention (MICCAI), volume 9351 of LNCS, pp. 234–241. Springer, 2015. URL http://lmb.informatik.uni-freiburg. de/Publications/2015/RFB15a. (available on arXiv:1505.04597 [cs.CV]). ",
+        "bbox": [
+            174,
+            867,
+            826,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kristof T Schütt, Huziel E Sauceda, P-J Kindermans, Alexandre Tkatchenko, and K-R Müller. Schnet–a deep learning architecture for molecules and materials. The Journal of Chemical Physics, 148(24):241722, 2018. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Daniel Schwalbe-Koda and Rafael Gómez-Bombarelli. Generative models for automatic chemical design. arXiv preprint arXiv:1907.01632, 2019. ",
+        "bbox": [
+            173,
+            155,
+            825,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Marwin HS Segler, Thierry Kogej, Christian Tyrchan, and Mark P Waller. Generating focused molecule libraries for drug discovery with recurrent neural networks. ACS central science, 4(1): 120–131, 2017. ",
+        "bbox": [
+            173,
+            193,
+            825,
+            234
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kihyuk Sohn, Honglak Lee, and Xinchen Yan. Learning structured output representation using deep conditional generative models. In Advances in neural information processing systems, pp. 3483–3491, 2015. ",
+        "bbox": [
+            173,
+            244,
+            826,
+            286
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Daniel P Tabor, Loïc M Roch, Semion K Saikin, Christoph Kreisbeck, Dennis Sheberla, Joseph H Montoya, Shyam Dwaraknath, Muratahan Aykol, Carlos Ortiz, Hermann Tribukait, et al. Accelerating the discovery of materials for clean energy in the era of smart automation. Nature Reviews Materials, 3(5):5, 2018. ",
+        "bbox": [
+            173,
+            295,
+            826,
+            352
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Diego Valsesia, Giulia Fracastoro, and Enrico Magli. Learning localized generative models for 3d point clouds via graph convolution. 2018. ",
+        "bbox": [
+            173,
+            361,
+            823,
+            390
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Maurice Weiler, Mario Geiger, Max Welling, Wouter Boomsma, and Taco Cohen. 3d steerable cnns: Learning rotationally equivariant features in volumetric data. In Advances in Neural Information Processing Systems, pp. 10381–10392, 2018. ",
+        "bbox": [
+            173,
+            398,
+            826,
+            441
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "David Weininger. Smiles, a chemical language and information system. 1. introduction to methodology and encoding rules. Journal of chemical information and computer sciences, 28(1):31–36, 1988. ",
+        "bbox": [
+            174,
+            450,
+            823,
+            492
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jiajun Wu, Chengkai Zhang, Tianfan Xue, William T Freeman, and Joshua B Tenenbaum. Learning a probabilistic latent space of object shapes via 3d generative-adversarial modeling. In Advances in Neural Information Processing Systems, pp. 82–90, 2016. ",
+        "bbox": [
+            176,
+            501,
+            823,
+            545
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Wenxuan Wu, Zhongang Qi, and Li Fuxin. Pointconv: Deep convolutional networks on 3d point clouds, 2018. ",
+        "bbox": [
+            173,
+            553,
+            825,
+            583
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Tian Xie and Jeffrey C Grossman. Crystal graph convolutional neural networks for an accurate and interpretable prediction of material properties. Physical review letters, 120(14):145301, 2018. ",
+        "bbox": [
+            171,
+            592,
+            823,
+            621
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Guandao Yang, Xun Huang, Zekun Hao, Ming-Yu Liu, Serge Belongie, and Bharath Hariharan. Pointflow: 3d point cloud generation with continuous normalizing flows. arXiv preprint arXiv:1906.12320, 2019. ",
+        "bbox": [
+            174,
+            628,
+            823,
+            671
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Xiufeng Yang, Jinzhe Zhang, Kazuki Yoshizoe, Kei Terayama, and Koji Tsuda. Chemts: an efficient python library for de novo molecular generation. Science and technology of advanced materials, 18(1):972–976, 2017. ",
+        "bbox": [
+            171,
+            680,
+            825,
+            723
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jiaxuan You, Bowen Liu, Zhitao Ying, Vijay Pande, and Jure Leskovec. Graph convolutional policy network for goal-directed molecular graph generation. In Advances in Neural Information Processing Systems, pp. 6410–6421, 2018. ",
+        "bbox": [
+            173,
+            732,
+            826,
+            775
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jun-Yan Zhu, Zhoutong Zhang, Chengkai Zhang, Jiajun Wu, Antonio Torralba, Josh Tenenbaum, and Bill Freeman. Visual object networks: image generation with disentangled 3d representations. In Advances in Neural Information Processing Systems, pp. 118–129, 2018. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            827
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A SUPPLEMENTAL INFORMATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            102,
+            467,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.1 VIDEOS ",
+        "bbox": [
+            176,
+            133,
+            274,
+            148
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "See anonymoized project site at: https://sites.google.com/view/ encode-decode-3d-crystals/home. ",
+        "bbox": [
+            173,
+            160,
+            825,
+            189
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B CHOICE OF DATA REPRESENTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            209,
+            508,
+            226
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We choose to use a 10 Angstrom cutoff as it kept over $90 \\%$ of the data we had available without becoming too computationally demanding, as we needed to maintain a relatively small grid spacing between voxels (0.33 Angstrom). Because the problem is 3-D, a $3 0 ^ { 3 }$ input is equivalent to a $1 6 4 \\times$ 164 image, in terms of pixels. ",
+        "bbox": [
+            174,
+            241,
+            825,
+            297
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C COMPARISON OF 1-D, 2-D, AND 3-D REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            318,
+            679,
+            335
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For small molecules, 1-D SMILES and 2-D graph based representations have been very effectively used for property prediction and for molecule generation tasks. In a SMILES representation, a specific grammar is learned but from a valid string, a specific molecule is generated based on the bond arrangement Weininger (1988); Gómez-Bombarelli et al. (2018). Similarly, a graph based representation is able to place atoms in space without specifically assigning each atom a specific coordinate Jin et al. (2018). Additionally, graph representations have been shown to be successful for property prediction of crystals Xie & Grossman (2018), but not for generating crystals. For small molecules, these representations have proved very effective, especially since both these representations effectively reduce the dimension of the problem. ",
+        "bbox": [
+            174,
+            351,
+            825,
+            477
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Specifically, SMILES and graph representations both do not encode the specific spatial arrangement of atoms. Instead, these representations are cleverly created in such a way that the spatial arrangements can reconstructed. Unfortunately, for many larger molecules these representations are not sufficient. Therefore, we focus on developing a representation that is able to directly reconstruct both species and locations in a 3-D space. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            553
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D SPECIES PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            574,
+            390,
+            590
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Each voxel is assigned an identity based on the argmax of the U-Net. The background has label 0. First, we find all connected components of non-background voxels. For each connected component, we tabulate the species predicted at each voxel and each cluster is assigned an identity baased on the majority vote. The location is based on the centroid of the cluster. We experimented with more complicated procedures (such as weighting by the probability vector) and did not find a meaningful improvement. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            689
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            710,
+            372,
+            727
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We used a Tesla V100 for training. We used a learning rate of 1e-5 and a batch size of 24. ",
+        "bbox": [
+            173,
+            743,
+            759,
+            757
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E.1 NETWORK DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            775,
+            354,
+            790
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E.1.1 ENCODER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            801,
+            299,
+            815
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "3D convolution, kernel size of 5 and stride of 2. 16 channels.   \nBatch Norm and LeakyReLU activation.   \n3D convolution, kernel size of 3 and stride of 1. 32 channels.   \nBatch Norm and LeakyReLU activation.   \n3D convolution, kernel size of 3 and stride of 1. 64 channels.   \nBatch Norm and LeakyReLU activation.   \n3D convolution, kernel size of 3 and stride of 2. 128 channels. Batch Norm and LeakyReLU activation.   \nFully connected layer with a bottleneck size 300. ",
+        "bbox": [
+            176,
+            827,
+            580,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            495,
+            132
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "E.1.2 DECODER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            147,
+            300,
+            162
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Fully connected layer.   \nReshape to 128 5,5,5 Trlinear upsample by a factor of two.   \nConv3D with 64 channels, kernel size of 5, leakyReLU.   \nTrlinear upsample by a factor of two.   \nConv3D with 32 channels, kernel size of 5, leakyReLU.   \nTrlinear upsample by a factor of two.   \nConv3D with 16 channels, kernel size of 4, leakyReLU.   \nConv3D with 1 channels, kernel size of 4, ReLU. ",
+        "bbox": [
+            173,
+            172,
+            540,
+            297
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "F RESULTS FROM THE ENCODER-DECODER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            333,
+            552,
+            348
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Our encoder-decoder architecture is able to accurately reconstruct the voxel-wise density (Fig. S8A and Fig. S6). We find a strong correlation between the predicted and target voxel value (Fig. S6A). This is essential for achieving an accurate segmentation of the correct atoms and their corresponding positions. Due to the strong penalty on the KL term we find that there is an increased spread in the resulting predictions when attempting to encode and decode repeating unit cells. This is less of an issue when encoding and decoding single unit cells. ",
+        "bbox": [
+            174,
+            364,
+            825,
+            449
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "G ACCURACY OF RANDOM DRAWS IN A REPEATING LATTICE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            470,
+            691,
+            486
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "To test whether random samples from the latent space, $\\tilde { \\mathbf { z } }$ , decode to physically realistic molecules, we trained a discriminator. We trained an auto-encoder that was able to very accurately reconstruct molecules by greatly reducing the penalty on $\\beta$ (see Fig. S12). Then, we compute real latent space representations of our different molecules, $\\mathbf { z }$ . We then draw a $\\lambda \\sim U ( 0 , 1 )$ and construct a new latent space vector ",
+        "bbox": [
+            173,
+            501,
+            825,
+            570
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/151834d505016811fb0958a58e330ca522891b89e563924985fc086b3a89d85b.jpg",
+        "text": "$$\n\\hat { \\mathbf { z } } = \\lambda \\widetilde { \\mathbf { z } } _ { \\mathcal { N } ( 0 , 1 ) } + ( 1 - \\lambda ) \\mathbf { z } _ { \\mathrm { r e a l } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            570,
+            591,
+            589
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where $\\tilde { \\mathbf { z } }$ is a random sample from a unit normal and $\\mathbf { z } _ { \\mathrm { r e a l } }$ is a random “true” latent space. We pass this through the decoder and provide this a label $( 1 - \\lambda , \\lambda )$ . We then randomly draw $\\mathbf { z } \\sim \\mathcal { N } ( 0 , 1 )$ from our trained network and pass this reconstruction $\\tilde { D }$ into the discriminator network, which outputs a prediction of the distance from a true crystal reconstruction versus a random draw from a latent space of a previously trained network. Applying this network to random samples from $\\mathbf { z } \\sim \\mathcal { N } ( 0 , 1 )$ we get a mean value of 0.84 with a standard deviation of 0.05. For true decoded samples, we find a mean value of 0.90 with a standard deviation of 0.01. In Fig. S13, we show results of the trained network and predictions on three different datasets. We find that the target latent space decodes to high-scoring samples (see Fig. S13B) and that out of distribution samples typically decode to much lower scores. ",
+        "bbox": [
+            173,
+            592,
+            825,
+            733
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "G.1 CONDITIONAL VAE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            751,
+            356,
+            765
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Moving forward, an important step will be creating structures that have specific chemical properties. Moving towards this direction, we attempt to condition the generation of molecules on the largest species present (Sohn et al., 2015). To do this, we multiply the input and output of the bottleneck by the largest present density. By doing this, we are still able to get the network to train but find that we are able to control the magnitude of the resulting density field without perturbing the geometry (see Fig. S10B). We attempted to condition the encoder and decoder by concatenation though we found this was not sufficient to generate density fields with the desired property. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            875
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The ability to condition on specific properties has obvious applications in the targeted generation of molecules. In this case, we choose to condition on the largest present density as a way to generate molecules that do not have an atom with more than a specified maximum atomic number present. We find that by varying different parameters in the latent space, some vary the field in such a way that appears to correlate with the location of atoms (see Fig. S10C,D). However, unlike as in work on 2-D problems, the changes in the 3-D scalar field are much harder to interpret (Chen et al., 2016; Higgins et al., 2017). Future work will attempt to use improved factorizing techniques (Kim & Mnih, 2018; Chen et al.). Additionally, one could seek to condition the generation of single unit cells on quantum mechanical properties or by adding an auxiliary loss using the latent space to predict quantum mechanical properties. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/be19653bcf2385458ab0ac12318d2df8c79a55720a0a35e8282bab936bc1eea6.jpg",
+        "image_caption": [
+            "Figure S6: Accuracy of Model. (A) For each position in 3-D space, we plot the predicted and target density for 4 different random crystals from the test set. The red dashed line is an identity line. (B) For each of the panels in (A), we show 4 different $z$ -slices through the true and predicted density fields. (C) We show the full 3-D reconstruction of the prediction and the true density field. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            104,
+            797,
+            530
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            632,
+            825,
+            731
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/1b139b5b1107a8b870c8c2d3fdca120045256bd847635d211975a104fa2e11df.jpg",
+        "image_caption": [
+            "Figure S7: Random Decoded Samples. We randomly sample the latent space17 $z \\sim N ( 0 , 1 )$ . We show a series of examples (from three different views) of different complexity. Note that while symmetry is not preserved, various geometric motifs are. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            104,
+            792,
+            938
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/2715fa0dbbb0eb4b2e3cfb3e172f54caa3891c68ab33d72ae7e72a19ccbc9435.jpg",
+        "image_caption": [
+            "Figure S8: Repeating unit cell accuracy. (A) For each position in 3-D space, we compute the difference between the truth and the reconstruction. We show different percentile bands of the reconstruction error between the target and predicted density, plotted using the mean square error (MSE). (B) For the species matrix from U-Net we ask what the error of top-1 predictions is between our predictions and the ground truth. (C) For our segmented matrices, we ask the distance from the nearest segmented atom to the ground truth. We show the distance errors by percentile for both the nearest true atom to each predicted atom and vice-versa (orange and blue, respectively). (D) After segmenting the reconstructed density maps we show the predicted and true number of atoms. (E) We plot the predicted nearest atom species versus the true species of the closest corresponding atom, as long as the distance is less than $0 . 5 \\mathring \\mathrm { \\mathrm { A } }$ . We find $6 5 . 4 \\%$ are correctly predicted. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            286,
+            805,
+            608
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/fec1c70feef090b9665cce8067981581ca15dee97b8ce3a537cf76b0d6cb21e5.jpg",
+        "image_caption": [
+            "Figure S9: Interpolation between two molecules. In (A) we show the interpolation between two crystal density maps. We show three equally spaced intermediates the corresponding segmentation. In (B), we show the same interpolation but highlight different two dimensional slices (y-axis). Along the $\\mathbf { X }$ -axis we label the fraction of the way between the two latent space vectors. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            256,
+            805,
+            715
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/0e74fa5ac1d8b18c6b8605a9ed9975dcf1137f638af2f6d2e30043233ec50c04.jpg",
+        "image_caption": [
+            "Figure S10: Conditional generation of molecules. We multiply the input and output of the bottleneck by the maximum density during training. Then, randomly decoding samples of $\\alpha \\mathbf { z }$ where $\\mathbf { z } \\sim \\mathcal { N } ( 0 , 1 )$ and $\\alpha$ is a random target, we find we are able to generate density maps that decode appropriately. If we take a true decoded value and re-scale the output we find we are able to control scale without affecting geometry. (A) We show the target and generated max value. (B) Using an encoded $\\mathbf { z }$ , we multiply it by different target values and decode them. We find that we are able to change scale without affecting the geometry. (C) We show a decoded sample. We cut away the right most corner facing the viewer. $\\mathbf { \\eta } ^ { ( \\mathbf { D } ) }$ For the molecule shown in (C), we show the results of varying one value in the latent space from -3 to 3. We plot the difference in the slice when compared the unaltered, decoded, $\\mathbf { z }$ for a slice that is in-plane with many atoms. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            287,
+            794,
+            604
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/d41bbb33b763cb8f62862c4c5f2a3af9df0ae401a41a28355085dcaed57d5822.jpg",
+        "image_caption": [
+            "Figure S11: Interpolation between two molecules. From $i - v$ we show two views of the output from the segmentation routine decoding the latent space between two different molecules. In the primed corresponding figures we show the density fields that are output by the decoder. We show the output of each grid normalized between 0-1 in blue-green and on a fixed color map in magma. We also vary the opacity to show the locations of predicted atoms. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            290,
+            800,
+            659
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/c65b020d6341425a2323154867c6b9dc320c173c64607cbc4760c5da8d95cc22.jpg",
+        "image_caption": [
+            "Figure S12: Results with smaller $\\beta$ . We decrease $\\beta$ by a factor of 10. By reducing the penalty on the KullbackLeibler (KL) term we are able to generate more accurate reconstructions. However, sampling $\\mathbf { z } \\sim \\mathcal { N } ( 0 , 1 )$ does not fully sample the encoded space of molecules. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            137,
+            799,
+            511
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/74d7ac4d6d4a712619001bbfdab66d8b49e2b430271ef077a6324faf7e074e45.jpg",
+        "image_caption": [
+            "Figure S13: $\\lambda$ prediction for different samples. Using the network in Fig. S12 we train a discriminator network to predict the “distance” from a real crystal. We apply this discriminator to real decoded samples, random latent space draws, and out of distribution draws (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            212,
+            648,
+            790,
+            828
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/a2d4e3798b857c00e00b5ddc63e4aa7ddbf927b4e7ead002db0de8bb464bf04d.jpg",
+        "image_caption": [
+            "Figure S14: Decoded samples of repeating unit cells. Results from the encoder-decoder. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            151,
+            777,
+            439
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "image",
+        "img_path": "images/9e97401d7f06566be399ea91e6d0acb6ec429d04f7c6b3fff01713fa27acdf4f.jpg",
+        "image_caption": [
+            "Figure S15: Segmented Output from the decoded samples. The segmented output from Fig. S14. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            569,
+            790,
+            852
+        ],
+        "page_idx": 22
+    }
+]

parse/train/ZBfUo_dr4H/ZBfUo_dr4H.md

@@ -0,0 +1,283 @@
+# DROID-SLAM: Deep Visual SLAM for Monocular, Stereo, and RGB-D Cameras
+
+Zachary Teed Jia Deng Princeton University {zteed,jiadeng}@princeton.edu
+
+# Abstract
+
+We introduce DROID-SLAM, a new deep learning based SLAM system. DROIDSLAM consists of recurrent iterative updates of camera pose and pixelwise depth through a Dense Bundle Adjustment layer. DROID-SLAM is accurate, achieving large improvements over prior work, and robust, suffering from substantially fewer catastrophic failures. Despite training on monocular video, it can leverage stereo or RGB-D video to achieve improved performance at test time. The URL to our open source code is https://github.com/princeton-vl/DROID-SLAM.
+
+# 1 Introduction
+
+Simultaneous Localization and Mapping (SLAM) aims to (1) build a map of the environment and (2) localize the agent within the environment. It is a special form of Structure-from-Motion (SfM) focused on accurate tracking of long-term trajectories. It is a critical capability for robotics, especially autonomous vehicles. In this work, we address visual SLAM, where sensor recordings come in the form of images captured from a monocular, stereo, or RGB-D camera.
+
+The SLAM problem has been approached from a number of different angles. Early work was built using probabilistic and filtering based approaches [12, 30], and alternating optimization of the map and camera poses [34, 16]. More recently, modern SLAM systems have leveraged least-squares optimization. A key element for accuracy has been full Bundle Adjustment (BA), which jointly optimizes the camera poses and the 3D map in a single optimization problem. One advantage of the optimization-based formulation is that a SLAM system can be easily modified to leverage different sensors. For example, ORB-SLAM3 [5] supports monocular, stereo, RGB-D, and IMU sensors, and modern systems can support a variety of camera models [5, 27, 42, 6]. Despite significant progress, current SLAM systems lack the robustness demanded for many real-world applications. Failures come in many forms, such as lost feature tracks, divergence in the optimization algorithm, and accumulation of drift.
+
+Deep learning has been proposed as a solution to many of these failure cases. Previous work has investigated replacing hand-crafted with learned features[13, 7, 29, 26, 35], using neural 3D representations[46, 1, 9, 45, 44, 25, 22], and combining learned energy terms with classical optimization backends[58, 57]. Other work has tried to learn SLAM or VO systems end-to-end [59, 47, 53, 52, 46]. While these systems are sometimes more robust, they fall far short of the accuracy of their classical counterparts on common benchmarks.
+
+In this work we introduce DROID-SLAM, a new SLAM system based on deep learning. It has state-of-the-art performance, outperforming existing SLAM systems, classical or learning-based, on challenging benchmarks with very large margins. In particular, it has the following advantages:
+
+• High Accuracy: We achieve large improvements over prior work across multiple datasets and modalities. On the TartanAir SLAM competition [54], we reduce error by $62 \%$ over the best prior result on the monocular track and $60 \%$ on the stereo track. We rank 1st on the
+
+![](images/1d529559adf3b5ab64f169b618c0c5f063e97ffd80568a42cc8609f1348f8b79.jpg)  
+Figure 1: DROID-SLAM can operate on monocular, stereo, and RGB-D video. It builds a dense 3D map of the environment while simultaneously localizing the camera within the map.
+
+ETH-3D RGB-D SLAM leaderboard [41], outperforming the second place by $3 5 \%$ under the AUC metric which considers both error and rate of catastrophic failure. On EuRoC [2], with monocular input, we reduce error by $82 \%$ among methods with zero failures, and by $43 \%$ over ORB-SLAM3 considering only the 10 out of 11 sequences it succeeds on. With stereo input, we reduce error by $71 \%$ over ORB-SLAM3. On TUM-RGBD [43], we reduce error by $83 \%$ among the methods with zero failures.
+
+• High Robustness: We have substantially fewer catastrophic failures than prior systems. On ETH-3D, we successfully track 30 of the 32 RGB-D datasets, while the next best successfully tracks only 19/32. On TartanAir, EuRoC, and TUM-RGBD, we have zero failures.
+
+• Strong Generalization: Our system, trained only with monocular input, can directly use stereo or RGB-D input to get improved accuracy without any retraining. All of our results across 4 datasets and 3 modalities are achieved by a single model, trained once with only monocular input entirely on the synthetic TartanAir dataset.
+
+The strong performance and generalization of DROID-SLAM is made possible by its “Differentiable Recurrent Optimization-Inspired Design” (DROID), which is an end-to-end differentiable architecture that combines the strengths of both classical approaches and deep networks. Specifically, it consists of recurrent iterative updates, building upon RAFT [48] for optical flow but introducing two key innovations.
+
+First, unlike RAFT, which iteratively updates optical flow, we iteratively update camera poses and depth. Whereas RAFT operates on two frames, our updates are applied to an arbitrary number of frames, enabling joint global refinement of all camera poses and depth maps, essential for minimizing drift for long trajectories and loop closures.
+
+Second, each update of camera poses and depth maps in DROID-SLAM is produced by a differentiable Dense Bundle Adjustment (DBA) layer, which computes a Gauss-Newton update to camera poses and dense per-pixel depth so as to maximize their compatibility with the current estimate of optical flow. This DBA layer leverages geometric constraints, improves accuracy and robustness, and enables a monocular system to handle stereo or RGB-D input without retraining.
+
+The design of DROID-SLAM is novel. The closest prior deep architectures are DeepV2D [47] and BA-Net [46], both of which were focused on depth estimation and reported limited SLAM results. DeepV2D alternates between updating depth and updating camera poses, instead of bundle adjustment. BA-Net has a bundle adjustment layer, but their layer is substantially different: it is not “dense” in that it optimizes over a small number of coefficients used to linearly combine a depth basis (a set of pre-predicted depth maps), whereas we optimize over per-pixel depth directly, without being handicapped by a depth basis. In addition, BA-Net optimizes photometric reprojection error (in feature space), whereas we optimize geometric error, leveraging state-of-the-art flow estimation.
+
+We perform extensive evaluation across four different datasets and three different sensor modalities, demonstrating state-of-the-art performance in all cases. We also include ablation studies that shed light on important design decisions and hyperparameters.
+
+# 2 Related Work
+
+Modern SLAM systems treat localization and mapping as a joint optimization problem [4].
+
+Visual SLAM focuses on observations in the form of monocular, stereo, or RGB-D images. These approaches are commonly categorized as either being direct or indirect [15]. Indirect approaches [31, 32, 5, 37] first process the image into an intermediate representation by detecting points of interest and attaching feature descriptors. Features are then matched between images. Indirect approaches optimize camera pose and a 3D point cloud by minimizing reprojection error–the distance between a projected 3D point and its location in the image.
+
+Direct approaches model the image formation process and define an objective function over photometric error [16, 15, 60]. One advantage of direct approaches is that they can model more information about the image, such as lines and intensity variations[15] which are not used by indirect approaches. However, photometric errors typically lead to more difficult optimization problems, and direct approaches are less robust to geometric distortion such as rolling shutter artifacts. This approach requires more sophisticated optimization techniques, such as coarse-to-fine image pyramids to avoid local minimum.
+
+Our method does not clearly fit into either of the categories. Like the direct approach, we do not require preprocessing steps to detect and match features between the images. We instead use the full image, allowing us to leverage a wider range of information than indirect methods with typically only use corners and edges. However, we minimize reprojection error similar to indirect methods. This is an easier optimization problem and avoids the need for more complicated representations such as image pyramids. In this sense, our approach borrows the best of both approaches: the smoother objective function of indirect approaches with the greater modeling capacity of indirect approaches.
+
+Deep Learning has more recently been applied to the SLAM problem. Many works have focused on training systems for particular subproblems, such as feature detection [13, 7, 29, 26, 35], feature matching and outlier rejection [38, 36], and localization [51, 39]. SuperGlue [38] was designed to perform feature matching and verification and make 2-view pose estimate much more robust. Our network also draws inspiration from Dusmanu et al[14], which builds a neural network into the SfM pipeline to improve keypoint localization accuracy.
+
+Other works have focused on training SLAM systems end-to-end [59, 46, 8, 50, 24, 47, 53]. These methods are not full SLAM systems, but instead focus on small scale reconstruction on the order of two [8, 50, 53] up to a dozen frames [59, 46, 47]. They lack many of the core capabilities of modern SLAM systems such as loop closure and global bundle adjustment which inhibit their ability to perform large scale reconstruction as demonstrated in our experiments. ∇SLAM[23] implements several existing SLAM algorithms as differentiable computation graphs, allowing for errors in the reconstruction to be backpropagated back to sensor measurements. While this approach is differentiable, it has no trainable parameters, meaning the performance of the system is limited by the accuracy of the classical algorithm they emulate.
+
+DeepFactors[9] is the most complete deep SLAM system, building on the earlier CodeSLAM[1]. It performs joint optimization of the pose and depth variables, and is capable of short and long-range loop closure. Similar to BA-Net[46], DeepFactors optimizes the parameters of a learned depth basis during inference. In contrast, we do not rely on a learned basis, but instead optimize pixelwise depth. This allows our network to better generalize to new datasets since our depth representation is not tied to the training dataset.
+
+# 3 Approach
+
+We take a video as input with two objectives: estimate the trajectory of the camera and build a 3D map of the environment. We first describe the monocular setting; in Sec. 3.4 we describe how to generalize the system to stereo and RGB-D video.
+
+Representation: Our network operates on an ordered collection of images, $\{ \mathbf { I } _ { t } \} _ { t = 0 } ^ { N }$ . For each image $t$ , we maintain two state variables: camera pose $\mathbf { G } _ { t } \in S E ( 3 )$ and inverse depth $\check { \mathbf { d } } _ { t } \in \mathbb { R } _ { + } ^ { H \times W }$ . The set of poses, $\{ \mathbf { G } _ { t } \} _ { t = 0 } ^ { N }$ , and set of inverse depths $\{ \mathbf { d } _ { t } \} _ { t = 0 } ^ { N }$ are unknown state variables, which get iteratively updated during inference as new frames are processed. For the reminder of the paper, when we refer to depths, note that we are using the inverse depth parameterization.
+
+We adopt a frame-graph $( \nu , \mathcal { E } )$ to represent co-visibility between frames. An edge $( i , j ) \in \mathcal { E }$ means image $\mathbf { I } _ { i }$ and $\mathbf { I } _ { j }$ have overlapping fields of view which shared points. The frame graph is built dynamically during training and inference. After each pose or depth update, we can recompute visibility to update the frame graph. If the camera returns to a previously mapped region, we add long range connections in the graph to perform loop closure.
+
+![](images/304389c6e297fe3835b1aedd0e7a558a3c31abe26192a228e5a023886a7925d9.jpg)  
+Figure 2: Illustration of the update operator. The operator acts on edges in the frame graph, predicting flow revisions which are mapped to depth and pose update through the (DBA) layer.
+
+# 3.1 Feature Extraction and Correlation
+
+Features are extracted from each new image added to they system. Key components of this stage are borrowed from RAFT[48].
+
+Feature Extraction Each of the input images are processed by a feature extraction network. The network consists of 6 residual blocks and 3 downsampling layers, producing dense feature maps at 1/8 the input image resolution. Like RAFT[48], we use two separate networks: a feature network and a context network. The feature network is used to build the set of correlation volumes, while the context features are injected into the network during each application of the update operator.
+
+Correlation Pyramid For each edge in the frame graph, $( i , j ) \in \mathcal { E }$ , we compute a 4D correlation volume by taking the dot product between all-pairs of feature vectors in $g _ { \boldsymbol { \theta } } ( I _ { i } )$ and $g _ { \boldsymbol { \theta } } ( I _ { j } )$
+
+$$
+C _ { u _ { 1 } v _ { 1 } u _ { 2 } v _ { 2 } } ^ { i j } = \langle g _ { \theta } ( I _ { i } ) _ { u _ { 1 } v _ { 1 } } , g _ { \theta } ( I _ { j } ) _ { u _ { 2 } v _ { 2 } } \rangle
+$$
+
+We then perform average pooling of the last two dimension of the correlation volume following RAFT[48] to form a 4-level correlation pyramid.
+
+Correlation Lookup We define a lookup operator which indexes the correlation volume using a grid with radius $r$ , $\mathbf { , } \ L _ { r } : \mathbb { R } ^ { H \times W \times H \times W } \times \mathbb { R } ^ { H \times W \times 2 } \mapsto \mathbb { R } ^ { H \times W \times ( r + 1 ) ^ { 2 } }$ .
+
+The lookup operator takes an $H \times W$ grid of coordinates as input and values are retrieved from the correlation volume using bilinear interpolation. The operator is applied to each correlation volume in the pyramid and the final feature vector is computed by concatenating the results at each level.
+
+# 3.2 Update Operator
+
+The core component of our SLAM system is a learned update operator show in Fig. 2. The update operator is a $3 \times 3$ convolutional GRU with hidden state $\mathbf { h }$ . Each application of the operator updates the hidden state, and additionally produces a pose update, $\Delta \xi ^ { ( k ) }$ , and depth update, $\Delta \mathbf { d } ^ { ( k ) }$ . The pose and depth updates are applied to the current depth and pose estimates through retraction on the SE3 manifold and vector addition respectively
+
+$$
+\mathbf { G } ^ { ( k + 1 ) } = \mathrm { E x p } ( \Delta \pmb { \xi } ^ { ( k ) } ) \circ \mathbf { G } ^ { ( k ) } , \qquad \mathbf { d } ^ { ( k + 1 ) } = \Delta \mathbf { d } ^ { ( k ) } + \mathbf { d } ^ { ( k ) } .
+$$
+
+Iterative applications of the update operator produce a sequence of poses and depths, with the expectation of converging to a fixed point $\{ \mathbf { G } ^ { ( k ) } \} \to \mathbf { G } ^ { * }$ , $\{ \mathbf { d } ^ { ( k ) } \}  \mathbf { d } ^ { * }$ , reflecting the true reconstruction.
+
+Correspondence At the start of each iteration we use the current estimates of poses and depths to estimate correspondence. Given a grid of pixel coordinates, $\mathbf { p } _ { i } \in \mathbb { R } ^ { H \times W \times 2 }$ in frame $i$ , we compute the dense correspondence field $\mathbf { p } _ { i j }$
+
+$$
+\mathbf { p } _ { i j } = \Pi _ { c } \big ( \mathbf { G } _ { i j } \circ \Pi _ { c } ^ { - 1 } \big ( \mathbf { p } _ { i } , \mathbf { d } _ { i } \big ) \big ) , \qquad \mathbf { p } _ { i j } \in \mathbb { R } ^ { H \times W \times 2 } \qquad \mathbf { G } _ { i j } = \mathbf { G } _ { j } \circ \mathbf { G } _ { i } ^ { - 1 } .
+$$
+
+for each edge $( i , j ) \in \mathcal { E }$ in the frame graph. Here $\Pi _ { c }$ is the camera model mapping a set of 3D points onto the image and $\Pi _ { c } ^ { - 1 }$ is the inverse projection function mapping inverse depth map d and coordinate grid $\mathbf { p } _ { i }$ to a 3D point cloud (we provide formulas and Jacobians in the appendix). $\mathbf { p } _ { i j }$ represents the coordinates of pixels $\mathbf { p } _ { i }$ mapped into frame $j$ using the estimated pose and depth.
+
+Inputs We use the correspondence field to index the correlation volumes. For each edge $( i , j ) \in \mathcal { E }$ we use $\mathbf { p } _ { i j }$ to perform lookup from the correlation volume $\mathbf { C } _ { i j }$ to retrieve correlation features. Additionally, we use the correspondence field to derive optical flow induced by camera motion as the difference $\mathbf { p } _ { i j } - \mathbf { p } _ { j }$ . Furthermore, the residual from the previous BA solution is concatenated with the flow field allowing the network to use feedback from the previous iteration.
+
+The correlation features provide information about visual similarity in the neighbourhood of $\mathbf { p } _ { i j }$ allowing the network to learn to align visually similar image regions. However, correspondence is sometimes ambiguous. The flow provides an complementary source of information allowing the network to exploit smoothness in the motion fields to gain robustness.
+
+Update The correlation features and flow features are each mapped through two convolutional layers before being injected into the GRU. Additionally, we inject context features, as extracted by the context network, into the GRU through element-wise addition.
+
+The ConvGRU is a local operation with a small receptive field. We extract global context by averaging the hidden state across the spatial dimensions of the image and use this feature vector as additional input to the GRU. Global context is important in SLAM because incorrect correspondences, caused by large moving objects for example, can degrade the accuracy of the system. It is important for the network to recognize and reject erroneous correspondence.
+
+The GRU produces an updated hidden state $\mathbf { h } ^ { ( k + 1 ) }$ . Instead of predicting updates to the depth or pose directly, we instead predict updates in the space of dense flow fields. We map the hidden state through two additional convoluation layers to produce two outputs: (1) a revision flow field $\mathbf { r } _ { i j } \in \mathbb { R } ^ { H \times W \times 2 }$ and (2) associated confidence map $\mathbf { w } _ { i j } \in \mathbb { R } _ { + } ^ { H \times W \times 2 }$ . The revision $\mathbf { r } _ { i j }$ is a correction term predicted by the network to correct errors in the dense correspondence field. We denote the corrected correspondence as $\mathbf { p } _ { i j } ^ { * } = \mathbf { r } _ { i j } + \mathbf { p } _ { i j }$
+
+We then pool the hidden state over all features which share the same source view $i$ and predict a pixel-wise damping factor $\lambda$ . We use the softplus operator to ensure that the damping term is positive. Additionally, we use the pooled features to predict a $8 \mathrm { x } 8$ mask which can be used to upsample the inverse depth estimate.
+
+Dense Bundle Adjustment Layer (DBA) The Dense Bundle Adjustment Layer (DBA) maps the set of flow revisions into a set of pose and pixelwise depth updates. We define the cost function over the entire frame graph
+
+$$
+\mathbf { E } ( \mathbf { G } ^ { \prime } , \mathbf { d } ^ { \prime } ) = \sum _ { ( i , j ) \in \mathcal { E } } \big \| \mathbf { p } _ { i j } ^ { * } - \Pi _ { c } \big ( \mathbf { G } _ { i j } ^ { \prime } \circ \Pi _ { c } ^ { - 1 } \big ( \mathbf { p } _ { i } , \mathbf { d } _ { i } ^ { \prime } \big ) \big ) \big \| _ { \Sigma _ { i j } } ^ { 2 } \qquad \Sigma _ { i j } = \mathrm { d i a g } \mathbf { w } _ { i j } .
+$$
+
+where $\lVert \cdot \rVert _ { \Sigma }$ is the Mahalanobis distance which weights the error terms based on the confidence weights $\mathbf { w } _ { i j }$ . Eqn. 4 states that we want an updated pose $\mathbf { G } ^ { \prime }$ and depth $\mathbf { d } ^ { \prime }$ such that reprojected points match the revised correspondence $\mathbf { p } _ { i j } ^ { * }$ as predicted by the update operator.
+
+We use local parameterization to linearize Eqn. 4 and use the Gauss-Newton algorithm solve for updates $( \Delta \xi , \Delta \mathbf { d } )$ . Since each term in Eqn. 4 only includes a single depth variable, the Hessian matrix has block diagonal structure. Separating pose and depth variables, the system can be solved efficiently using the Schur complement with the pixelwise damping factor $\lambda$ added to the depth block
+
+$$
+\begin{array} { r }  \left[ \begin{array} { l l } { \mathbf { B } } & { \mathbf { E } } \\ { \mathbf { E } ^ { T } } & { \mathbf { C } } \end{array} \right] \left[ \boldsymbol { \Delta } \pmb { \xi } \right] = \left[ \mathbf { v } \right] \qquad \begin{array} { r l } & { \boldsymbol { \Delta } \pmb { \xi } = [ \mathbf { B } - \mathbf { E } \mathbf { C } ^ { - 1 } \mathbf { E } ^ { T } ] ^ { - 1 } ( \mathbf { v } - \mathbf { E } \mathbf { C } ^ { - 1 } \mathbf { w } ) } \\ & { \boldsymbol { \Delta } \mathbf { d } = \mathbf { C } ^ { - 1 } ( \mathbf { w } - \mathbf { E } ^ { T } \boldsymbol { \Delta } \pmb { \xi } ) } \end{array} \end{array}
+$$
+
+where $\mathbf { C }$ is diagonal and can be cheaply inverted ${ \bf C } ^ { - 1 } = 1 / { \bf C }$ . The DBA layer is implemented as part of the computation graph and backpropogation is performed through the layer during training.
+
+# 3.3 Training
+
+Our SLAM system is implemented in PyTorch and we use the LieTorch extension [49] to perform backprogation in the tangent space of all group elements.
+
+Removing gauge freedom In the monocular setting, the network is only able to recover the trajectory of the camera up to a similarity transform. One solution is to define a loss which is invariant to similarity transforms. However, the gauge-freedom still exists during training which poorly impacts the conditioning of the linear system and the stability of the gradients. We solve this problem by fixing the first two poses to the ground-truth poses of each training sequence. Fixing the first pose removes the 6-dof gauge freedom. Fixing the second pose resolves the scale freedom.
+
+Constructing training video Each training example consists of a 7-frame video sequence. In order to ensure stable training and good downstream performance, we want to sample videos which are not too easy nor too difficult.
+
+The training set is composed of a collection of videos. For each video $i$ of length $N _ { i }$ , we precompute an $N _ { i } \times N _ { i }$ distance matrix storing the average optical flow magnitude between each pair of frames. However, not all frames are covisible; and frames pairs with less than $50 \%$ overlap are assigned a distance of infinity. During training, we dynamically generate videos by sampling paths in the distance matrix, such that the average flow between adjacent video frames is between 8px and 96px.
+
+Supervision We supervise our network using a combination of pose loss and flow loss. The flow loss is applied to pairs of adjacent frames. We compute the optical flow induced by the predicted depth and poses and the flow induced by the ground truth depth and poses. The loss is taken to be the average l2 distance between the two flow fields.
+
+Given a set of ground truth poses $\{ \mathbf { T } \} _ { i } ^ { N }$ and predicted poses $\{ \mathbf { G } \} _ { i } ^ { N }$ , the pose loss is taken to be the distance between the ground truth and predicted poses, $\begin{array} { r } { \mathcal { L } _ { p o s e } = \sum _ { i } | | \operatorname { L o g } _ { S E 3 } ( \mathbf { T } _ { i } ^ { - 1 } \cdot \mathbf { G } _ { i } ) | | _ { 2 } } \end{array}$ . We apply the losses to the output of every iteration with exponentially increasing weight using $\gamma = 0 . 9$ .
+
+# 3.4 SLAM System
+
+During inference, we compose the network into a full SLAM system. The SLAM system takes a video stream as input, and performs reconstruction and localization in real-time. Our system contains two threads which run asynchronously. The frontend thread takes in new frames, extracts features, selects keyframes, and performs local bundle adjustment. The backend thread simultaneously performs global bundle adjustment over the entire history of keyframes. We provide an overview of the system here, and provide more information in the appendix.
+
+Initialization Initialization is simple with DROID-SLAM. We simply collect frames until we have a set of 12. As we accumulate frames, we only keep the previous frame if optical flow is greater than 16px (estimated by applying one update iteration). Once 12 frames have been accumulated, we initialize a frame graph by creating an edges between keyframes which are within 3 timesteps apart, then run 10 iterations of the update operator.
+
+Frontend The frontend operates directly on the incoming video stream. It maintains a collection of keyframes and a frame graph storing edges between covisible kefyrames. Keyframe poses and depths are actively being optimized. Features are first extracted from the incoming frames. The new frame is then added to the frame graph adding edges with its 3 closest neighbors as measured by mean optical flow. The pose is initialized using a linear motion model. We then apply several iterations of the update operator to update keyframe poses and depths. We fix the first two poses to remove gauge freedom but treat all depths as free variables.
+
+After the new frame is tracked, we select a keyframe for removal. We compute distance between pairs of frames by computing the average optical flow magnitude and remove redundant frames. If no frame is a good candidate for removal, we remove the oldest keyframe.
+
+Backend The backend performs global bundle adjustment over the entire history of keyframes. During each iteration, we rebuild the frame graph using the flow between all pairs of keyframes, represented as an $N \times N$ distance matrix. We first add edges between temporally adjacent keyframes. We then sample new edges from the distance matrix in order of increasing flow. With each selected edge, we suppress neighboring edges within a distance of 2, where distance is defined as the Chebyshev distance between index pairs $| | ( i , j ) - ( k , l ) | | _ { \infty } = \operatorname* { m a x } ( | i - k | , | j - l | )$ .
+
+We then apply the update operator to the entire frame graph, often consisting of thousands of frames and edges. Storing the full set of correlation volumes would quickly exceed video memory. Instead, we use the memory efficient implementation proposed in RAFT [48].
+
+![](images/9272db540c28a43e8ab054074f443b10bc601aba4494a3370e157a7c168fc922.jpg)  
+Figure 3: DROID-SLAM can generalize to new datasets. In order, we show results from Tanks & Temples [21], ScanNet [10], Sintel [3], and ETH-3D [41]; all using monocular video.
+
+During training, we implement dense bundle adjustment in PyTorch to leverage the automatic differentiation engine. At inference time, we use a custom CUDA kernel which takes advantage of the block-sparse structure of the problem, then perform sparse Cholesky decomposition on the reduced camera block.
+
+We only perform full bundle adjustment on keyframe images. In order to recover the poses of non-keyframes, we perform motion-only bundle adjustment by iteratively estimating flow between each keyframe and its neighboring non-keyframes. During testing, we evaluate on the full camera trajectory, not just keyframes.
+
+Stereo and RGB-D Our system can be easily modified for stereo and RGB-D video. In the case of RGB-D, we still treat depth as a variable, since sensor depth can be noisy and have missing observations, and simply add a term to the optimization objective (Eqn. 4) which penalizes the squared distance between the measured and predicted depth. For stereo, we use the exact same system described above, with just double the frames, and fix the relative pose between the left and right frames in the DBA layer. Cross camera edges in the graph allow us to leverage stereo information.
+
+# 4 Experiments
+
+We experiment on a diverse set of datasets and sensor modalities. We compare to both deep learning and established classical SLAM algorithms and put specific emphasis on cross-dataset generalization. Following prior work, we evaluate the accuracy of the camera trajectory [31, 15, 41], primarily using Absolute Trajectory Error (ATE) [43]. While some datasets have ground truth point clouds [21], there is no standard protocol to compare 3D reconstructions directly given by SLAM systems because a SLAM systems can choose which 3D points to reconstruct. Evaluating dense 3D reconstruction is typically considered in the domain of Multiview Stereo [19] and outside the scope of this work.
+
+Our network is trained entirely on monocular video from the synthetic TartanAir dataset [54]. We train our network for 250k steps with a batch size of 4, resolution $3 8 4 \times 5 1 2$ , and 7 frame clips, and unroll 15 update iterations. Training takes 1 week on 4 RTX-3090 GPUs.
+
+Table 1: Results on the TartanAir monocular benchmark.   
+
+<table><tr><td>Monocular</td><td>MH000</td><td>MH001</td><td>MH002</td><td>MH003</td><td>MH004</td><td>MH005</td><td>MH006</td><td>MH007</td><td>Avg</td></tr><tr><td>ORB-SLAM[31]</td><td>1.30</td><td>0.04</td><td>2.37</td><td>2.45</td><td>X</td><td>X</td><td>21.47</td><td>2.73</td><td>-</td></tr><tr><td>DeepV2D[47]</td><td>6.15</td><td>2.12</td><td>4.54</td><td>3.89</td><td>2.71</td><td>11.55</td><td>5.53</td><td>3.76</td><td>5.03</td></tr><tr><td>TartanVO [53]</td><td>4.88</td><td>0.26</td><td>2.00</td><td>0.94</td><td>1.07</td><td>3.19</td><td>1.00</td><td>2.04</td><td>1.92</td></tr><tr><td>Ours</td><td>0.08</td><td>0.05</td><td>0.04</td><td>0.02</td><td>0.01</td><td>1.31</td><td>0.30</td><td>0.07</td><td>0.24</td></tr></table>
+
+TartanAir [54] (Monocular & Stereo) The TartanAir dataset is a challenging synthetic benchmark for evaluating SLAM algorithms and was used as part of the ECCV 2020 SLAM competition. We use the official test split [54], and provide ATE across all “Hard” sequences in Tab. 1.
+
+Tab. 1 demonstrates both the robustness of our method (no catastrophic failures) and accuracy (very low drift). We retrain DeepV2D [47] on TartanAir as a baseline. On most sequences, we outperform existing methods by an order-of-magnitude and achieve ${ } ^ { 8 \mathrm { { X } } }$ lower average error than TartanVO [53] and $2 0 \mathrm { x }$ lower than DeepV2D [47]. We also use the TartanAir dataset to compare with the top submissions to the ECCV 2020 SLAM competition in Tab. 2. The top two submissions use systems
+
+<table><tr><td></td><td>Mono.</td><td>Stereo</td></tr><tr><td>OV²SLAM[17]</td><td>0.510</td><td>0.182</td></tr><tr><td>VOLDOR [28] + COLMAP [40]</td><td>0.440</td><td>0.177</td></tr><tr><td>SuperGlue [38] + SuperPoint [13] + COLMAP [40]</td><td>0.340</td><td>0.119</td></tr><tr><td>Ours</td><td>0.129</td><td>0.047</td></tr></table>
+
+Table 2: Results on the TartanAir test set, compared with the top 3 submission to the ECCV 2020 SLAM competition. The score is computed using normalized relative pose error for all possible sequences of length $\{ 5 , 1 0 , 1 5 , . . . , 4 0 \}$ meters, see competition page for details.
+
+built on top of COLMAP [40] and run $4 0 \mathbf { x }$ slower than real-time. Our method, on the other hand, runs 16x faster and achieves an error $62 \%$ lower on the monocular benchmark and $60 \%$ lower on the stereo benchmark.
+
+EuRoC [2] (Monocular & Stereo) In the remaining experiments, we are interested in the ability of our network to generalize to new cameras and environments. The EuRoC dataset consists of video captured from sensor on-board a micro aerial vehicle (MAV) and is a widely used benchmark to evaluate SLAM systems. We use the EuRoC dataset to evaluate both monocular and stereo performance and report results on Tab. 3.
+
+Table 3: Monocular SLAM on the EuRoC datasets, ATE[m]. † denotes visual odometry methods.   
+
+<table><tr><td colspan="2"></td><td>MH01</td><td>MH02</td><td>MH03</td><td>MH04</td><td>MH05</td><td>V101</td><td>V102</td><td>V103</td><td>V201</td><td>V202</td><td>V203</td><td>Avg</td></tr><tr><td rowspan="5">qH/deea</td><td>DeepFactors [9]</td><td>1.587</td><td>1.479</td><td>3.139</td><td>5.331</td><td>4.002</td><td>1.520</td><td>0.679</td><td>0.900</td><td>0.876</td><td>1.905</td><td>1.021</td><td>2.040</td></tr><tr><td>DeepV2D [47]t</td><td>0.739</td><td>1.144</td><td>0.752</td><td>1.492</td><td>1.567</td><td>0.981</td><td>0.801</td><td>1.570</td><td>0.290</td><td>2.202</td><td>2.743</td><td>1.298</td></tr><tr><td>DeepV2D (Tartan Air)†</td><td>1.614</td><td>1.492</td><td>1.635</td><td>1.775</td><td>1.013</td><td>0.717</td><td>0.695</td><td>1.483</td><td>0.839</td><td>1.052</td><td>0.591</td><td>1.173</td></tr><tr><td>TartanVO1 [53]†</td><td>0.639</td><td>0.325</td><td>0.550</td><td>1.153</td><td>1.021</td><td>0.447</td><td>0.389</td><td>0.622</td><td>0.433</td><td>0.749</td><td>1.152</td><td>0.680</td></tr><tr><td>D3VO + DSO [57]t</td><td>-</td><td>-</td><td>0.08</td><td>-</td><td>0.09</td><td>-</td><td>-</td><td>0.11</td><td>-</td><td>0.05</td><td>0.19</td><td>-</td></tr><tr><td rowspan="4">Cesssssr</td><td>ORB-SLAM [31]</td><td>0.071</td><td>0.067</td><td>0.071</td><td>0.082</td><td>0.060</td><td>0.015</td><td>0.020</td><td>X</td><td>0.021</td><td>0.018</td><td>X</td><td>-</td></tr><tr><td>DSO [15]t</td><td>0.046</td><td>0.046</td><td>0.172</td><td>3.810</td><td>0.110</td><td>0.089</td><td>0.107</td><td>0.903</td><td>0.044</td><td>0.132</td><td>1.152</td><td>0.601</td></tr><tr><td>SVO[18]t</td><td>0.100</td><td>0.120</td><td>0.410</td><td>0.430</td><td>0.300</td><td>0.070</td><td>0.210</td><td>X</td><td>0.110</td><td>0.110</td><td>1.080</td><td>·</td></tr><tr><td>DSM[60] ORB-SLAM3 [5]</td><td>0.039</td><td>0.036</td><td>0.055</td><td>0.057</td><td>0.067</td><td>0.095</td><td>0.059</td><td>0.076</td><td>0.056</td><td>0.057</td><td>0.784</td><td>0.126</td></tr><tr><td colspan="2">Ours (odometry only)†</td><td>0.016</td><td>0.027</td><td>0.028</td><td>0.138</td><td>0.072</td><td>0.033</td><td>0.015</td><td>0.033</td><td>0.023</td><td>0.029</td><td>X</td><td>-</td></tr><tr><td colspan="2">Ours</td><td>0.163 0.013</td><td>0.121 0.014</td><td>0.242 0.022</td><td>0.399 0.043</td><td>0.270 0.043</td><td>0.103 0.037</td><td>0.165 0.012</td><td>0.158</td><td>0.020</td><td>0.102 0.115 0.017 0.013</td><td>0.204 0.014</td><td>0.186 0.022</td></tr></table>
+
+In the monocular setting, we achieve an average ATE of $2 . 2 \mathrm { c m }$ , reducing error by $82 \%$ among methods with zero failures, and by $43 \%$ over ORB-SLAM3 when only comparing sequences where ORB-SLAM3 is successful.
+
+We compare to several deep learning approaches. We compare to DeepV2D trained on the TartanAir dataset and the publicly available version trained on NYUv2 [33] and ScanNet[10]. DeepFactors [9] was trained on ScanNet. We find that recent deep learning approaches [9, 47, 53] perform poorly on the EuRoC dataset compared to classical SLAM systems. This is due to poor generalization and dataset biases which lead to large amounts of drift; our method does not suffer from these issues. D3VO [57] is able to achieve both good robustness and accuracy by combining a neural network frontend with DSO as a backend, using 6 of the 11 sequences for evaluation and performing unsupervised training on the remaining ones, which contain the same scenes used for evaluation.
+
+TUM-RGBD [43] The RGBD dataset consists of indoor scenes captured with handheld camera. This is a notoriously difficult dataset for monocular methods due to rolling shutter artifacts, motion blur, and heavy rotation. We benchmark prior work on the entirety of the freiburg1 set in Tab. 4.
+
+Classical SLAM algorithms such as ORB-SLAM tend to fail on most of the sequences. While deep learning methods are more robust, they obtain low accuracy on most of the evaluated sequences. Our
+
+<table><tr><td></td><td>360</td><td>desk</td><td>desk2</td><td>floor</td><td>plant</td><td>room</td><td>rpy</td><td>teddy</td><td>xyz</td><td>avg</td></tr><tr><td>ORB-SLAM2 [32] ORB-SLAM3[5]</td><td>X X</td><td>0.071 0.017</td><td>X 0.210</td><td>0.023 X</td><td>X 0.034</td><td>X X</td><td>X X</td><td>X X</td><td>0.010 0.009</td><td>： -</td></tr><tr><td>DeepTAM1 [59]</td><td>0.111</td><td>0.053</td><td>0.103</td><td>0.206</td><td>0.064</td><td>0.239</td><td>0.093</td><td>0.144</td><td>0.036</td><td>0.116</td></tr><tr><td>TartanVO² [53]</td><td>0.178</td><td>0.125</td><td>0.122</td><td>0.349</td><td>0.297</td><td>0.333</td><td>0.049</td><td>0.339</td><td>0.062</td><td>0.206</td></tr><tr><td>DeepV2D [47]</td><td>0.243</td><td>0.166</td><td>0.379</td><td>1.653</td><td>0.203</td><td>0.246</td><td>0.105</td><td>0.316</td><td>0.064</td><td>0.375</td></tr><tr><td>DeepV2D (TartanAir)</td><td>0.182</td><td>0.652</td><td>0.633</td><td>0.579</td><td>0.582</td><td>0.776</td><td>0.053</td><td>0.602</td><td>0.150</td><td>0.468</td></tr><tr><td>DeepFactors [9]</td><td>0.159</td><td>0.170</td><td>0.253</td><td>0.169</td><td>0.305</td><td>0.364</td><td>0.043</td><td>0.601</td><td>0.035</td><td>0.233</td></tr><tr><td>Ours</td><td>0.111</td><td>0.018</td><td>0.042</td><td>0.021</td><td>0.016</td><td>0.049</td><td>0.026</td><td>0.048</td><td>0.012</td><td>0.038</td></tr></table>
+
+Table 4: ATE on the TUM-RGBD benchmark. All methods are provided mono. video, 1except DeepTAM which uses RGB-D and 2TartanVO which uses ground truth to scale relative pose.
+
+method is both robust and accurate. It successfully tracks all 9 sequences while achieving $83 \%$ lower ATE than DeepFactors [9] and which succeeds on all videos and $90 \%$ lower ATE than DeepV2D [47].
+
+![](images/be9d1f884bf4e0054f381943dd26e4c24baf1db7982edbe0eb27578756eb52ae.jpg)  
+Figure 4: Generalization results on the RGB-D ETH3D-SLAM benchmark. (Left) Our method, which is trained only on the synthetic TartanAir dataset, ranks 1st on both the train and test splits. (Right) Plot of the number successful trajectories as a function of ATE. Our method successfully tracks 30/32 of the datasets where image data is available.
+
+ETH3D-SLAM [41] (RGB-D) Finally, we evaluate the RGB-D performance on the ETH3D-SLAM benchmark. In this setup, the network is also provided measurements from an RGB-D camera. We take our network trained on TartanAir and add an addition term in the optimization objective penalizing the distance between the predicted inv. depth and inv. depth measured by the sensor. Without any finetuning, our method ranks 1st on both the train and test splits. Several of the datasets are "dark" meaning no image data is available; on these datasets we do not submit any predictions. On the test set, we successfully track 30/32 RGB-D, improving over the next best of 19/32.
+
+Timing and Memory Our system can run in real-time with 2 3090 GPUs. Tracking and local BA is run on the first GPU, while global BA and loop closure is run on the second. On EuRoC, we average 20fps (camera hz) by downsampling to $3 2 0 \times 5 1 2$ resolution and skipping every other frame. Results in Tab. 3 were obtained in this setting. On TUM-RGBD, we average 30fps by downsampling to $2 4 0 \times 3 2 0$ and skipping every other frame, again the reported results where obtained in this setting. On TartanAir, due to much faster camera motion, we are unable to run in real-time, averaging 8fps. However, this is still a 16x speedup over the top 2 submissions to the TartanAir SLAM challenge, which rely on COLMAP [40].
+
+The SLAM frontend can be run on GPUs with 8GB of memory. The backend, which requires storing feature maps from the full set of images, is more memory intensive. All results on TUM-RGBD can be produced on a single 1080Ti graphics card. Results on EuRoC, TartanAir and ETH-3D (where video can be up to 5000 frames) requires a GPU with 24GB memory. While memory and resource requirements are currently the biggest limitation of our system, we believe these can be drastically reduced by culling redundant computation and more efficient representations.
+
+# 5 Conclusion
+
+We introduce DROID-SLAM, an end-to-end neural architecture for visual SLAM. DROID-SLAM is accurate, robust, and versatile and can be used on monocular, stereo, and RGB-D video. It outperforms prior work by large margins on challenging benchmarks.
+
+Acknowledgements This work is partially supported by the National Science Foundation under Award IIS-1942981.
+
+# References
+
+optimisable representation for dense visual slam. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2560–2568, 2018.   
+[2] M. Burri, J. Nikolic, P. Gohl, T. Schneider, J. Rehder, S. Omari, M. W. Achtelik, and R. Siegwart. The euroc micro aerial vehicle datasets. The International Journal of Robotics Research, 35(10):1157–1163, 2016.   
+[3] D. J. Butler, J. Wulff, G. B. Stanley, and M. J. Black. A naturalistic open source movie for optical flow evaluation. In A. Fitzgibbon et al. (Eds.), editor, European Conf. on Computer Vision (ECCV), Part IV, LNCS 7577, pages 611–625. Springer-Verlag, Oct. 2012.   
+[4] C. Cadena, L. Carlone, H. Carrillo, Y. Latif, D. Scaramuzza, J. Neira, I. Reid, and J. J. Leonard. Past, present, and future of simultaneous localization and mapping: Toward the robust-perception age. IEEE Transactions on robotics, 32(6):1309–1332, 2016.   
+[5] C. Campos, R. Elvira, J. J. G. Rodríguez, J. M. Montiel, and J. D. Tardós. Orb-slam3: An accurate open-source library for visual, visual-inertial and multi-map slam. arXiv preprint arXiv:2007.11898, 2020.   
+[6] D. Caruso, J. Engel, and D. Cremers. Large-scale direct slam for omnidirectional cameras. In 2015 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 141–148. IEEE, 2015.   
+[7] C. B. Choy, J. Gwak, S. Savarese, and M. Chandraker. Universal correspondence network. arXiv preprint arXiv:1606.03558, 2016.   
+[8] R. Clark, M. Bloesch, J. Czarnowski, S. Leutenegger, and A. J. Davison. Ls-net: Learning to solve nonlinear least squares for monocular stereo. arXiv preprint arXiv:1809.02966, 2018. [9] J. Czarnowski, T. Laidlow, R. Clark, and A. J. Davison. Deepfactors: Real-time probabilistic dense monocular slam. IEEE Robotics and Automation Letters, 5(2):721–728, 2020.   
+[10] A. Dai, A. X. Chang, M. Savva, M. Halber, T. Funkhouser, and M. Nießner. Scannet: Richly-annotated 3d reconstructions of indoor scenes. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5828–5839, 2017.   
+[11] A. Dai, M. Nießner, M. Zollhöfer, S. Izadi, and C. Theobalt. Bundlefusion: Real-time globally consistent 3d reconstruction using on-the-fly surface reintegration. ACM Transactions on Graphics (ToG), 36(4):1, 2017.   
+[12] A. J. Davison, I. D. Reid, N. D. Molton, and O. Stasse. Monoslam: Real-time single camera slam. IEEE transactions on pattern analysis and machine intelligence, 29(6):1052–1067, 2007.   
+[13] D. DeTone, T. Malisiewicz, and A. Rabinovich. Superpoint: Self-supervised interest point detection and description. In Proceedings of the IEEE conference on computer vision and pattern recognition workshops, pages 224–236, 2018.   
+[14] M. Dusmanu, J. L. Schonberger, and M. Pollefeys. Multi-view optimization of local feature geometry. In Proceedings of the 2020 European Conference on Computer Vision, 2020.   
+[15] J. Engel, V. Koltun, and D. Cremers. Direct sparse odometry. IEEE transactions on pattern analysis and machine intelligence, 40(3):611–625, 2017.   
+[16] J. Engel, T. Schöps, and D. Cremers. Lsd-slam: Large-scale direct monocular slam. In European conference on computer vision, pages 834–849. Springer, 2014.   
+[17] M. Ferrera, A. Eudes, J. Moras, M. Sanfourche, and G. Le Besnerais. Ov2 slam: A fully online and versatile visual slam for real-time applications. IEEE Robotics and Automation Letters, 6(2):1399–1406, 2021.   
+[18] C. Forster, Z. Zhang, M. Gassner, M. Werlberger, and D. Scaramuzza. Svo: Semidirect visual odometry for monocular and multicamera systems. IEEE Transactions on Robotics, 33(2):249–265, 2016.   
+[19] Y. Furukawa and C. Hernández. Multi-view stereo: A tutorial. Foundations and Trends® in Computer Graphics and Vision, 9(1-2):1–148, 2015.   
+[20] C. Kerl, J. Sturm, and D. Cremers. Dense visual slam for rgb-d cameras. In 2013 IEEE/RSJ International Conference on Intelligent Robots and Systems, pages 2100–2106. IEEE, 2013.   
+[21] A. Knapitsch, J. Park, Q.-Y. Zhou, and V. Koltun. Tanks and temples: Benchmarking large-scale scene reconstruction. ACM Transactions on Graphics (ToG), 36(4):1–13, 2017.   
+[22] J. Kopf, X. Rong, and J.-B. Huang. Robust consistent video depth estimation. arXiv preprint arXiv:2012.05901, 2020.   
+[23] J. Krishna Murthy, S. Saryazdi, G. Iyer, and L. Paull. gradslam: Dense slam meets automatic differentiation. arXiv, 2020.   
+[24] C. Liu, J. Gu, K. Kim, S. G. Narasimhan, and J. Kautz. Neural rgb (r) d sensing: Depth and uncertainty from a video camera. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 10986–10995, 2019.   
+[25] X. Luo, J.-B. Huang, R. Szeliski, K. Matzen, and J. Kopf. Consistent video depth estimation. ACM Transactions on Graphics (TOG), 39(4):71–1, 2020.   
+[26] Zhu, R. Zhang, Yao, Quan. Learning local descriptors by integrating geometry constraints. In Proceedings of the European conference on computer vision (ECCV), pages 168–183, 2018.   
+[27] H. Matsuki, L. von Stumberg, V. Usenko, J. Stückler, and D. Cremers. Omnidirectional dso: Direct sparse odometry with fisheye cameras. IEEE Robotics and Automation Letters, 3(4):3693–3700, 2018.   
+[28] Z. Min, Y. Yang, and E. Dunn. Voldor: Visual odometry from log-logistic dense optical flow residuals. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4898–4909, 2020.   
+[29] A. Mishchuk, D. Mishkin, F. Radenovic, and J. Matas. Working hard to know your neighbor’s margins: Local descriptor learning loss. arXiv preprint arXiv:1705.10872, 2017.   
+[30] A. I. Mourikis and S. I. Roumeliotis. A multi-state constraint kalman filter for vision-aided inertial navigation. In Proceedings 2007 IEEE International Conference on Robotics and Automation, pages 3565–3572. IEEE, 2007.   
+[31] R. Mur-Artal, J. M. M. Montiel, and J. D. Tardos. Orb-slam: a versatile and accurate monocular slam system. IEEE transactions on robotics, 31(5):1147–1163, 2015.   
+[32] R. Mur-Artal and J. D. Tardós. Orb-slam2: An open-source slam system for monocular, stereo, and rgb-d cameras. IEEE Transactions on Robotics, 33(5):1255–1262, 2017.   
+[33] P. K. Nathan Silberman, Derek Hoiem and R. Fergus. Indoor segmentation and support inference from rgbd images. In ECCV, 2012.   
+[34] R. A. Newcombe, S. J. Lovegrove, and A. J. Davison. Dtam: Dense tracking and mapping in real-time. In 2011 international conference on computer vision, pages 2320–2327. IEEE, 2011.   
+[35] Y. Ono, E. Trulls, P. Fua, and K. M. Yi. Lf-net: Learning local features from images. arXiv preprint arXiv:1805.09662, 2018.   
+[36] R. Ranftl and V. Koltun. Deep fundamental matrix estimation. In Proceedings of the European conference on computer vision (ECCV), pages 284–299, 2018.   
+[37] A. Rosinol, M. Abate, Y. Chang, and L. Carlone. Kimera: an open-source library for real-time metricsemantic localization and mapping. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 1689–1696. IEEE, 2020.   
+[38] P.-E. Sarlin, D. DeTone, T. Malisiewicz, and A. Rabinovich. Superglue: Learning feature matching with graph neural networks. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 4938–4947, 2020.   
+[39] P.-E. Sarlin, A. Unagar, M. Larsson, H. Germain, C. Toft, V. Larsson, M. Pollefeys, V. Lepetit, L. Hammarstrand, F. Kahl, et al. Back to the feature: Learning robust camera localization from pixels to pose. arXiv preprint arXiv:2103.09213, 2021.   
+[40] J. L. Schonberger and J.-M. Frahm. Structure-from-motion revisited. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 4104–4113, 2016.   
+[41] T. Schops, T. Sattler, and M. Pollefeys. Bad slam: Bundle adjusted direct rgb-d slam. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 134–144, 2019.   
+[42] D. Schubert, N. Demmel, V. Usenko, J. Stuckler, and D. Cremers. Direct sparse odometry with rolling shutter. In Proceedings of the European Conference on Computer Vision (ECCV), pages 682–697, 2018.   
+[43] J. Sturm, N. Engelhard, F. Endres, W. Burgard, and D. Cremers. A benchmark for the evaluation of rgb-d slam systems. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pages 573–580. IEEE, 2012.   
+[44] E. Sucar, S. Liu, J. Ortiz, and A. J. Davison. imap: Implicit mapping and positioning in real-time. arXiv preprint arXiv:2103.12352, 2021.   
+[45] E. Sucar, K. Wada, and A. Davison. Nodeslam: Neural object descriptors for multi-view shape reconstruction. In 2020 International Conference on 3D Vision (3DV), pages 949–958. IEEE, 2020.   
+[46] C. Tang and P. Tan. Ba-net: Dense bundle adjustment network. arXiv preprint arXiv:1806.04807, 2018.   
+[47] Z. Teed and J. Deng. Deepv2d: Video to depth with differentiable structure from motion. arXiv preprint arXiv:1812.04605, 2018.   
+[48] Z. Teed and J. Deng. Raft: Recurrent all-pairs field transforms for optical flow. In European Conference on Computer Vision, pages 402–419. Springer, 2020.   
+[49] Z. Teed and J. Deng. Tangent space backpropagation for 3d transformation groups. In Conference on Computer Vision and Pattern Recognition, 2021.   
+[50] B. Ummenhofer, H. Zhou, J. Uhrig, N. Mayer, E. Ilg, A. Dosovitskiy, and T. Brox. Demon: Depth and motion network for learning monocular stereo. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5038–5047, 2017.   
+[51] L. von Stumberg, P. Wenzel, N. Yang, and D. Cremers. Lm-reloc: Levenberg-marquardt based direct visual relocalization. arXiv preprint arXiv:2010.06323, 2020.   
+[52] S. Wang, R. Clark, H. Wen, and N. Trigoni. Deepvo: Towards end-to-end visual odometry with deep recurrent convolutional neural networks. In 2017 IEEE International Conference on Robotics and Automation (ICRA), pages 2043–2050. IEEE, 2017.   
+[53] W. Wang, Y. Hu, and S. Scherer. Tartanvo: A generalizable learning-based vo. arXiv preprint arXiv:2011.00359, 2020.   
+[54] W. Wang, D. Zhu, X. Wang, Y. Hu, Y. Qiu, C. Wang, Y. Hu, A. Kapoor, and S. Scherer. Tartanair: A dataset to push the limits of visual slam. arXiv preprint arXiv:2003.14338, 2020.   
+[55] T. Whelan, M. Kaess, H. Johannsson, M. Fallon, J. J. Leonard, and J. McDonald. Real-time large-scale dense rgb-d slam with volumetric fusion. The International Journal of Robotics Research, 34(4-5):598–626, 2015.   
+[56] T. Whelan, S. Leutenegger, R. Salas-Moreno, B. Glocker, and A. Davison. Elasticfusion: Dense slam without a pose graph. Robotics: Science and Systems, 2015.   
+[57] N. Yang, L. v. Stumberg, R. Wang, and D. Cremers. D3vo: Deep depth, deep pose and deep uncertainty for monocular visual odometry. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 1281–1292, 2020.   
+[58] N. Yang, R. Wang, J. Stuckler, and D. Cremers. Deep virtual stereo odometry: Leveraging deep depth prediction for monocular direct sparse odometry. In Proceedings of the European Conference on Computer Vision (ECCV), pages 817–833, 2018.   
+[59] H. Zhou, B. Ummenhofer, and T. Brox. Deeptam: Deep tracking and mapping. In Proceedings of the European conference on computer vision (ECCV), pages 822–838, 2018.   
+[60] J. Zubizarreta, I. Aguinaga, and J. M. M. Montiel. Direct sparse mapping. IEEE Transactions on Robotics, 36(4):1363–1370, 2020.

parse/train/ZBfUo_dr4H/ZBfUo_dr4H_content_list.json

@@ -0,0 +1,1233 @@
+[
+    {
+        "type": "text",
+        "text": "DROID-SLAM: Deep Visual SLAM for Monocular, Stereo, and RGB-D Cameras ",
+        "text_level": 1,
+        "bbox": [
+            187,
+            122,
+            812,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zachary Teed Jia Deng Princeton University {zteed,jiadeng}@princeton.edu ",
+        "bbox": [
+            387,
+            224,
+            612,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            303,
+            535,
+            319
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We introduce DROID-SLAM, a new deep learning based SLAM system. DROIDSLAM consists of recurrent iterative updates of camera pose and pixelwise depth through a Dense Bundle Adjustment layer. DROID-SLAM is accurate, achieving large improvements over prior work, and robust, suffering from substantially fewer catastrophic failures. Despite training on monocular video, it can leverage stereo or RGB-D video to achieve improved performance at test time. The URL to our open source code is https://github.com/princeton-vl/DROID-SLAM. ",
+        "bbox": [
+            232,
+            333,
+            766,
+            430
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            454,
+            310,
+            472
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Simultaneous Localization and Mapping (SLAM) aims to (1) build a map of the environment and (2) localize the agent within the environment. It is a special form of Structure-from-Motion (SfM) focused on accurate tracking of long-term trajectories. It is a critical capability for robotics, especially autonomous vehicles. In this work, we address visual SLAM, where sensor recordings come in the form of images captured from a monocular, stereo, or RGB-D camera. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            554
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The SLAM problem has been approached from a number of different angles. Early work was built using probabilistic and filtering based approaches [12, 30], and alternating optimization of the map and camera poses [34, 16]. More recently, modern SLAM systems have leveraged least-squares optimization. A key element for accuracy has been full Bundle Adjustment (BA), which jointly optimizes the camera poses and the 3D map in a single optimization problem. One advantage of the optimization-based formulation is that a SLAM system can be easily modified to leverage different sensors. For example, ORB-SLAM3 [5] supports monocular, stereo, RGB-D, and IMU sensors, and modern systems can support a variety of camera models [5, 27, 42, 6]. Despite significant progress, current SLAM systems lack the robustness demanded for many real-world applications. Failures come in many forms, such as lost feature tracks, divergence in the optimization algorithm, and accumulation of drift. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            713
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning has been proposed as a solution to many of these failure cases. Previous work has investigated replacing hand-crafted with learned features[13, 7, 29, 26, 35], using neural 3D representations[46, 1, 9, 45, 44, 25, 22], and combining learned energy terms with classical optimization backends[58, 57]. Other work has tried to learn SLAM or VO systems end-to-end [59, 47, 53, 52, 46]. While these systems are sometimes more robust, they fall far short of the accuracy of their classical counterparts on common benchmarks. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            803
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work we introduce DROID-SLAM, a new SLAM system based on deep learning. It has state-of-the-art performance, outperforming existing SLAM systems, classical or learning-based, on challenging benchmarks with very large margins. In particular, it has the following advantages: ",
+        "bbox": [
+            176,
+            808,
+            825,
+            851
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• High Accuracy: We achieve large improvements over prior work across multiple datasets and modalities. On the TartanAir SLAM competition [54], we reduce error by $62 \\%$ over the best prior result on the monocular track and $60 \\%$ on the stereo track. We rank 1st on the ",
+        "bbox": [
+            217,
+            861,
+            823,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/1d529559adf3b5ab64f169b618c0c5f063e97ffd80568a42cc8609f1348f8b79.jpg",
+        "image_caption": [
+            "Figure 1: DROID-SLAM can operate on monocular, stereo, and RGB-D video. It builds a dense 3D map of the environment while simultaneously localizing the camera within the map. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            88,
+            823,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "ETH-3D RGB-D SLAM leaderboard [41], outperforming the second place by $3 5 \\%$ under the AUC metric which considers both error and rate of catastrophic failure. On EuRoC [2], with monocular input, we reduce error by $82 \\%$ among methods with zero failures, and by $43 \\%$ over ORB-SLAM3 considering only the 10 out of 11 sequences it succeeds on. With stereo input, we reduce error by $71 \\%$ over ORB-SLAM3. On TUM-RGBD [43], we reduce error by $83 \\%$ among the methods with zero failures. ",
+        "bbox": [
+            230,
+            261,
+            825,
+            343
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• High Robustness: We have substantially fewer catastrophic failures than prior systems. On ETH-3D, we successfully track 30 of the 32 RGB-D datasets, while the next best successfully tracks only 19/32. On TartanAir, EuRoC, and TUM-RGBD, we have zero failures. ",
+        "bbox": [
+            217,
+            352,
+            825,
+            393
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Strong Generalization: Our system, trained only with monocular input, can directly use stereo or RGB-D input to get improved accuracy without any retraining. All of our results across 4 datasets and 3 modalities are achieved by a single model, trained once with only monocular input entirely on the synthetic TartanAir dataset. ",
+        "bbox": [
+            218,
+            401,
+            825,
+            455
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The strong performance and generalization of DROID-SLAM is made possible by its “Differentiable Recurrent Optimization-Inspired Design” (DROID), which is an end-to-end differentiable architecture that combines the strengths of both classical approaches and deep networks. Specifically, it consists of recurrent iterative updates, building upon RAFT [48] for optical flow but introducing two key innovations. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            537
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "First, unlike RAFT, which iteratively updates optical flow, we iteratively update camera poses and depth. Whereas RAFT operates on two frames, our updates are applied to an arbitrary number of frames, enabling joint global refinement of all camera poses and depth maps, essential for minimizing drift for long trajectories and loop closures. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            599
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Second, each update of camera poses and depth maps in DROID-SLAM is produced by a differentiable Dense Bundle Adjustment (DBA) layer, which computes a Gauss-Newton update to camera poses and dense per-pixel depth so as to maximize their compatibility with the current estimate of optical flow. This DBA layer leverages geometric constraints, improves accuracy and robustness, and enables a monocular system to handle stereo or RGB-D input without retraining. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            675
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The design of DROID-SLAM is novel. The closest prior deep architectures are DeepV2D [47] and BA-Net [46], both of which were focused on depth estimation and reported limited SLAM results. DeepV2D alternates between updating depth and updating camera poses, instead of bundle adjustment. BA-Net has a bundle adjustment layer, but their layer is substantially different: it is not “dense” in that it optimizes over a small number of coefficients used to linearly combine a depth basis (a set of pre-predicted depth maps), whereas we optimize over per-pixel depth directly, without being handicapped by a depth basis. In addition, BA-Net optimizes photometric reprojection error (in feature space), whereas we optimize geometric error, leveraging state-of-the-art flow estimation. ",
+        "bbox": [
+            173,
+            683,
+            825,
+            792
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We perform extensive evaluation across four different datasets and three different sensor modalities, demonstrating state-of-the-art performance in all cases. We also include ablation studies that shed light on important design decisions and hyperparameters. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            842
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            863,
+            321,
+            881
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Modern SLAM systems treat localization and mapping as a joint optimization problem [4]. ",
+        "bbox": [
+            169,
+            897,
+            767,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Visual SLAM focuses on observations in the form of monocular, stereo, or RGB-D images. These approaches are commonly categorized as either being direct or indirect [15]. Indirect approaches [31, 32, 5, 37] first process the image into an intermediate representation by detecting points of interest and attaching feature descriptors. Features are then matched between images. Indirect approaches optimize camera pose and a 3D point cloud by minimizing reprojection error–the distance between a projected 3D point and its location in the image. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Direct approaches model the image formation process and define an objective function over photometric error [16, 15, 60]. One advantage of direct approaches is that they can model more information about the image, such as lines and intensity variations[15] which are not used by indirect approaches. However, photometric errors typically lead to more difficult optimization problems, and direct approaches are less robust to geometric distortion such as rolling shutter artifacts. This approach requires more sophisticated optimization techniques, such as coarse-to-fine image pyramids to avoid local minimum. ",
+        "bbox": [
+            174,
+            181,
+            825,
+            277
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our method does not clearly fit into either of the categories. Like the direct approach, we do not require preprocessing steps to detect and match features between the images. We instead use the full image, allowing us to leverage a wider range of information than indirect methods with typically only use corners and edges. However, we minimize reprojection error similar to indirect methods. This is an easier optimization problem and avoids the need for more complicated representations such as image pyramids. In this sense, our approach borrows the best of both approaches: the smoother objective function of indirect approaches with the greater modeling capacity of indirect approaches. ",
+        "bbox": [
+            174,
+            284,
+            825,
+            382
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Deep Learning has more recently been applied to the SLAM problem. Many works have focused on training systems for particular subproblems, such as feature detection [13, 7, 29, 26, 35], feature matching and outlier rejection [38, 36], and localization [51, 39]. SuperGlue [38] was designed to perform feature matching and verification and make 2-view pose estimate much more robust. Our network also draws inspiration from Dusmanu et al[14], which builds a neural network into the SfM pipeline to improve keypoint localization accuracy. ",
+        "bbox": [
+            174,
+            387,
+            825,
+            470
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Other works have focused on training SLAM systems end-to-end [59, 46, 8, 50, 24, 47, 53]. These methods are not full SLAM systems, but instead focus on small scale reconstruction on the order of two [8, 50, 53] up to a dozen frames [59, 46, 47]. They lack many of the core capabilities of modern SLAM systems such as loop closure and global bundle adjustment which inhibit their ability to perform large scale reconstruction as demonstrated in our experiments. ∇SLAM[23] implements several existing SLAM algorithms as differentiable computation graphs, allowing for errors in the reconstruction to be backpropagated back to sensor measurements. While this approach is differentiable, it has no trainable parameters, meaning the performance of the system is limited by the accuracy of the classical algorithm they emulate. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            602
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "DeepFactors[9] is the most complete deep SLAM system, building on the earlier CodeSLAM[1]. It performs joint optimization of the pose and depth variables, and is capable of short and long-range loop closure. Similar to BA-Net[46], DeepFactors optimizes the parameters of a learned depth basis during inference. In contrast, we do not rely on a learned basis, but instead optimize pixelwise depth. This allows our network to better generalize to new datasets since our depth representation is not tied to the training dataset. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            691
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Approach ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            709,
+            287,
+            727
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We take a video as input with two objectives: estimate the trajectory of the camera and build a 3D map of the environment. We first describe the monocular setting; in Sec. 3.4 we describe how to generalize the system to stereo and RGB-D video. ",
+        "bbox": [
+            176,
+            741,
+            823,
+            782
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Representation: Our network operates on an ordered collection of images, $\\{ \\mathbf { I } _ { t } \\} _ { t = 0 } ^ { N }$ . For each image $t$ , we maintain two state variables: camera pose $\\mathbf { G } _ { t } \\in S E ( 3 )$ and inverse depth $\\check { \\mathbf { d } } _ { t } \\in \\mathbb { R } _ { + } ^ { H \\times W }$ . The set of poses, $\\{ \\mathbf { G } _ { t } \\} _ { t = 0 } ^ { N }$ , and set of inverse depths $\\{ \\mathbf { d } _ { t } \\} _ { t = 0 } ^ { N }$ are unknown state variables, which get iteratively updated during inference as new frames are processed. For the reminder of the paper, when we refer to depths, note that we are using the inverse depth parameterization. ",
+        "bbox": [
+            174,
+            789,
+            825,
+            863
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We adopt a frame-graph $( \\nu , \\mathcal { E } )$ to represent co-visibility between frames. An edge $( i , j ) \\in \\mathcal { E }$ means image $\\mathbf { I } _ { i }$ and $\\mathbf { I } _ { j }$ have overlapping fields of view which shared points. The frame graph is built dynamically during training and inference. After each pose or depth update, we can recompute visibility to update the frame graph. If the camera returns to a previously mapped region, we add long range connections in the graph to perform loop closure. ",
+        "bbox": [
+            174,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/304389c6e297fe3835b1aedd0e7a558a3c31abe26192a228e5a023886a7925d9.jpg",
+        "image_caption": [
+            "Figure 2: Illustration of the update operator. The operator acts on edges in the frame graph, predicting flow revisions which are mapped to depth and pose update through the (DBA) layer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            295,
+            87,
+            732,
+            246
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            313,
+            823,
+            342
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Feature Extraction and Correlation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            353,
+            460,
+            368
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Features are extracted from each new image added to they system. Key components of this stage are borrowed from RAFT[48]. ",
+        "bbox": [
+            173,
+            375,
+            823,
+            404
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Feature Extraction Each of the input images are processed by a feature extraction network. The network consists of 6 residual blocks and 3 downsampling layers, producing dense feature maps at 1/8 the input image resolution. Like RAFT[48], we use two separate networks: a feature network and a context network. The feature network is used to build the set of correlation volumes, while the context features are injected into the network during each application of the update operator. ",
+        "bbox": [
+            173,
+            410,
+            825,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Correlation Pyramid For each edge in the frame graph, $( i , j ) \\in \\mathcal { E }$ , we compute a 4D correlation volume by taking the dot product between all-pairs of feature vectors in $g _ { \\boldsymbol { \\theta } } ( I _ { i } )$ and $g _ { \\boldsymbol { \\theta } } ( I _ { j } )$ ",
+        "bbox": [
+            173,
+            486,
+            823,
+            515
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2c4c615334ee0efc31e343d067a3fe735589bc3f98fca5309efa8ee07e2eb42a.jpg",
+        "text": "$$\nC _ { u _ { 1 } v _ { 1 } u _ { 2 } v _ { 2 } } ^ { i j } = \\langle g _ { \\theta } ( I _ { i } ) _ { u _ { 1 } v _ { 1 } } , g _ { \\theta } ( I _ { j } ) _ { u _ { 2 } v _ { 2 } } \\rangle\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            521,
+            624,
+            542
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We then perform average pooling of the last two dimension of the correlation volume following RAFT[48] to form a 4-level correlation pyramid. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            575
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Correlation Lookup We define a lookup operator which indexes the correlation volume using a grid with radius $r$ , $\\mathbf { , } \\ L _ { r } : \\mathbb { R } ^ { H \\times W \\times H \\times W } \\times \\mathbb { R } ^ { H \\times W \\times 2 } \\mapsto \\mathbb { R } ^ { H \\times W \\times ( r + 1 ) ^ { 2 } }$ . ",
+        "bbox": [
+            174,
+            582,
+            823,
+            612
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The lookup operator takes an $H \\times W$ grid of coordinates as input and values are retrieved from the correlation volume using bilinear interpolation. The operator is applied to each correlation volume in the pyramid and the final feature vector is computed by concatenating the results at each level. ",
+        "bbox": [
+            173,
+            617,
+            826,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Update Operator ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            676,
+            333,
+            693
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The core component of our SLAM system is a learned update operator show in Fig. 2. The update operator is a $3 \\times 3$ convolutional GRU with hidden state $\\mathbf { h }$ . Each application of the operator updates the hidden state, and additionally produces a pose update, $\\Delta \\xi ^ { ( k ) }$ , and depth update, $\\Delta \\mathbf { d } ^ { ( k ) }$ . The pose and depth updates are applied to the current depth and pose estimates through retraction on the SE3 manifold and vector addition respectively ",
+        "bbox": [
+            173,
+            702,
+            825,
+            775
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/14000a7d46092f8bff030bc2cce82190d5fa8ca6735e70be82edb9e78184adae.jpg",
+        "text": "$$\n\\mathbf { G } ^ { ( k + 1 ) } = \\mathrm { E x p } ( \\Delta \\pmb { \\xi } ^ { ( k ) } ) \\circ \\mathbf { G } ^ { ( k ) } , \\qquad \\mathbf { d } ^ { ( k + 1 ) } = \\Delta \\mathbf { d } ^ { ( k ) } + \\mathbf { d } ^ { ( k ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            781,
+            702,
+            801
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Iterative applications of the update operator produce a sequence of poses and depths, with the expectation of converging to a fixed point $\\{ \\mathbf { G } ^ { ( k ) } \\} \\to \\mathbf { G } ^ { * }$ , $\\{ \\mathbf { d } ^ { ( k ) } \\}  \\mathbf { d } ^ { * }$ , reflecting the true reconstruction. ",
+        "bbox": [
+            173,
+            808,
+            825,
+            839
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Correspondence At the start of each iteration we use the current estimates of poses and depths to estimate correspondence. Given a grid of pixel coordinates, $\\mathbf { p } _ { i } \\in \\mathbb { R } ^ { H \\times W \\times 2 }$ in frame $i$ , we compute the dense correspondence field $\\mathbf { p } _ { i j }$ ",
+        "bbox": [
+            174,
+            843,
+            825,
+            887
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/472d3683bbc2b4816c7ebbb4172f86b9d9affdd4afba48fc772280af1a9ffba0.jpg",
+        "text": "$$\n\\mathbf { p } _ { i j } = \\Pi _ { c } \\big ( \\mathbf { G } _ { i j } \\circ \\Pi _ { c } ^ { - 1 } \\big ( \\mathbf { p } _ { i } , \\mathbf { d } _ { i } \\big ) \\big ) , \\qquad \\mathbf { p } _ { i j } \\in \\mathbb { R } ^ { H \\times W \\times 2 } \\qquad \\mathbf { G } _ { i j } = \\mathbf { G } _ { j } \\circ \\mathbf { G } _ { i } ^ { - 1 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            893,
+            751,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "for each edge $( i , j ) \\in \\mathcal { E }$ in the frame graph. Here $\\Pi _ { c }$ is the camera model mapping a set of 3D points onto the image and $\\Pi _ { c } ^ { - 1 }$ is the inverse projection function mapping inverse depth map d and coordinate grid $\\mathbf { p } _ { i }$ to a 3D point cloud (we provide formulas and Jacobians in the appendix). $\\mathbf { p } _ { i j }$ represents the coordinates of pixels $\\mathbf { p } _ { i }$ mapped into frame $j$ using the estimated pose and depth. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Inputs We use the correspondence field to index the correlation volumes. For each edge $( i , j ) \\in \\mathcal { E }$ we use $\\mathbf { p } _ { i j }$ to perform lookup from the correlation volume $\\mathbf { C } _ { i j }$ to retrieve correlation features. Additionally, we use the correspondence field to derive optical flow induced by camera motion as the difference $\\mathbf { p } _ { i j } - \\mathbf { p } _ { j }$ . Furthermore, the residual from the previous BA solution is concatenated with the flow field allowing the network to use feedback from the previous iteration. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            223
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The correlation features provide information about visual similarity in the neighbourhood of $\\mathbf { p } _ { i j }$ allowing the network to learn to align visually similar image regions. However, correspondence is sometimes ambiguous. The flow provides an complementary source of information allowing the network to exploit smoothness in the motion fields to gain robustness. ",
+        "bbox": [
+            174,
+            228,
+            823,
+            285
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Update The correlation features and flow features are each mapped through two convolutional layers before being injected into the GRU. Additionally, we inject context features, as extracted by the context network, into the GRU through element-wise addition. ",
+        "bbox": [
+            174,
+            290,
+            823,
+            333
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The ConvGRU is a local operation with a small receptive field. We extract global context by averaging the hidden state across the spatial dimensions of the image and use this feature vector as additional input to the GRU. Global context is important in SLAM because incorrect correspondences, caused by large moving objects for example, can degrade the accuracy of the system. It is important for the network to recognize and reject erroneous correspondence. ",
+        "bbox": [
+            173,
+            338,
+            825,
+            410
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The GRU produces an updated hidden state $\\mathbf { h } ^ { ( k + 1 ) }$ . Instead of predicting updates to the depth or pose directly, we instead predict updates in the space of dense flow fields. We map the hidden state through two additional convoluation layers to produce two outputs: (1) a revision flow field $\\mathbf { r } _ { i j } \\in \\mathbb { R } ^ { H \\times W \\times 2 }$ and (2) associated confidence map $\\mathbf { w } _ { i j } \\in \\mathbb { R } _ { + } ^ { H \\times W \\times 2 }$ . The revision $\\mathbf { r } _ { i j }$ is a correction term predicted by the network to correct errors in the dense correspondence field. We denote the corrected correspondence as $\\mathbf { p } _ { i j } ^ { * } = \\mathbf { r } _ { i j } + \\mathbf { p } _ { i j }$ ",
+        "bbox": [
+            173,
+            415,
+            825,
+            503
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We then pool the hidden state over all features which share the same source view $i$ and predict a pixel-wise damping factor $\\lambda$ . We use the softplus operator to ensure that the damping term is positive. Additionally, we use the pooled features to predict a $8 \\mathrm { x } 8$ mask which can be used to upsample the inverse depth estimate. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            563
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Dense Bundle Adjustment Layer (DBA) The Dense Bundle Adjustment Layer (DBA) maps the set of flow revisions into a set of pose and pixelwise depth updates. We define the cost function over the entire frame graph ",
+        "bbox": [
+            174,
+            569,
+            825,
+            612
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/52708fb800e9cf761b0e2ecb07689bc1cdc00682c91d4465da5afdfda5ea9a73.jpg",
+        "text": "$$\n\\mathbf { E } ( \\mathbf { G } ^ { \\prime } , \\mathbf { d } ^ { \\prime } ) = \\sum _ { ( i , j ) \\in \\mathcal { E } } \\big \\| \\mathbf { p } _ { i j } ^ { * } - \\Pi _ { c } \\big ( \\mathbf { G } _ { i j } ^ { \\prime } \\circ \\Pi _ { c } ^ { - 1 } \\big ( \\mathbf { p } _ { i } , \\mathbf { d } _ { i } ^ { \\prime } \\big ) \\big ) \\big \\| _ { \\Sigma _ { i j } } ^ { 2 } \\qquad \\Sigma _ { i j } = \\mathrm { d i a g } \\mathbf { w } _ { i j } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            240,
+            617,
+            756,
+            656
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\lVert \\cdot \\rVert _ { \\Sigma }$ is the Mahalanobis distance which weights the error terms based on the confidence weights $\\mathbf { w } _ { i j }$ . Eqn. 4 states that we want an updated pose $\\mathbf { G } ^ { \\prime }$ and depth $\\mathbf { d } ^ { \\prime }$ such that reprojected points match the revised correspondence $\\mathbf { p } _ { i j } ^ { * }$ as predicted by the update operator. ",
+        "bbox": [
+            173,
+            662,
+            825,
+            705
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use local parameterization to linearize Eqn. 4 and use the Gauss-Newton algorithm solve for updates $( \\Delta \\xi , \\Delta \\mathbf { d } )$ . Since each term in Eqn. 4 only includes a single depth variable, the Hessian matrix has block diagonal structure. Separating pose and depth variables, the system can be solved efficiently using the Schur complement with the pixelwise damping factor $\\lambda$ added to the depth block ",
+        "bbox": [
+            174,
+            710,
+            825,
+            767
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3df14bb8b9411e7d558e199464e00020318e281ad8cd725ea81aadc90d814247.jpg",
+        "text": "$$\n\\begin{array} { r }  \\left[ \\begin{array} { l l } { \\mathbf { B } } & { \\mathbf { E } } \\\\ { \\mathbf { E } ^ { T } } & { \\mathbf { C } } \\end{array} \\right] \\left[ \\boldsymbol { \\Delta } \\pmb { \\xi } \\right] = \\left[ \\mathbf { v } \\right] \\qquad \\begin{array} { r l } & { \\boldsymbol { \\Delta } \\pmb { \\xi } = [ \\mathbf { B } - \\mathbf { E } \\mathbf { C } ^ { - 1 } \\mathbf { E } ^ { T } ] ^ { - 1 } ( \\mathbf { v } - \\mathbf { E } \\mathbf { C } ^ { - 1 } \\mathbf { w } ) } \\\\ & { \\boldsymbol { \\Delta } \\mathbf { d } = \\mathbf { C } ^ { - 1 } ( \\mathbf { w } - \\mathbf { E } ^ { T } \\boldsymbol { \\Delta } \\pmb { \\xi } ) } \\end{array} \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            772,
+            745,
+            809
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { C }$ is diagonal and can be cheaply inverted ${ \\bf C } ^ { - 1 } = 1 / { \\bf C }$ . The DBA layer is implemented as part of the computation graph and backpropogation is performed through the layer during training. ",
+        "bbox": [
+            173,
+            815,
+            825,
+            845
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Training ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            861,
+            274,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our SLAM system is implemented in PyTorch and we use the LieTorch extension [49] to perform backprogation in the tangent space of all group elements. ",
+        "bbox": [
+            173,
+            882,
+            821,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Removing gauge freedom In the monocular setting, the network is only able to recover the trajectory of the camera up to a similarity transform. One solution is to define a loss which is invariant to similarity transforms. However, the gauge-freedom still exists during training which poorly impacts the conditioning of the linear system and the stability of the gradients. We solve this problem by fixing the first two poses to the ground-truth poses of each training sequence. Fixing the first pose removes the 6-dof gauge freedom. Fixing the second pose resolves the scale freedom. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Constructing training video Each training example consists of a 7-frame video sequence. In order to ensure stable training and good downstream performance, we want to sample videos which are not too easy nor too difficult. ",
+        "bbox": [
+            176,
+            181,
+            821,
+            222
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The training set is composed of a collection of videos. For each video $i$ of length $N _ { i }$ , we precompute an $N _ { i } \\times N _ { i }$ distance matrix storing the average optical flow magnitude between each pair of frames. However, not all frames are covisible; and frames pairs with less than $50 \\%$ overlap are assigned a distance of infinity. During training, we dynamically generate videos by sampling paths in the distance matrix, such that the average flow between adjacent video frames is between 8px and 96px. ",
+        "bbox": [
+            174,
+            228,
+            825,
+            299
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Supervision We supervise our network using a combination of pose loss and flow loss. The flow loss is applied to pairs of adjacent frames. We compute the optical flow induced by the predicted depth and poses and the flow induced by the ground truth depth and poses. The loss is taken to be the average l2 distance between the two flow fields. ",
+        "bbox": [
+            174,
+            304,
+            825,
+            359
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Given a set of ground truth poses $\\{ \\mathbf { T } \\} _ { i } ^ { N }$ and predicted poses $\\{ \\mathbf { G } \\} _ { i } ^ { N }$ , the pose loss is taken to be the distance between the ground truth and predicted poses, $\\begin{array} { r } { \\mathcal { L } _ { p o s e } = \\sum _ { i } | | \\operatorname { L o g } _ { S E 3 } ( \\mathbf { T } _ { i } ^ { - 1 } \\cdot \\mathbf { G } _ { i } ) | | _ { 2 } } \\end{array}$ . We apply the losses to the output of every iteration with exponentially increasing weight using $\\gamma = 0 . 9$ . ",
+        "bbox": [
+            174,
+            366,
+            825,
+            411
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4 SLAM System ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            435,
+            313,
+            450
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "During inference, we compose the network into a full SLAM system. The SLAM system takes a video stream as input, and performs reconstruction and localization in real-time. Our system contains two threads which run asynchronously. The frontend thread takes in new frames, extracts features, selects keyframes, and performs local bundle adjustment. The backend thread simultaneously performs global bundle adjustment over the entire history of keyframes. We provide an overview of the system here, and provide more information in the appendix. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            546
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Initialization Initialization is simple with DROID-SLAM. We simply collect frames until we have a set of 12. As we accumulate frames, we only keep the previous frame if optical flow is greater than 16px (estimated by applying one update iteration). Once 12 frames have been accumulated, we initialize a frame graph by creating an edges between keyframes which are within 3 timesteps apart, then run 10 iterations of the update operator. ",
+        "bbox": [
+            173,
+            551,
+            825,
+            622
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Frontend The frontend operates directly on the incoming video stream. It maintains a collection of keyframes and a frame graph storing edges between covisible kefyrames. Keyframe poses and depths are actively being optimized. Features are first extracted from the incoming frames. The new frame is then added to the frame graph adding edges with its 3 closest neighbors as measured by mean optical flow. The pose is initialized using a linear motion model. We then apply several iterations of the update operator to update keyframe poses and depths. We fix the first two poses to remove gauge freedom but treat all depths as free variables. ",
+        "bbox": [
+            174,
+            627,
+            825,
+            726
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "After the new frame is tracked, we select a keyframe for removal. We compute distance between pairs of frames by computing the average optical flow magnitude and remove redundant frames. If no frame is a good candidate for removal, we remove the oldest keyframe. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            773
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Backend The backend performs global bundle adjustment over the entire history of keyframes. During each iteration, we rebuild the frame graph using the flow between all pairs of keyframes, represented as an $N \\times N$ distance matrix. We first add edges between temporally adjacent keyframes. We then sample new edges from the distance matrix in order of increasing flow. With each selected edge, we suppress neighboring edges within a distance of 2, where distance is defined as the Chebyshev distance between index pairs $| | ( i , j ) - ( k , l ) | | _ { \\infty } = \\operatorname* { m a x } ( | i - k | , | j - l | )$ . ",
+        "bbox": [
+            174,
+            779,
+            825,
+            864
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We then apply the update operator to the entire frame graph, often consisting of thousands of frames and edges. Storing the full set of correlation volumes would quickly exceed video memory. Instead, we use the memory efficient implementation proposed in RAFT [48]. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/9272db540c28a43e8ab054074f443b10bc601aba4494a3370e157a7c168fc922.jpg",
+        "image_caption": [
+            "Figure 3: DROID-SLAM can generalize to new datasets. In order, we show results from Tanks & Temples [21], ScanNet [10], Sintel [3], and ETH-3D [41]; all using monocular video. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            97,
+            807,
+            309
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "During training, we implement dense bundle adjustment in PyTorch to leverage the automatic differentiation engine. At inference time, we use a custom CUDA kernel which takes advantage of the block-sparse structure of the problem, then perform sparse Cholesky decomposition on the reduced camera block. ",
+        "bbox": [
+            174,
+            387,
+            825,
+            443
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We only perform full bundle adjustment on keyframe images. In order to recover the poses of non-keyframes, we perform motion-only bundle adjustment by iteratively estimating flow between each keyframe and its neighboring non-keyframes. During testing, we evaluate on the full camera trajectory, not just keyframes. ",
+        "bbox": [
+            173,
+            449,
+            825,
+            506
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Stereo and RGB-D Our system can be easily modified for stereo and RGB-D video. In the case of RGB-D, we still treat depth as a variable, since sensor depth can be noisy and have missing observations, and simply add a term to the optimization objective (Eqn. 4) which penalizes the squared distance between the measured and predicted depth. For stereo, we use the exact same system described above, with just double the frames, and fix the relative pose between the left and right frames in the DBA layer. Cross camera edges in the graph allow us to leverage stereo information. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            595
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            619,
+            312,
+            637
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We experiment on a diverse set of datasets and sensor modalities. We compare to both deep learning and established classical SLAM algorithms and put specific emphasis on cross-dataset generalization. Following prior work, we evaluate the accuracy of the camera trajectory [31, 15, 41], primarily using Absolute Trajectory Error (ATE) [43]. While some datasets have ground truth point clouds [21], there is no standard protocol to compare 3D reconstructions directly given by SLAM systems because a SLAM systems can choose which 3D points to reconstruct. Evaluating dense 3D reconstruction is typically considered in the domain of Multiview Stereo [19] and outside the scope of this work. ",
+        "bbox": [
+            173,
+            655,
+            825,
+            752
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our network is trained entirely on monocular video from the synthetic TartanAir dataset [54]. We train our network for 250k steps with a batch size of 4, resolution $3 8 4 \\times 5 1 2$ , and 7 frame clips, and unroll 15 update iterations. Training takes 1 week on 4 RTX-3090 GPUs. ",
+        "bbox": [
+            176,
+            758,
+            823,
+            801
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/450f39f80018c9c4f55e15e250efc8eddad8b3fb05c6d45f53d3b499c061c4c8.jpg",
+        "table_caption": [
+            "Table 1: Results on the TartanAir monocular benchmark. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Monocular</td><td>MH000</td><td>MH001</td><td>MH002</td><td>MH003</td><td>MH004</td><td>MH005</td><td>MH006</td><td>MH007</td><td>Avg</td></tr><tr><td>ORB-SLAM[31]</td><td>1.30</td><td>0.04</td><td>2.37</td><td>2.45</td><td>X</td><td>X</td><td>21.47</td><td>2.73</td><td>-</td></tr><tr><td>DeepV2D[47]</td><td>6.15</td><td>2.12</td><td>4.54</td><td>3.89</td><td>2.71</td><td>11.55</td><td>5.53</td><td>3.76</td><td>5.03</td></tr><tr><td>TartanVO [53]</td><td>4.88</td><td>0.26</td><td>2.00</td><td>0.94</td><td>1.07</td><td>3.19</td><td>1.00</td><td>2.04</td><td>1.92</td></tr><tr><td>Ours</td><td>0.08</td><td>0.05</td><td>0.04</td><td>0.02</td><td>0.01</td><td>1.31</td><td>0.30</td><td>0.07</td><td>0.24</td></tr></table>",
+        "bbox": [
+            238,
+            823,
+            753,
+            881
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "TartanAir [54] (Monocular & Stereo) The TartanAir dataset is a challenging synthetic benchmark for evaluating SLAM algorithms and was used as part of the ECCV 2020 SLAM competition. We use the official test split [54], and provide ATE across all “Hard” sequences in Tab. 1. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Tab. 1 demonstrates both the robustness of our method (no catastrophic failures) and accuracy (very low drift). We retrain DeepV2D [47] on TartanAir as a baseline. On most sequences, we outperform existing methods by an order-of-magnitude and achieve ${ } ^ { 8 \\mathrm { { X } } }$ lower average error than TartanVO [53] and $2 0 \\mathrm { x }$ lower than DeepV2D [47]. We also use the TartanAir dataset to compare with the top submissions to the ECCV 2020 SLAM competition in Tab. 2. The top two submissions use systems ",
+        "bbox": [
+            174,
+            140,
+            825,
+            209
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/ee6578f34f60b072bc389edc23210edd2aa143835d1110fe80c60802022651c4.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Mono.</td><td>Stereo</td></tr><tr><td>OV²SLAM[17]</td><td>0.510</td><td>0.182</td></tr><tr><td>VOLDOR [28] + COLMAP [40]</td><td>0.440</td><td>0.177</td></tr><tr><td>SuperGlue [38] + SuperPoint [13] + COLMAP [40]</td><td>0.340</td><td>0.119</td></tr><tr><td>Ours</td><td>0.129</td><td>0.047</td></tr></table>",
+        "bbox": [
+            334,
+            224,
+            660,
+            285
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Results on the TartanAir test set, compared with the top 3 submission to the ECCV 2020 SLAM competition. The score is computed using normalized relative pose error for all possible sequences of length $\\{ 5 , 1 0 , 1 5 , . . . , 4 0 \\}$ meters, see competition page for details. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            337
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "built on top of COLMAP [40] and run $4 0 \\mathbf { x }$ slower than real-time. Our method, on the other hand, runs 16x faster and achieves an error $62 \\%$ lower on the monocular benchmark and $60 \\%$ lower on the stereo benchmark. ",
+        "bbox": [
+            176,
+            356,
+            821,
+            397
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "EuRoC [2] (Monocular & Stereo) In the remaining experiments, we are interested in the ability of our network to generalize to new cameras and environments. The EuRoC dataset consists of video captured from sensor on-board a micro aerial vehicle (MAV) and is a widely used benchmark to evaluate SLAM systems. We use the EuRoC dataset to evaluate both monocular and stereo performance and report results on Tab. 3. ",
+        "bbox": [
+            174,
+            404,
+            825,
+            473
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/821b2e37bd70840d578bc00372d6e2c64ec767491a7f3ece64daa00e1e5ae5a3.jpg",
+        "table_caption": [
+            "Table 3: Monocular SLAM on the EuRoC datasets, ATE[m]. † denotes visual odometry methods. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\"></td><td>MH01</td><td>MH02</td><td>MH03</td><td>MH04</td><td>MH05</td><td>V101</td><td>V102</td><td>V103</td><td>V201</td><td>V202</td><td>V203</td><td>Avg</td></tr><tr><td rowspan=\"5\">qH/deea</td><td>DeepFactors [9]</td><td>1.587</td><td>1.479</td><td>3.139</td><td>5.331</td><td>4.002</td><td>1.520</td><td>0.679</td><td>0.900</td><td>0.876</td><td>1.905</td><td>1.021</td><td>2.040</td></tr><tr><td>DeepV2D [47]t</td><td>0.739</td><td>1.144</td><td>0.752</td><td>1.492</td><td>1.567</td><td>0.981</td><td>0.801</td><td>1.570</td><td>0.290</td><td>2.202</td><td>2.743</td><td>1.298</td></tr><tr><td>DeepV2D (Tartan Air)†</td><td>1.614</td><td>1.492</td><td>1.635</td><td>1.775</td><td>1.013</td><td>0.717</td><td>0.695</td><td>1.483</td><td>0.839</td><td>1.052</td><td>0.591</td><td>1.173</td></tr><tr><td>TartanVO1 [53]†</td><td>0.639</td><td>0.325</td><td>0.550</td><td>1.153</td><td>1.021</td><td>0.447</td><td>0.389</td><td>0.622</td><td>0.433</td><td>0.749</td><td>1.152</td><td>0.680</td></tr><tr><td>D3VO + DSO [57]t</td><td>-</td><td>-</td><td>0.08</td><td>-</td><td>0.09</td><td>-</td><td>-</td><td>0.11</td><td>-</td><td>0.05</td><td>0.19</td><td>-</td></tr><tr><td rowspan=\"4\">Cesssssr</td><td>ORB-SLAM [31]</td><td>0.071</td><td>0.067</td><td>0.071</td><td>0.082</td><td>0.060</td><td>0.015</td><td>0.020</td><td>X</td><td>0.021</td><td>0.018</td><td>X</td><td>-</td></tr><tr><td>DSO [15]t</td><td>0.046</td><td>0.046</td><td>0.172</td><td>3.810</td><td>0.110</td><td>0.089</td><td>0.107</td><td>0.903</td><td>0.044</td><td>0.132</td><td>1.152</td><td>0.601</td></tr><tr><td>SVO[18]t</td><td>0.100</td><td>0.120</td><td>0.410</td><td>0.430</td><td>0.300</td><td>0.070</td><td>0.210</td><td>X</td><td>0.110</td><td>0.110</td><td>1.080</td><td>·</td></tr><tr><td>DSM[60] ORB-SLAM3 [5]</td><td>0.039</td><td>0.036</td><td>0.055</td><td>0.057</td><td>0.067</td><td>0.095</td><td>0.059</td><td>0.076</td><td>0.056</td><td>0.057</td><td>0.784</td><td>0.126</td></tr><tr><td colspan=\"2\">Ours (odometry only)†</td><td>0.016</td><td>0.027</td><td>0.028</td><td>0.138</td><td>0.072</td><td>0.033</td><td>0.015</td><td>0.033</td><td>0.023</td><td>0.029</td><td>X</td><td>-</td></tr><tr><td colspan=\"2\">Ours</td><td>0.163 0.013</td><td>0.121 0.014</td><td>0.242 0.022</td><td>0.399 0.043</td><td>0.270 0.043</td><td>0.103 0.037</td><td>0.165 0.012</td><td>0.158</td><td>0.020</td><td>0.102 0.115 0.017 0.013</td><td>0.204 0.014</td><td>0.186 0.022</td></tr></table>",
+        "bbox": [
+            205,
+            487,
+            790,
+            623
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In the monocular setting, we achieve an average ATE of $2 . 2 \\mathrm { c m }$ , reducing error by $82 \\%$ among methods with zero failures, and by $43 \\%$ over ORB-SLAM3 when only comparing sequences where ORB-SLAM3 is successful. ",
+        "bbox": [
+            176,
+            669,
+            823,
+            710
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare to several deep learning approaches. We compare to DeepV2D trained on the TartanAir dataset and the publicly available version trained on NYUv2 [33] and ScanNet[10]. DeepFactors [9] was trained on ScanNet. We find that recent deep learning approaches [9, 47, 53] perform poorly on the EuRoC dataset compared to classical SLAM systems. This is due to poor generalization and dataset biases which lead to large amounts of drift; our method does not suffer from these issues. D3VO [57] is able to achieve both good robustness and accuracy by combining a neural network frontend with DSO as a backend, using 6 of the 11 sequences for evaluation and performing unsupervised training on the remaining ones, which contain the same scenes used for evaluation. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            829
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "TUM-RGBD [43] The RGBD dataset consists of indoor scenes captured with handheld camera. This is a notoriously difficult dataset for monocular methods due to rolling shutter artifacts, motion blur, and heavy rotation. We benchmark prior work on the entirety of the freiburg1 set in Tab. 4. ",
+        "bbox": [
+            174,
+            835,
+            825,
+            877
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Classical SLAM algorithms such as ORB-SLAM tend to fail on most of the sequences. While deep learning methods are more robust, they obtain low accuracy on most of the evaluated sequences. Our ",
+        "bbox": [
+            174,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/40fd359eb6e696b2a7bd8c74e1fc5a70af8c2bf44945768d8a3e5b27e9696eab.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>360</td><td>desk</td><td>desk2</td><td>floor</td><td>plant</td><td>room</td><td>rpy</td><td>teddy</td><td>xyz</td><td>avg</td></tr><tr><td>ORB-SLAM2 [32] ORB-SLAM3[5]</td><td>X X</td><td>0.071 0.017</td><td>X 0.210</td><td>0.023 X</td><td>X 0.034</td><td>X X</td><td>X X</td><td>X X</td><td>0.010 0.009</td><td>： -</td></tr><tr><td>DeepTAM1 [59]</td><td>0.111</td><td>0.053</td><td>0.103</td><td>0.206</td><td>0.064</td><td>0.239</td><td>0.093</td><td>0.144</td><td>0.036</td><td>0.116</td></tr><tr><td>TartanVO² [53]</td><td>0.178</td><td>0.125</td><td>0.122</td><td>0.349</td><td>0.297</td><td>0.333</td><td>0.049</td><td>0.339</td><td>0.062</td><td>0.206</td></tr><tr><td>DeepV2D [47]</td><td>0.243</td><td>0.166</td><td>0.379</td><td>1.653</td><td>0.203</td><td>0.246</td><td>0.105</td><td>0.316</td><td>0.064</td><td>0.375</td></tr><tr><td>DeepV2D (TartanAir)</td><td>0.182</td><td>0.652</td><td>0.633</td><td>0.579</td><td>0.582</td><td>0.776</td><td>0.053</td><td>0.602</td><td>0.150</td><td>0.468</td></tr><tr><td>DeepFactors [9]</td><td>0.159</td><td>0.170</td><td>0.253</td><td>0.169</td><td>0.305</td><td>0.364</td><td>0.043</td><td>0.601</td><td>0.035</td><td>0.233</td></tr><tr><td>Ours</td><td>0.111</td><td>0.018</td><td>0.042</td><td>0.021</td><td>0.016</td><td>0.049</td><td>0.026</td><td>0.048</td><td>0.012</td><td>0.038</td></tr></table>",
+        "bbox": [
+            276,
+            87,
+            718,
+            179
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 4: ATE on the TUM-RGBD benchmark. All methods are provided mono. video, 1except DeepTAM which uses RGB-D and 2TartanVO which uses ground truth to scale relative pose. ",
+        "bbox": [
+            173,
+            191,
+            823,
+            219
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "method is both robust and accurate. It successfully tracks all 9 sequences while achieving $83 \\%$ lower ATE than DeepFactors [9] and which succeeds on all videos and $90 \\%$ lower ATE than DeepV2D [47]. ",
+        "bbox": [
+            173,
+            246,
+            825,
+            275
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/be9d1f884bf4e0054f381943dd26e4c24baf1db7982edbe0eb27578756eb52ae.jpg",
+        "image_caption": [
+            "Figure 4: Generalization results on the RGB-D ETH3D-SLAM benchmark. (Left) Our method, which is trained only on the synthetic TartanAir dataset, ranks 1st on both the train and test splits. (Right) Plot of the number successful trajectories as a function of ATE. Our method successfully tracks 30/32 of the datasets where image data is available. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            292,
+            795,
+            407
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ETH3D-SLAM [41] (RGB-D) Finally, we evaluate the RGB-D performance on the ETH3D-SLAM benchmark. In this setup, the network is also provided measurements from an RGB-D camera. We take our network trained on TartanAir and add an addition term in the optimization objective penalizing the distance between the predicted inv. depth and inv. depth measured by the sensor. Without any finetuning, our method ranks 1st on both the train and test splits. Several of the datasets are \"dark\" meaning no image data is available; on these datasets we do not submit any predictions. On the test set, we successfully track 30/32 RGB-D, improving over the next best of 19/32. ",
+        "bbox": [
+            173,
+            481,
+            825,
+            578
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Timing and Memory Our system can run in real-time with 2 3090 GPUs. Tracking and local BA is run on the first GPU, while global BA and loop closure is run on the second. On EuRoC, we average 20fps (camera hz) by downsampling to $3 2 0 \\times 5 1 2$ resolution and skipping every other frame. Results in Tab. 3 were obtained in this setting. On TUM-RGBD, we average 30fps by downsampling to $2 4 0 \\times 3 2 0$ and skipping every other frame, again the reported results where obtained in this setting. On TartanAir, due to much faster camera motion, we are unable to run in real-time, averaging 8fps. However, this is still a 16x speedup over the top 2 submissions to the TartanAir SLAM challenge, which rely on COLMAP [40]. ",
+        "bbox": [
+            173,
+            584,
+            826,
+            695
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The SLAM frontend can be run on GPUs with 8GB of memory. The backend, which requires storing feature maps from the full set of images, is more memory intensive. All results on TUM-RGBD can be produced on a single 1080Ti graphics card. Results on EuRoC, TartanAir and ETH-3D (where video can be up to 5000 frames) requires a GPU with 24GB memory. While memory and resource requirements are currently the biggest limitation of our system, we believe these can be drastically reduced by culling redundant computation and more efficient representations. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            785
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            804,
+            299,
+            820
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We introduce DROID-SLAM, an end-to-end neural architecture for visual SLAM. DROID-SLAM is accurate, robust, and versatile and can be used on monocular, stereo, and RGB-D video. It outperforms prior work by large margins on challenging benchmarks. ",
+        "bbox": [
+            174,
+            835,
+            825,
+            877
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements This work is partially supported by the National Science Foundation under Award IIS-1942981. ",
+        "bbox": [
+            174,
+            882,
+            820,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            266,
+            106
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "optimisable representation for dense visual slam. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2560–2568, 2018.   \n[2] M. Burri, J. Nikolic, P. Gohl, T. Schneider, J. Rehder, S. Omari, M. W. Achtelik, and R. Siegwart. The euroc micro aerial vehicle datasets. The International Journal of Robotics Research, 35(10):1157–1163, 2016.   \n[3] D. J. Butler, J. Wulff, G. B. Stanley, and M. J. Black. A naturalistic open source movie for optical flow evaluation. In A. Fitzgibbon et al. (Eds.), editor, European Conf. on Computer Vision (ECCV), Part IV, LNCS 7577, pages 611–625. Springer-Verlag, Oct. 2012.   \n[4] C. Cadena, L. Carlone, H. Carrillo, Y. Latif, D. Scaramuzza, J. Neira, I. Reid, and J. J. Leonard. Past, present, and future of simultaneous localization and mapping: Toward the robust-perception age. IEEE Transactions on robotics, 32(6):1309–1332, 2016.   \n[5] C. Campos, R. Elvira, J. J. G. Rodríguez, J. M. Montiel, and J. D. Tardós. Orb-slam3: An accurate open-source library for visual, visual-inertial and multi-map slam. arXiv preprint arXiv:2007.11898, 2020.   \n[6] D. Caruso, J. Engel, and D. Cremers. Large-scale direct slam for omnidirectional cameras. In 2015 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 141–148. IEEE, 2015.   \n[7] C. B. Choy, J. Gwak, S. Savarese, and M. Chandraker. Universal correspondence network. arXiv preprint arXiv:1606.03558, 2016.   \n[8] R. Clark, M. Bloesch, J. Czarnowski, S. Leutenegger, and A. J. Davison. Ls-net: Learning to solve nonlinear least squares for monocular stereo. arXiv preprint arXiv:1809.02966, 2018. [9] J. Czarnowski, T. Laidlow, R. Clark, and A. J. Davison. Deepfactors: Real-time probabilistic dense monocular slam. IEEE Robotics and Automation Letters, 5(2):721–728, 2020.   \n[10] A. Dai, A. X. Chang, M. Savva, M. Halber, T. Funkhouser, and M. Nießner. Scannet: Richly-annotated 3d reconstructions of indoor scenes. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5828–5839, 2017.   \n[11] A. Dai, M. Nießner, M. Zollhöfer, S. Izadi, and C. Theobalt. Bundlefusion: Real-time globally consistent 3d reconstruction using on-the-fly surface reintegration. ACM Transactions on Graphics (ToG), 36(4):1, 2017.   \n[12] A. J. Davison, I. D. Reid, N. D. Molton, and O. Stasse. Monoslam: Real-time single camera slam. IEEE transactions on pattern analysis and machine intelligence, 29(6):1052–1067, 2007.   \n[13] D. DeTone, T. Malisiewicz, and A. Rabinovich. Superpoint: Self-supervised interest point detection and description. In Proceedings of the IEEE conference on computer vision and pattern recognition workshops, pages 224–236, 2018.   \n[14] M. Dusmanu, J. L. Schonberger, and M. Pollefeys. Multi-view optimization of local feature geometry. In Proceedings of the 2020 European Conference on Computer Vision, 2020.   \n[15] J. Engel, V. Koltun, and D. Cremers. Direct sparse odometry. IEEE transactions on pattern analysis and machine intelligence, 40(3):611–625, 2017.   \n[16] J. Engel, T. Schöps, and D. Cremers. Lsd-slam: Large-scale direct monocular slam. In European conference on computer vision, pages 834–849. Springer, 2014.   \n[17] M. Ferrera, A. Eudes, J. Moras, M. Sanfourche, and G. Le Besnerais. Ov2 slam: A fully online and versatile visual slam for real-time applications. IEEE Robotics and Automation Letters, 6(2):1399–1406, 2021.   \n[18] C. Forster, Z. Zhang, M. Gassner, M. Werlberger, and D. Scaramuzza. Svo: Semidirect visual odometry for monocular and multicamera systems. IEEE Transactions on Robotics, 33(2):249–265, 2016.   \n[19] Y. Furukawa and C. Hernández. Multi-view stereo: A tutorial. Foundations and Trends® in Computer Graphics and Vision, 9(1-2):1–148, 2015.   \n[20] C. Kerl, J. Sturm, and D. Cremers. Dense visual slam for rgb-d cameras. In 2013 IEEE/RSJ International Conference on Intelligent Robots and Systems, pages 2100–2106. IEEE, 2013.   \n[21] A. Knapitsch, J. Park, Q.-Y. Zhou, and V. Koltun. Tanks and temples: Benchmarking large-scale scene reconstruction. ACM Transactions on Graphics (ToG), 36(4):1–13, 2017.   \n[22] J. Kopf, X. Rong, and J.-B. Huang. Robust consistent video depth estimation. arXiv preprint arXiv:2012.05901, 2020.   \n[23] J. Krishna Murthy, S. Saryazdi, G. Iyer, and L. Paull. gradslam: Dense slam meets automatic differentiation. arXiv, 2020.   \n[24] C. Liu, J. Gu, K. Kim, S. G. Narasimhan, and J. Kautz. Neural rgb (r) d sensing: Depth and uncertainty from a video camera. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 10986–10995, 2019.   \n[25] X. Luo, J.-B. Huang, R. Szeliski, K. Matzen, and J. Kopf. Consistent video depth estimation. ACM Transactions on Graphics (TOG), 39(4):71–1, 2020.   \n[26] Zhu, R. Zhang, Yao, Quan. Learning local descriptors by integrating geometry constraints. In Proceedings of the European conference on computer vision (ECCV), pages 168–183, 2018.   \n[27] H. Matsuki, L. von Stumberg, V. Usenko, J. Stückler, and D. Cremers. Omnidirectional dso: Direct sparse odometry with fisheye cameras. IEEE Robotics and Automation Letters, 3(4):3693–3700, 2018.   \n[28] Z. Min, Y. Yang, and E. Dunn. Voldor: Visual odometry from log-logistic dense optical flow residuals. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4898–4909, 2020.   \n[29] A. Mishchuk, D. Mishkin, F. Radenovic, and J. Matas. Working hard to know your neighbor’s margins: Local descriptor learning loss. arXiv preprint arXiv:1705.10872, 2017.   \n[30] A. I. Mourikis and S. I. Roumeliotis. A multi-state constraint kalman filter for vision-aided inertial navigation. In Proceedings 2007 IEEE International Conference on Robotics and Automation, pages 3565–3572. IEEE, 2007.   \n[31] R. Mur-Artal, J. M. M. Montiel, and J. D. Tardos. Orb-slam: a versatile and accurate monocular slam system. IEEE transactions on robotics, 31(5):1147–1163, 2015.   \n[32] R. Mur-Artal and J. D. Tardós. Orb-slam2: An open-source slam system for monocular, stereo, and rgb-d cameras. IEEE Transactions on Robotics, 33(5):1255–1262, 2017.   \n[33] P. K. Nathan Silberman, Derek Hoiem and R. Fergus. Indoor segmentation and support inference from rgbd images. In ECCV, 2012.   \n[34] R. A. Newcombe, S. J. Lovegrove, and A. J. Davison. Dtam: Dense tracking and mapping in real-time. In 2011 international conference on computer vision, pages 2320–2327. IEEE, 2011.   \n[35] Y. Ono, E. Trulls, P. Fua, and K. M. Yi. Lf-net: Learning local features from images. arXiv preprint arXiv:1805.09662, 2018.   \n[36] R. Ranftl and V. Koltun. Deep fundamental matrix estimation. In Proceedings of the European conference on computer vision (ECCV), pages 284–299, 2018.   \n[37] A. Rosinol, M. Abate, Y. Chang, and L. Carlone. Kimera: an open-source library for real-time metricsemantic localization and mapping. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 1689–1696. IEEE, 2020.   \n[38] P.-E. Sarlin, D. DeTone, T. Malisiewicz, and A. Rabinovich. Superglue: Learning feature matching with graph neural networks. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 4938–4947, 2020.   \n[39] P.-E. Sarlin, A. Unagar, M. Larsson, H. Germain, C. Toft, V. Larsson, M. Pollefeys, V. Lepetit, L. Hammarstrand, F. Kahl, et al. Back to the feature: Learning robust camera localization from pixels to pose. arXiv preprint arXiv:2103.09213, 2021.   \n[40] J. L. Schonberger and J.-M. Frahm. Structure-from-motion revisited. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 4104–4113, 2016.   \n[41] T. Schops, T. Sattler, and M. Pollefeys. Bad slam: Bundle adjusted direct rgb-d slam. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 134–144, 2019.   \n[42] D. Schubert, N. Demmel, V. Usenko, J. Stuckler, and D. Cremers. Direct sparse odometry with rolling shutter. In Proceedings of the European Conference on Computer Vision (ECCV), pages 682–697, 2018.   \n[43] J. Sturm, N. Engelhard, F. Endres, W. Burgard, and D. Cremers. A benchmark for the evaluation of rgb-d slam systems. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pages 573–580. IEEE, 2012.   \n[44] E. Sucar, S. Liu, J. Ortiz, and A. J. Davison. imap: Implicit mapping and positioning in real-time. arXiv preprint arXiv:2103.12352, 2021.   \n[45] E. Sucar, K. Wada, and A. Davison. Nodeslam: Neural object descriptors for multi-view shape reconstruction. In 2020 International Conference on 3D Vision (3DV), pages 949–958. IEEE, 2020.   \n[46] C. Tang and P. Tan. Ba-net: Dense bundle adjustment network. arXiv preprint arXiv:1806.04807, 2018.   \n[47] Z. Teed and J. Deng. Deepv2d: Video to depth with differentiable structure from motion. arXiv preprint arXiv:1812.04605, 2018.   \n[48] Z. Teed and J. Deng. Raft: Recurrent all-pairs field transforms for optical flow. In European Conference on Computer Vision, pages 402–419. Springer, 2020.   \n[49] Z. Teed and J. Deng. Tangent space backpropagation for 3d transformation groups. In Conference on Computer Vision and Pattern Recognition, 2021.   \n[50] B. Ummenhofer, H. Zhou, J. Uhrig, N. Mayer, E. Ilg, A. Dosovitskiy, and T. Brox. Demon: Depth and motion network for learning monocular stereo. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5038–5047, 2017.   \n[51] L. von Stumberg, P. Wenzel, N. Yang, and D. Cremers. Lm-reloc: Levenberg-marquardt based direct visual relocalization. arXiv preprint arXiv:2010.06323, 2020.   \n[52] S. Wang, R. Clark, H. Wen, and N. Trigoni. Deepvo: Towards end-to-end visual odometry with deep recurrent convolutional neural networks. In 2017 IEEE International Conference on Robotics and Automation (ICRA), pages 2043–2050. IEEE, 2017.   \n[53] W. Wang, Y. Hu, and S. Scherer. Tartanvo: A generalizable learning-based vo. arXiv preprint arXiv:2011.00359, 2020.   \n[54] W. Wang, D. Zhu, X. Wang, Y. Hu, Y. Qiu, C. Wang, Y. Hu, A. Kapoor, and S. Scherer. Tartanair: A dataset to push the limits of visual slam. arXiv preprint arXiv:2003.14338, 2020.   \n[55] T. Whelan, M. Kaess, H. Johannsson, M. Fallon, J. J. Leonard, and J. McDonald. Real-time large-scale dense rgb-d slam with volumetric fusion. The International Journal of Robotics Research, 34(4-5):598–626, 2015.   \n[56] T. Whelan, S. Leutenegger, R. Salas-Moreno, B. Glocker, and A. Davison. Elasticfusion: Dense slam without a pose graph. Robotics: Science and Systems, 2015.   \n[57] N. Yang, L. v. Stumberg, R. Wang, and D. Cremers. D3vo: Deep depth, deep pose and deep uncertainty for monocular visual odometry. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 1281–1292, 2020.   \n[58] N. Yang, R. Wang, J. Stuckler, and D. Cremers. Deep virtual stereo odometry: Leveraging deep depth prediction for monocular direct sparse odometry. In Proceedings of the European Conference on Computer Vision (ECCV), pages 817–833, 2018.   \n[59] H. Zhou, B. Ummenhofer, and T. Brox. Deeptam: Deep tracking and mapping. In Proceedings of the European conference on computer vision (ECCV), pages 822–838, 2018.   \n[60] J. Zubizarreta, I. Aguinaga, and J. M. M. Montiel. Direct sparse mapping. IEEE Transactions on Robotics, 36(4):1363–1370, 2020. ",
+        "bbox": [
+            171,
+            132,
+            828,
+            914
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            101,
+            828,
+            909
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            342
+        ],
+        "page_idx": 11
+    }
+]

parse/train/ZRcjSOmYraB/ZRcjSOmYraB.md

@@ -0,0 +1,203 @@
+# Learning Distilled Collaboration Graph for Multi-Agent Perception
+
+Yiming Li New York University yimingli@nyu.edu
+
+Shunli Ren Shanghai Jiao Tong University renshunli@sjtu.edu.cn
+
+Pengxiang Wu Rutgers University pxiangwu@gmail.com
+
+Siheng Chen∗ Shanghai Jiao Tong University sihengc@sjtu.edu.cn
+
+Chen Feng∗ New York University cfeng@nyu.edu
+
+Wenjun Zhang Shanghai Jiao Tong University zhangwenjun@sjtu.edu.cn
+
+# Abstract
+
+To promote better performance-bandwidth trade-off for multi-agent perception, we propose a novel distilled collaboration graph (DiscoGraph) to model trainable, pose-aware, and adaptive collaboration among agents. Our key novelties lie in two aspects. First, we propose a teacher-student framework to train DiscoGraph via knowledge distillation. The teacher model employs an early collaboration with holistic-view inputs; the student model is based on intermediate collaboration with single-view inputs. Our framework trains DiscoGraph by constraining postcollaboration feature maps in the student model to match the correspondences in the teacher model. Second, we propose a matrix-valued edge weight in DiscoGraph. In such a matrix, each element reflects the inter-agent attention at a specific spatial region, allowing an agent to adaptively highlight the informative regions. During inference, we only need to use the student model named as the distilled collaboration network (DiscoNet). Attributed to the teacher-student framework, multiple agents with the shared DiscoNet could collaboratively approach the performance of a hypothetical teacher model with a holistic view. Our approach is validated on V2X$\mathrm { S i m } 1 . 0$ , a large-scale multi-agent perception dataset that we synthesized using CARLA and SUMO co-simulation. Our quantitative and qualitative experiments in multi-agent 3D object detection show that DiscoNet could not only achieve a better performance-bandwidth trade-off than the state-of-the-art collaborative perception methods, but also bring more straightforward design rationale. Our code is available on https://github.com/ai4ce/DiscoNet.
+
+# 1 Introduction
+
+Perception, which involves organizing, identifying and interpreting sensory information, is a crucial ability for intelligent agents to understand the environment. Single-agent perception [4] has been studied extensively in recent years, e.g., 2D/3D object detection [18, 27], tracking [23, 22] and segmentation [25, 16], etc. Despite its great progress, single-agent perception suffers from a number of shortcomings stemmed from its individual perspective. For example, in autonomous driving [8], the LiDAR-based perception system can hardly perceive the target in the occluded or long-range areas. Intuitively, with an appropriate collaboration strategy, multi-agent perception could fundamentally upgrade the perception ability over single-agent perception.
+
+To design a collaboration strategy, current approaches mainly include raw-measurement-based early collaboration, output-based late collaboration and feature-based intermediate collaboration.
+
+![](images/1c66afcc6198f0995246098a2b12241266dfde33ae9237b23f6b144bf6eb2c3c.jpg)  
+Figure 1: Scheme comparison. (a) Early collaboration requires an expensive bandwidth for raw data transmission. (b) Intermediate collaboration needs an appropriate collaboration strategy. (c) The proposed method incorporates both early and intermediate collaboration into a knowledge distillation framework, enabling the knowledge of early collaboration to guide the training of an intermediate collaboration strategy, leading to better trade-off between performance and bandwidth.
+
+Early collaboration [3] aggregates the raw measurements from all the agents, promoting a holistic perspective; see Fig. 1 (a). It can fundamentally solve the occlusion and long-range issues occurring in the single-agent perception; however, it requires a lot of communication bandwidth. Contrarily, late collaboration aggregates each agent’s perception outputs. Although it is bandwidth-efficient, each individual perception output could be noisy and incomplete, causing unsatisfying fusion results. To deal with the performance-bandwidth trade-off, intermediate collaboration [19, 34, 20] has been proposed to aggregate intermediate features across agents; see Fig. 1 (b). Since we can squeeze representative information to compact features, this approach can potentially both achieve communication bandwidth efficiency and upgrade perception ability; however, a bad design of collaboration strategy might cause information loss during feature abstraction and fusion, leading to limited improvement of the perception ability.
+
+To achieve an effective design of intermediate collaboration, we propose a distilled collaboration graph (DiscoGraph) to model the collaboration among agents. In DiscoGraph, each node is an agent with real-time pose information and each edge reflects the pair-wise collaboration between two agents. The proposed DiscoGraph is trainable, pose-aware, and adaptive to real-time measurements, reflecting dynamic collaboration among agents. It is novel from two aspects. First, from the training aspect, we propose a teacher-student framework to train DiscoGraph through knowledge distillation [1, 10, 26]; see Fig. 1 (c). Here the teacher model is based on early collaboration with holistic-view inputs and the student model is based on intermediate collaboration with single-view inputs. The knowledge-distillation-based framework enhances the training of DiscoGraph by constraining the postcollaboration feature maps in the student model to match the correspondences in the teacher model. With the guidance of both output-level supervision from perception and feature-level supervision from knowledge distillation, the distilled collaboration graph promotes better feature abstraction and aggregation, improving the performance-bandwidth trade-off. Second, from the modeling aspect, we propose a matrix-valued edge weight in DiscoGraph to reflect the collaboration strength with a high spatial resolution. In the matrix, each element represents the inter-agent attention at a specific spatial region. This design allows the agents to adaptively highlight the informative regions and strategically select appropriate partners to request supplementary information.
+
+During inference, we only need to use the student model. Since it leverages DiscoGraph as the key component, we call the student model as the distilled collaboration network (DiscoNet). Multiple agents with the shared DiscoNet could collaboratively approach the performance of a hypothetical teacher model with the holistic view.
+
+To validate the proposed method, we build V2X-Sim 1.0, a new large-scale multi-agent 3D object detection dataset in autonomous driving scenarios based on CARLA and SUMO co-simulation platform [6]. Comprehensive experiments conducted in 3D object detection [37, 28, 29, 17] have shown that the proposed DiscoNet achieves better performance-bandwidth trade-off and lower communication latency than the state-of-the-art intermediate collaboration methods.
+
+![](images/840c243044307a32e675ccc3354761110a2f63d547ea8c4da9f56dd0b071cd01.jpg)  
+Figure 2: Overall teacher-student training framework. In the student model, for Agent 1 (in red), its input single-view point cloud can be converted to a BEV map, and then be consumed by a shared encoder $\Theta ^ { \mathrm { s } }$ to obtain the feature map $\mathbf { F } _ { i } ^ { \mathrm { s } }$ . Based on the collaboration graph $\mathcal { G } _ { \Pi }$ , Agent 1 aggregates the neural messages from other agents and obtains the updated feature map $\mathbf { H } _ { i } ^ { \mathrm { s } }$ . The shared header following the shared decoder outputs the 3D detection results. In the teacher model, we aggregate the points collected from all agents to obtain a holistic-view point cloud. We crop the region and align the pose to ensure the BEV maps in both teacher and student models are synchronized. We constrain all the post-collaboration feature maps in the student model to match the correspondences in the teacher model through knowledge distillation, resulting in a collaborative student model.
+
+# 2 Multi-Agent Perception System with Distilled Collaboration Graph
+
+This work considers a collaborative perception system to perceive a scene, where multiple agents can perceive and collaborate with each other through a broadcast communication channel. We assume each agent is provided with an accurate pose and the perceived measurements are well synchronized. Then, given a certain communication bandwidth, we aim to maximize the perception ability of each agent through optimizing a collaboration strategy. To design such a strategy, we consider a teacher-student training framework to integrate the strengths from both early and intermediate collaboration. During training, we leverage an early-collaboration model (teacher) to teach an intermediate-collaboration model (student) how to collaborate through knowledge distillation. Here the teacher model and the student model are shared by all the agents, but each agent would input raw measurements from its own view to either model; see Fig. 2. During inference, we only need the student model, where multiple agents with the shared student model could collaboratively approach the performance of the teacher model with the hypothetical holistic view.
+
+In this work, we focus on the perception task of LiDAR-based 3D object detection because the unifying 3D space naturally allows the aggregation of multiple LiDAR scans. Note that in principle the proposed method is generally-applicable in collaborative perception if there exists a unified space to aggregate raw data across multiple agents.
+
+# 2.1 Student: Intermediate collaboration via graphs
+
+Feature encoder. The functionality is to extract informative features from raw measurements for each agent. Let $\mathcal { X } _ { i }$ be the 3D point cloud collected by the $i$ th agent ( $M$ agents in total), the feature of the ith agent is obtained as $\mathbf { F } _ { i } ^ { \mathrm { s } } \gets \Theta ^ { \mathrm { s } } ( \mathcal { X } _ { i } )$ , where $\Theta ^ { \mathrm { s } } ( \cdot )$ is the feature encoder shared by all the agents and the superscript s reflects the student mode. To implement the encoder, we convert a 3D point cloud to a bird’s-eye-view (BEV) map, which is amenable to classic 2D convolutions. Specifically, we quantize the 3D points into regular voxels and represent the 3D voxel lattice as a 2D pseudo-image, with the height dimension corresponding to image channels. Such a 2D image is virtually a BEV map, whose basic element is a cell that is associated with a binary vector along the vertical axis. Let $\mathbf { B } _ { i } \in \{ 0 , 1 \} ^ { K \times K \times C }$ be the BEV map of the $i$ th agent associated with $\mathcal { X } _ { i }$ . With this map, we can apply four blocks composed of 2D convolutions, batch normalization and ReLU activation to gradually reduce the spatial dimension and increase the number of channels for the BEV, to obtain the feature map $\mathbf { F } _ { i } ^ { \mathrm { s } } \in \bar { \mathbb { R } } ^ { \bar { K } \times \bar { K } \times \bar { C } }$ with $\bar { K } \times \bar { K }$ the spatial resolution and $\bar { C }$ the number of channels.
+
+Feature compression. To save the communication bandwidth, each agent could compress its feature map prior to transmission. Here we consider a $1 \times 1$ convolutional autoencoder [24] to compress/decompress the feature maps along the channel dimension. The autoencoder is trained together with the whole system, making the system work with limited collaboration information.
+
+Collaboration graph process. The functionality is to update the feature map through data transmission among the agents. The core component here is a collaboration graph1 $\dot { \mathcal { G } } _ { \Pi } ( \nu , \bar { \mathcal { E } } _ { \Pi } )$ , where $\nu$ is the fixed node set and $\mathcal { E } _ { \Pi }$ is the trainable edge set. Each node in $\nu$ is an agent with the real-time pose information; for instance, $\pmb { \xi } _ { i } \in \mathfrak { s e } ( 3 )$ is the ith agent’s pose in the global coordinate system; and each edge in $\mathcal { E } _ { \Pi }$ is trainable and models the collaboration between two agents, with $\Pi$ an edge-weight encoder, reflecting the trainable collaboration strength between agents. Let $\mathcal { M } _ { \mathcal { G } _ { \Pi } } ( \cdot )$ be the collaboration process defined on the collaboration graph $\mathcal { G } _ { \Pi }$ . The feature maps of all the agents after collaboration are $\{ \mathbf { H } _ { i } ^ { \mathrm { s } } \} _ { i = 1 } ^ { M }  \mathcal { M } _ { \mathcal { G } _ { \Pi } } ( \{ \mathbf { F } _ { i } ^ { \mathrm { s } } \} _ { i = 1 } ^ { M } )$ . This process has three stages: neural message transmission (S1), neural message attention (S2) and neural message aggregation (S3).
+
+In the neural message transmission stage (S1), each agent transmits its BEV-based feature map to the other agents. Since the BEV-based feature map summarizes the information of each agent, we consider it as a neural message. In the neural message attention stage (S2), each agent receives others’ neural messages and determines the matrix-valued edge weights, which reflect the importance of the neural message from one agent to another at each individual cell. Since each agent has its unique pose, we leverage the collaboration graph to achieve feature transformation across agents. For the ith agent, the transformed BEV-based feature map from the $j$ th agent is then $\mathbf { F } _ { j  i } ^ { \mathrm { s } } = \bar { \Gamma } _ { j  i } ( \mathbf { F } _ { i } ^ { \mathrm { s } } ) \in \mathbb { R } ^ { \bar { K } \times \bar { K } \times \bar { C } }$ where the transformation $\Gamma _ { j  i } ( \cdot )$ is based on two ego poses $\xi _ { j }$ and $\pmb { \xi } _ { i }$ . Now $\mathbf { F } _ { j  i } ^ { \mathrm { s } }$ and $\mathbf { F } _ { i } ^ { \mathrm { s } }$ are supported in the same coordinate system. To determine the edge weights, we use the edge encoder $\Pi$ to correlate the ego feature map and the feature map from another agent; that is, the matrix-valued edge weight from the $j$ th agent to the ith agent is $\mathbf { W } _ { j  i } = \bar { \Pi } ( \bar { \mathbf { F } _ { j  i } ^ { \mathrm { s } } } , \mathbf { F } _ { i } ^ { \mathrm { s } } ) \in \mathbb { R } ^ { \bar { K } \times \bar { K } }$ , where $\Pi$ concatenates two feature maps along the channel dimension and then uses four $1 \times 1$ convolutional layers to gradually reduce the number of channels from $2 \bar { C }$ to 1. Meanwhile, there is a softmax operation applied at each cell in the feature map to normalize the edge weights across multiple agents. Note that previous works [19, 20, 34] generally consider a scalar-valued edge weight to reflect the overall collaboration strength between two agents; while we consider a matrix-valued edge weight $\mathbf { W } _ { j  i }$ , which models the collaboration strength from the $j$ th agent to the ith agent with a ${ \bar { K } } \times { \bar { K } }$ spatial resolution. In this matrix, each element corresponds to a cell in the BEV map, indicating a specific spatial region; thus, this matrix reflects the spatial attention at a cell-level resolution. In the neural message aggregation stage (S3), each agent aggregates the feature maps from all the agents based on the normalized matrix-valued edge weights. The updated feature map of the agent $i$ is $\begin{array} { r } { \mathbf { H } _ { i } ^ { \mathrm { s } } = \sum _ { j = 1 } ^ { M } \mathbf { W } _ { j  i } \odot \mathbf { F } _ { j  i } ^ { \mathrm { s } } } \end{array}$ , where $\odot$ denotes the dot product with channel-wise broadcasting.
+
+Remark. The proposed collaboration graph is trainable because each matrix-valued edge weight is a trainable matrix to reflect the agent-to-agent attention in a cell-level spatial resolution; it is poseaware, empowering all the agents to work with the synchronized coordinate system; furthermore, it is dynamic at each timestamp as each edge weight would adapt to the real-time neural messages. According to the proposed collaboration graph, the agents can discover the region requiring collaboration on the fly, and strategically select appropriate partners to request supplementary information.
+
+Decoder and header. After collaboration, each agent decodes the updated BEV-based feature map. The decoded feature map is ${ \bf M } _ { i } ^ { \mathrm { s } }  \Psi ^ { \mathrm { s } } ( { \bf H } _ { i } ^ { \mathrm { s } } )$ . To implement the decoder $\Psi ^ { \mathrm { s } } ( \cdot )$ , we progressively up-sample $\mathbf { H } _ { i } ^ { \mathrm { s } }$ with four layers, where each layer first concatenates the previous feature map with the corresponding feature map in the encoder and then uses a $1 \times 1$ convolutional operation to halve the number of channels. Finally, we use an output header to generate the final detection outputs, $\hat { \mathbf { Y } } _ { i } ^ { \mathrm { s } } \gets \Phi ^ { \mathrm { s } } ( \mathbf { M } _ { i } ^ { \mathrm { s } } )$ . To implement the header $\Psi ^ { \mathrm { s } } ( \cdot )$ , we use two branches of convolutional layers to classify the foreground-background categories and regress the bounding boxes.
+
+# 2.2 Teacher: Early collaboration
+
+During the training phase, an early-collaboration model, as the teacher, is introduced to guide the intermediate-collaboration model, which is a student. Similar to the student model, the teacher’s pipeline has the feature encoder $\Theta ^ { \mathrm { t } }$ , feature decoder $\Psi ^ { \mathrm { t } }$ and the output header $\Phi ^ { \mathrm { t } }$ . Note that all the agents share the same teacher model to guide one student model; however, each agent provides the inputs with its own pose, and its inputs to both the teacher and student models should be well aligned.
+
+Feature encoder. Let $\mathcal { X } = \mathcal { A } ( \pmb { \xi } _ { 1 } \circ \mathcal { X } _ { 1 } , \pmb { \xi } _ { 2 } \circ \mathcal { X } _ { 2 } , . . . , \pmb { \xi } _ { M } \circ \mathcal { X } _ { M } )$ be a holistic-view 3D point cloud that aggregates all the points from all $M$ agents in the global coordinate system, where $\mathcal { A } ( \cdot , . . . , \cdot )$ is the aggregation operator of multiple 3D point clouds, and $\pmb { \xi } _ { i }$ and $\mathcal { X } _ { i }$ are the pose and the 3D point cloud of the ith agent, respectively. To ensure the inputs to the teacher model and the student model are aligned, we transform the holistic-view point cloud $\mathcal { X }$ to an agent’s own coordinate based on the pose information. Now, for the ith agent, the input to the teacher model $\pmb { \xi } _ { i } ^ { - 1 } \circ \pmb { \chi }$ and the input to the student model $\mathcal { X } _ { i }$ are in the same coordinate system. Similarly to the feature encoder in the student model, we convert the 3D point cloud $\pmb { \xi } _ { i } ^ { - 1 } \circ \mathscr { X }$ to a BEV map and use 2D convolutions to obtain the feature map of the ith agent in the teacher model, $\mathbf { H } _ { i } ^ { \mathrm { t } } \in \mathbb { R } ^ { \bar { K } \times \bar { K } \times \bar { C } }$ . Here we crop the BEV map to ensure it has the same spatial range and resolution with the BEV map in the student model.
+
+Decoder and header. Similarly to the decoder and header in the student model, we adopt $\mathbf { M } _ { i } ^ { \mathrm { t } } \gets$ $\Psi ^ { \mathrm { t } } ( \mathbf { H } _ { i } ^ { \mathrm { t } } )$ to obtain the decoded BEV-based feature map and $\widehat { \mathbf { Y } } _ { i } ^ { \mathrm { t } } \gets \Phi ^ { \mathrm { t } } ( \mathbf { M } _ { i } ^ { \mathrm { t } } )$ to obtain the predicted foreground-background categories and regressed bounding boxes.
+
+Teacher training scheme. As in common teacher-student frameworks, we train the teacher model   
+separately. We employ the binary cross-entropy loss to supervise foreground-background classifi  
+cation andloss functidenoted as $L _ { 1 }$ ise the bounding-box regression. Overall, we min, where classification and regression losses are cound-truth detection in the perception region of the mize thelectivelyth agent. $\begin{array} { r } { \mathcal { L } ^ { \mathrm { t } } = \sum _ { i = 1 } ^ { M } \mathcal { L } _ { \mathrm { d e t } } ( \mathbf { Y } _ { i } ^ { \mathrm { t } } , \widehat { \mathbf { Y } } _ { i } ^ { \mathrm { t } } ) } \end{array}$ $\mathcal { L } _ { \mathrm { d e t } }$ $\mathbf { Y } _ { i } ^ { \mathrm { t } } = \mathbf { Y } _ { i } ^ { \mathrm { s } }$ $i$
+
+# 2.3 System training with knowledge distillation
+
+Given a well-trained teacher model, we use both detection loss and knowledge distillation loss to supervise the training of the student model. We consider minimizing the following loss
+
+$$
+\mathcal { L } ^ { \mathrm { s } } = \sum _ { i = 1 } ^ { M } \left( \mathcal { L } _ { \mathrm { d e t } } ( \mathbf { Y } _ { i } ^ { \mathrm { s } } , \widehat { \mathbf { Y } } _ { i } ^ { \mathrm { s } } ) + \lambda _ { \mathrm { k d } } \mathcal { L } _ { \mathrm { k d } } ( \mathbf { H } _ { i } ^ { \mathrm { s } } , \mathbf { H } _ { i } ^ { \mathrm { t } } ) + \lambda _ { \mathrm { k d } } \mathcal { L } _ { \mathrm { k d } } ( \mathbf { M } _ { i } ^ { \mathrm { s } } , \mathbf { M } _ { i } ^ { \mathrm { t } } ) \right) .
+$$
+
+The detection loss $\mathcal { L } _ { \mathrm { d e t } }$ is similar to that of the teacher, including both foreground-background classification loss and the bounding box regression loss, pushing the detection result of each agent to be close to its local ground-truth. The second and third terms form a knowledge distillation loss, regularizing the student model to generate similar feature maps with the teacher model. The hyperparameter $\lambda _ { \mathrm { k d } }$ controls the weight of the knowledge distillation loss $\mathcal { L } _ { \mathrm { k d } }$ defined as follows
+
+$$
+\mathcal { L } _ { \mathrm { k d } } ( \mathbf { H } _ { i } ^ { \mathrm { s } } , \mathbf { H } _ { i } ^ { \mathrm { t } } ) = \sum _ { n = 1 } ^ { { \bar { K } } \times { \bar { K } } } D _ { \mathrm { K L } } \left( \sigma \left( \left( \mathbf { H } _ { i } ^ { \mathrm { t } } \right) _ { n } \right) \vert \vert \sigma \left( \left( \mathbf { H } _ { i } ^ { \mathrm { s } } \right) _ { n } \right) \right) ,
+$$
+
+where $D _ { K L } ( p ( \mathbf { x } ) | | q ( \mathbf { x } ) )$ denotes the Kullback-Leibler (KL) divergence of distribution $q ( \mathbf { x } )$ from distribution $p ( \mathbf { x } ) , \sigma ( \cdot )$ indicates the softmax operation of the feature vector along the channel dimension, and $( \mathbf { H } _ { i } ^ { \mathrm { s } } ) _ { n }$ and $( { \bf { H } } _ { i } ^ { \mathrm { { t } } } ) _ { n }$ denote the feature vectors at the $n$ th cell of the ith agent’s feature map in the student model and teacher model, respectively. Similarly, the loss on decoded feature maps $\mathcal { L } _ { \mathrm { k d } } ( \mathbf { M } _ { i } ^ { \mathrm { s } } , \mathbf { M } _ { i } ^ { \mathrm { t } } )$ can be introduced to enhance the regularization.
+
+Remark. As mentioned in Section 2.in the student model is computed by $\{ \mathbf { H } _ { i } ^ { \mathrm { s } } \} _ { i = 1 } ^ { M }  \mathcal { M } _ { \mathcal { G } _ { \Pi } } ( \{ \mathbf { \dot { F } } _ { i } ^ { \mathrm { s } } \} _ { i = 1 } ^ { M ^ { - } } ) .$ the collaboration graph process. Intuitively, the feature map of the teacher model $\{ \mathbf { H } _ { i } ^ { \mathrm { t } } \} _ { i = 1 } ^ { M }$ would be the desired output of the collaboration graph process $\mathcal { M } _ { \mathcal { G } _ { \Pi } } ( \cdot )$ . Therefore, we constrain all the post-collaboration feature maps in the student model to match the correspondences in the teacher model through knowledge distillation. This constraint would further regularize the upfront trainable components: i) the distilled student encoder $\Theta ^ { \mathrm { s } }$ , which abstracts the features from raw measurements and produces the input to $\mathcal { M } _ { \mathcal { G } _ { \Pi } } ( \cdot )$ , and ii) the edge-weight encoder $\Pi$ in the distilled collaboration graph. Consequently, through knowledge distillation and back-propagation, the distilled student encoder would learn to abstract informative features from raw data for better collaboration; and the distilled edge-weight encoder would learn how to control the collaboration based on agents’ features. In a word, our distilled collaboration network (DiscoNet) can comprehend feature abstraction and fusion via the proposed knowledge distillation framework.
+
+# 3 Related Work
+
+Multi-agent communication. As core components in a multi-agent system, communication strategy among agents has been actively studied in previous works [30, 7, 31]. For example, CommNet [32] adopted the averaging operation to achieve continuous communication in multi-agent system; VAIN [11] considered an attention mechanism to determine which agents would share information;
+
+![](images/8102d95755f63e0f194402216f3f8f1f81f9dc1f52403b9bae6360d3da1ad034.jpg)  
+Figure $3 \colon \mathrm { V } 2 \mathrm { X } { \cdot } \mathrm { S i m } 1 . 0$ dataset. (a) Point clouds from multiple agents in a top-down view (each color indicates an individual agent). (b) Snapshot of the rendered CARLA-SUMO co-simulation. (c) The map of Town05 which is a squared-grid town with cross junctions and multiple lanes per direction.
+
+ATOC [12] exploited an attention unit to determine what information to share with other agents; and TarMAC [5] implicitly learned a signature-based soft attention mechanism to let agents actively select which agents should receive the messages. In this work, we focus on the 3D perception task and propose a trainable, dynamic collaboration graph to control the communication among agents.
+
+Collaborative perception. Collaborative perception is an application of multi-agent communication system to perception tasks [9, 36, 14]. Who2com [20] exploited a handshake communication mechanism to determine which two agents should communicate for image segmentation; When2com [19] introduced an asymmetric attention mechanism to decide when to communicate and how to create communication groups for image segmentation; V2VNet [34] proposed multiple rounds of message passing on a spatial-aware graph neural network for joint perception and prediction in autonomous driving; and [33] proposed a pose error regression module to learn to correct pose errors when the pose information from other agents is noisy.
+
+Knowledge distillation. Knowledge distillation (KD) is a widely used technique to compress a larger teacher network to a smaller student network by pushing the student to approach the teacher in either output or intermediate feature space [10], and it has been applied to various tasks such as semantic segmentation [21], single-agent 3D detection [35], and object re-identification [13]. In this work, we apply the KD technique to a new application scenario: multi-agent graph learning. The teacher is an early-collaboration model with privileged information, and the student is an intermediatecollaboration model with limited viewpoint. The distilled collaboration graph could enable effective and efficient inference for the student model without teacher’s supervision.
+
+Advantages and limitation of DiscoNet. First, previous collaborative perception only rely on the final detection supervision; while DiscoNet leverages both detection supervision and intermediate feature supervision, acquiring more explicit guidance. Second, the collaboration attention in previous methods is a scalar, which cannot reflect the significance of each region; while DiscoNet uses a matrix, leading to more flexible collaboration at various spatial regions. Third, previous methods uses multiple-round collaboration: When2com needs at least one more round of communication after the first handshake, and V2VNet claims three rounds to ensure reliable performance; while DiscoNet only requires one round, suffering less from latency. Admittedly, DiscoNet has a limitation by assuming accurate pose for each agent, which could be improved by method like [33].
+
+# 4 Experiment
+
+# 4.1 V2X-Sim 1.0: A multi-agent 3D object detection dataset
+
+Since there is no public dataset to support the research on multi-agent 3D object detection in selfdriving scenarios, we build such a dataset named as $\mathrm { V } 2 \mathrm { X } { \mathrm { - } } \mathrm { S i m ~ } 1 . 0 ^ { \circ }$ , based on both SUMO [15], a micro-traffic simulation, and CARLA [6], a widely-used open-source simulator for autonomous driving research. SUMO is firstly used to produce numerically-realistic traffic flow and CARLA is employed to get realistic sensory streams including LiDAR and RGB data, from multiple vehicles located in the same geographical area. The simulated LiDAR is rotated at a frequency of $2 0 \mathrm { H z }$ and has 32 channels; the range which denotes the maximum distance to capture is 70 meters. We use Town05 with multiple lanes and cross junctions for dense traffic simulation; see Fig. 3.
+
+Table 1: Detection comparison. Our method is in bold and ∗ indicates the pose-aware version. The proposed DiscoNet is the best among intermediate collaboration. Even with 16 times compression, DiscoNet(16) still outperforms V2VNet without compression.   
+
+<table><tr><td>Method</td><td colspan="3">Collaboration Approach Early Intermediate Late</td><td colspan="2">Average Precision (AP)</td></tr><tr><td>Upper-bound</td><td></td><td></td><td>X</td><td>IoU=0.5 63.3</td><td>IoU=0.7 60.2</td></tr><tr><td></td><td>、</td><td>X</td><td>√</td><td>59.7</td><td>55.8</td></tr><tr><td>When2com*[19]</td><td>X</td><td>√</td><td>X</td><td>45.7</td><td>41.7</td></tr><tr><td>When2com[19]</td><td>X</td><td>√</td><td>X</td><td>45.7</td><td>41.8</td></tr><tr><td>Who2com*[20]</td><td>X</td><td>√</td><td>X</td><td>44.3</td><td>40.3</td></tr><tr><td>Who2com [20]</td><td>X</td><td>√</td><td>X</td><td>44.8</td><td>40.4</td></tr><tr><td>V2VNet [34]</td><td>X</td><td>√</td><td>X</td><td>56.8</td><td>50.7</td></tr><tr><td>DiscoNet</td><td>X</td><td>√</td><td>X</td><td>60.3</td><td>53.9</td></tr><tr><td>DiscoNet(16)</td><td>X</td><td>√</td><td>X</td><td>58.5</td><td>53.0</td></tr><tr><td>Lower-bound</td><td>X</td><td>X</td><td>√</td><td>57.6</td><td>54.2</td></tr><tr><td></td><td>X</td><td>X</td><td>X</td><td>45.8</td><td>42.3</td></tr></table>
+
+Table 2: Detection performance by regularizing various layers via knowledge distillation (KD). ${ \bf M } _ { i } ^ { \mathrm { s } } \{ n \} ( n \stackrel { \cdot } { = } 1 , 2 , 3 , 4 )$ denotes different layers in the decoder. The performance significantly boots once the KD regularization is applied. Further regularization has a slight effect on the detection performance.   
+
+<table><tr><td colspan="4">KD Regularization M{3}</td><td colspan="2">Average Precision (AP)</td></tr><tr><td colspan="4">H M{1} M{2}</td><td>IoU=0.5</td><td>IoU=0.7</td></tr><tr><td>xν&lt;√</td><td></td><td></td><td>M{4}</td><td>57.2</td><td>52.3</td></tr><tr><td></td><td></td><td>xxxx&lt;&lt;&gt;</td><td>xxxxx&lt;v</td><td>57.5</td><td>52.7</td></tr><tr><td></td><td></td><td></td><td></td><td>58.2</td><td>52.7</td></tr><tr><td></td><td></td><td></td><td></td><td>59.7</td><td>53.5</td></tr><tr><td></td><td></td><td></td><td></td><td>60.3</td><td>53.9</td></tr><tr><td></td><td></td><td></td><td></td><td>59.1 58.3</td><td>53.8</td></tr><tr><td>v/x</td><td>xx&lt;&lt;&lt;&lt;&gt;</td><td>xxx&lt;&lt;&lt;&gt;</td><td></td><td></td><td>52.6</td></tr></table>
+
+$\mathrm { V } 2 \mathrm { X } { \cdot } \mathrm { S i m } 1 . 0$ follows the same storage format of nuScenes [2], a widely-used autonomous driving dataset. nuScenes collected real-world single-agent data; while we simulate multi-agent scenarios. Each scene includes a 20 second traffic flow at a certain intersection of Town05, and the LiDAR streams are recorded every 0.2 second, so each scene consists of 100 frames. We generate 100 scenes with a total of 10,000 frames, and in each scene, we randomly select 2-5 vehicles as the collaboration agents. We use 8,000/900/1,100 frames for training/validation/testing. Each frame has multiple samples, and there are 23,500 samples in the training set and 3,100 samples in the test set.
+
+# 4.2 Quantitative evaluation
+
+Implementation and evaluation. We crop the points located in the region of $[ - 3 2 , 3 2 ] \times [ - 3 2 , 3 2 ] \times$ $[ - 3 , 2 ]$ meters defined in the ego-vehicle $X Y Z$ coordinate. We set the width/length of each voxel as 0.25 meter, and the height as 0.4 meter; therefore the BEV map input to the student/teacher encoder has a dimension of $2 5 6 \times 2 5 6 \times 1 3$ . The intermediate feature output by the encoder has a dimension of $3 2 \times 3 2 \times 2 5 6$ , and we use an autoencoder (AE) for compression to save bandwidth: the sent message is the embedding output by AE. After the agents receive the embedding, they will decode it to the original resolution $3 2 \times 3 2 \times 2 5 6$ for intermediate collaboration. The hyperparameter $\lambda _ { \mathrm { k d } }$ is set as $1 0 ^ { 5 }$ . We train all the models using NVIDIA GeForce RTX 3090 GPU. We employ the generic BEV detection evaluation metric: Average Precision (AP) at Intersection-over-Union (IoU) threshold of 0.5 and 0.7. We target the detection of the car category and report the results on the test set.
+
+Baselines and existing methods. We consider the single-agent perception model; called Lowerbound, which consumes a single-view point cloud. The teacher model based on early collaboration with a holistic view is considered as the Upper-bound. Both lower-bound and upper-bound can involve late collaboration, which aggregates all the boxes and applies a global non-maximum suppression (NMS). We also consider three intermediate-collaboration methods, Who2com [20], When2com [19] and V2VNet [34]. Since the original Who2com and When2com do not consider pose information, we consider both pose-aware and pose-agnostic versions to achieve fair comparisons. All the methods use the same detection architecture and conduct collaboration at the same intermediate feature layer.
+
+Results and comparisons. Table 1 shows the comparisons in terms of AP ( $\textcircled { a } \mathrm { I o U } = 0 . 5 / 0 . 7 $ ). We see that i) early collaboration (first row) achieves the best detection performance, and there is an obvious improvement over no collaboration (last row), i.e., $\mathrm { A P } @ 0 . 5$ and $\mathrm { A P @ 0 . 7 }$ are increased by $3 8 . 2 \%$ and $4 2 . 3 \%$ respectively, reflecting the significance of collaboration; ii) late collaboration improves the lower-bound (second last row), but hurts the upper-bound (second row), reflecting the unreliability of late collaboration. This is because the final, global NMS can remove a lot of noisy boxes for the lower-bound, but would also remove many useful boxes for the upper-bound; and iii) among the intermediate collaboration-based methods, the proposed DiscoNet achieves the best performance. Comparing to the pose-aware When2com, DiscoNet improves by $3 1 . 9 \%$ in $\mathrm { A P } @ 0 . 5$ and $2 9 . 3 \%$ in $\mathrm { A P @ 0 . 7 }$ . Comparing to V2VNet, DiscoNet improves by $6 . 2 \%$ in $\mathsf { A P @ 0 . 5 }$ and $6 . 3 \ \%$ in $\mathrm { A P @ 0 . 7 }$ Even with 16-times compression by the autoencoder, DiscoNet(16) still outperforms V2VNet.
+
+Table 3: Comparison of various intermediate collaboration strategies. KD indicates knowledge distillation. With KD and matrix-valued edge weights, our DiscoGraph outperforms the others.   
+
+<table><tr><td rowspan="2">Collaboration Strategy</td><td colspan="4">Scalar Weight</td><td colspan="3">Matrix Weight</td></tr><tr><td>No</td><td>Sum</td><td>Average</td><td>Weighted Average</td><td>Max</td><td>Cat</td><td>DiscoGraph</td></tr><tr><td>w/o KD (AP@IoU 0.5/0.7)</td><td>45.8/42.3</td><td>55.7/50.9</td><td>55.7/50.4</td><td>56.1/51.4</td><td>56.7/51.4</td><td>55.0/50.2</td><td>57.2/52.3</td></tr><tr><td>w/ KD (AP@IoU 0.5/0.7)</td><td>46.5/42.9</td><td>54.4/46.3</td><td>56.4/51.1</td><td>56.7/50.9</td><td>56.7/51.8</td><td>57.5/52.6</td><td>60.3/53.9</td></tr><tr><td>Gain</td><td>0.7/0.6</td><td>-1.3/-4.6</td><td>0.7/0.7</td><td>0.6/-0.5</td><td>0.0/0.4</td><td>2.5/2.4</td><td>3.1/1.6</td></tr><tr><td>Gain (%)</td><td>1.5/1.4</td><td>-2.3/-9.0</td><td>1.3/1.4</td><td>1.1/-1.0</td><td>0.0/0.7</td><td>3.3/4.6</td><td>5.4/3.1</td></tr></table>
+
+![](images/94f9630b277421bc78f106f725e6c54e342f61f6fb6857034dede40d2030fcb0.jpg)  
+Figure 4: Performance-bandwidth trade-off. DiscoNet(64) achieves 192 times less communication volume and still outperforms V2VNet [34].
+
+Performance-bandwidth trade-off analysis. Fig. 4 thoroughly compares the proposed DiscoNet with the baseline methods in terms of the trade-off between detection performance and communication bandwidth. In Plots (a) and (b), the lower-bound with no collaboration is shown as a dashed line since the communication volume is zero, and the other method is shown as one dot in the plot. We see that i) DiscoNet with feature-map compression by an autoencoder achieves a far-more superior trade-off than the other methods; ii) DiscoNet(64), which is DiscoNet with 64-times feature compression by autoencoder, achieves 192 times less communication volume and still outperforms V2VNet for both $\mathrm { A P } @ 0 . 5$ and 0.7; and iii) feature compression does not significantly hurt the detection performance.
+
+Comparison of training times with and without KD. Incorporating KD will increase the training time a little bit, from ${ \sim } 1 2 0 0 \mathrm { s }$ to ${ \sim } 1 5 0 0 \mathrm { s }$ per epoch (each epoch consists of 2,000 iterations). However, during inference, DiscoNet does not need the teacher model anymore and can work alone without extra computations. Note that our key advantage is to push the computation burden into the training stage in pursuit of efficient and effective inference which is crucial in the real-world deployment.
+
+# 4.3 Qualitative evaluation
+
+Visualization of edge weight. To understand the working mechanism of the proposed collaboration graph, we visualize the detection results and the corresponding edge weights; see Fig. 5 and Fig. 7. Note that the proposed edge weight is a matrix, reflecting the collaboration attention in a cell-level resolution, which is shown as a heat map. Fig. 5 (a), (b) and (c) show three exemplar detection results of Agent 1 based on the lower-bound, upper-bound and the proposed DiscoNet, respectively. We see that with the collaboration, DiscoNet is able to detect boxes in those occluded and long-range regions. To understand why, Fig. 5 (d) and (e) provide the corresponding ego edge weight and the edge weight from agent 2 to agent 1, respectively. We clearly see that with the proposed collaboration graph, Agent 1 is able to receive complementary information from the other agents. Take the first row in Fig. 5 as an example, we see that in Plot (d), the bottom-left spatial region has a much darker color, indicating that Agent 1 has less confidence about this region; while in Plot (e), the bottom-left spatial region has a much brighter color, indicating that Agent 1 has much stronger demands to request information from Agent 2.
+
+![](images/0f9e147c78da7f3c0138848ca13b5cbee6a5beb02d6f1e7fad34e2efc16b7424.jpg)  
+Figure 5: Detection and matrix-valued edge weight for Agent 1. Green and red boxes denote groundtruth (GT) and predictions, respectively. (a-c) shows the outputs of lower-bound, upper-bound and DiscoNet compared to GT. (d) Ego matrix-valued edge weight for Agent 1. Attention to the region with sparse/no measurement is suppressed. (e) Matrix-valued edge weight from Agent 2 to Agent 1. Attention to the region with complementary information from Agent 2 is enhanced.
+
+![](images/d2db0446ec6e857e4e2fc34a2f9cbc4fb04277e3bcd1ced0b2260b2d983fb515.jpg)  
+Figure 6: DiscoNet qualitatively outperforms the state-of-the-art methods. Green and red boxes denote ground-truth and detection, respectively. (a) Output of when2com. (b) Output of V2VNet. (c) Output of DiscoNet. (d)-(f) Matrix-valued edge weights. (Ego agent: 1; neighbour agents: 2 and 3.)
+
+Comparison with When2com and V2VNet. Fig. 6 shows two examples to compare the proposed DiscoNet with When2com, V2VNet. We see that DiscoNet is able to detect more objects. The reason is that both V2VNet and when2com employ a scalar to denote the agent-to-agent attention, which cannot distinguish which region is more informative; while DiscoNet can adaptively find beneficial region in a cell-level resolution; see the visualization of matrix-valued edge weights in Fig. 6 (d)-(f).
+
+# 4.4 Ablation study
+
+Effect of collaboration strategy. Table 3 compares the proposed method with five baselines using different intermediate collaboration strategies. Sum simply sums all the intermediate feature maps. Average calculates the mean of all the feature maps. Max selects the maximum value of all the feature maps at each cell to produce the final feature. Cat concatenates the mean of others’ features with its own feature, and then uses a convolution layer to halve the channel number. Weighted Average appends one convolutional layer to our edge encoder $\Pi$ , to generate a scalar value as the agent-wise edge weight. We use a matrix-valued edge weight to model the collaboration among agents. Without knowledge distillation, Max has achieved the second best performance probably because it ignores the noisy information with lower value. We see that with the proposed matrix-valued edge weight and knowledge distillation, DiscoGraph significantly outperforms all the other collaboration choices.
+
+![](images/67f9b034777ad954f1f371bd61a8d1c42e83002a642125dbfaff38747b0b1953.jpg)  
+Figure 7: Detection and matrix-valued edge weight for Agent 1. Green/red boxes denote GT/predictions. (a)(b) show the outputs of upper-bound and DiscoNet. (c) Ego edge weight for Agent 1. (d) Edge weight from Agent 2 to Agent 1. The spatial regions containing complementary information for Agent 1 are highlighted by green circles in (d) and red circles in (a).
+
+Effect of knowledge distillation. In Table 3 we investigate the versions with and without knowledge distillation, We see that i) for our method, the knowledge distillation can guide the learning of collaboration graph, and the agents can work collaboratively to approach the teacher’s performance; ii) for max without a learnable module during collaboration, knowledge distillation has no impact; and iii) for cat and average, their performances are improved a little bit, as knowledge distillation can influence the feature abstraction process. Table 2 further shows the detection performances when we apply knowledge-distillation regularization at various network layers. We see that i) once we apply knowledge distillation to regularize the feature map, the proposed method starts to achieve improvement; and ii) applying regularization on four layers has the best performance.
+
+# 5 Conclusion
+
+We propose a novel intermediate-collaboration method, called distilled collaboration network (DiscoNet), for multi-agent perception. Its core component is a distilled collaboration graph (DiscoGraph), which is novel in both the training paradigm and the edge weight setting. DiscoGraph is also pose-aware and adaptive to perception measurements, allowing multiple agents with the shared DiscoNet to collaboratively approach the performance of the teacher model. To validate, we build $\mathrm { V } 2 \mathrm { X } { \cdot } \mathrm { S i m } 1 . 0$ , a large-scale multi-agent 3D object detection dataset based on CARLA and SUMO. Comprehensive quantitative and qualitative experiments show that DiscoNet achieves appealing performance-bandwidth trade-off with a more straightforward design rationale.
+
+Acknowledgment. This research is partially supported by the NSF CPS program under CMMI1932187, the National Natural Science Foundation of China under Grant 6217010074, and the Science and Technology Commission of Shanghai Municipal under Grant 21511100900. The authors gratefully acknowledge the useful comments and suggestions from anonymous reviewers.
+
+References   
+[1] Rohan Anil, Gabriel Pereyra, Alexandre Passos, Robert Ormandi, George E Dahl, and Geoffrey E Hinton. Large scale distributed neural network training through online distillation. In International Conference on Learning Representations, 2018. 2   
+[2] Holger Caesar, Varun Bankiti, Alex H Lang, Sourabh Vora, Venice Erin Liong, Qiang Xu, Anush Krishnan, Yu Pan, Giancarlo Baldan, and Oscar Beijbom. nuscenes: A multimodal dataset for autonomous driving. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 11621–11631, 2020. 7   
+[3] Qi Chen, Sihai Tang, Qing Yang, and Song Fu. Cooper: Cooperative perception for connected autonomous vehicles based on 3d point clouds. In IEEE International Conference on Distributed Computing Systems (ICDCS), pages 514–524, 2019. 2   
+[4] Siheng Chen, Baoan Liu, Chen Feng, Carlos Vallespi-Gonzalez, and Carl K. Wellington. 3d point cloud processing and learning for autonomous driving: Impacting map creation, localization, and perception. IEEE Signal Processing Magazine, 38:68–86, 2021. 1   
+[5] Abhishek Das, Théophile Gervet, Joshua Romoff, Dhruv Batra, Devi Parikh, Mike Rabbat, and Joelle Pineau. Tarmac: Targeted multi-agent communication. In International Conference on Machine Learning, pages 1538–1546, 2019. 6   
+[6] Alexey Dosovitskiy, German Ros, Felipe Codevilla, Antonio Lopez, and Vladlen Koltun. CARLA: An open urban driving simulator. In Proceedings of the 1st Annual Conference on Robot Learning, pages 1–16, 2017. 2, 6   
+[7] Jakob N. Foerster, Yannis M. Assael, N. D. Freitas, and S. Whiteson. Learning to communicate with deep multi-agent reinforcement learning. In NeurIPS, 2016. 5   
+[8] Andreas Geiger, Philip Lenz, and Raquel Urtasun. Are we ready for autonomous driving? the kitti vision benchmark suite. In 2012 IEEE Conference on Computer Vision and Pattern Recognition, pages 3354–3361, 2012. 1   
+[9] Ramyad Hadidi, Jiashen Cao, Matthew Woodward, Michael S Ryoo, and Hyesoon Kim. Distributed perception by collaborative robots. IEEE Robotics and Automation Letters, 3(4):3709–3716, 2018. 6   
+[10] Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015. 2, 6   
+[11] Yedid Hoshen. Vain: Attentional multi-agent predictive modeling. In NeurIPS, 2017. 5   
+[12] Jiechuan Jiang and Zongqing Lu. Learning attentional communication for multi-agent cooperation. In NeurIPS, 2018. 6   
+[13] Xin Jin, Cuiling Lan, Wenjun Zeng, and Zhibo Chen. Uncertainty-aware multi-shot knowledge distillation for image-based object re-identification. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 11165–11172, 2020. 6   
+[14] Saifullah Khan, Franz Andert, Nicolai Wojke, Julian Schindler, Alejandro Correa, and Anton Wijbenga. Towards collaborative perception for automated vehicles in heterogeneous traffic. In International Forum on Advanced Microsystems for Automotive Applications, pages 31–42, 2018. 6   
+[15] Daniel Krajzewicz, Jakob Erdmann, Michael Behrisch, and Laura Bieker. Recent development and applications of sumo-simulation of urban mobility. International journal on advances in systems and measurements, 5(3&4), 2012. 6   
+[16] Loic Landrieu and Martin Simonovsky. Large-scale point cloud semantic segmentation with superpoint graphs. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4558–4567, 2018. 1   
+[17] Yiming Li, Congcong Wen, Felix Juefei-Xu, and Chen Feng. Fooling lidar perception via adversarial trajectory perturbation. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 7898–7907, October 2021. 2   
+[18] Li Liu, Wanli Ouyang, Xiaogang Wang, Paul Fieguth, Jie Chen, Xinwang Liu, and Matti Pietikäinen. Deep learning for generic object detection: A survey. International journal of computer vision, 128(2):261–318, 2020. 1   
+[19] Yen-Cheng Liu, Junjiao Tian, Nathaniel Glaser, and Zsolt Kira. When2com: multi-agent perception via communication graph grouping. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4106–4115, 2020. 2, 4, 6, 7   
+[20] Yen-Cheng Liu, Junjiao Tian, Chih-Yao Ma, Nathan Glaser, Chia-Wen Kuo, and Zsolt Kira. Who2com: Collaborative perception via learnable handshake communication. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 6876–6883, 2020. 2, 4, 6, 7   
+[21] Yifan Liu, Ke Chen, Chris Liu, Zengchang Qin, Zhenbo Luo, and Jingdong Wang. Structured knowledge distillation for semantic segmentation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 2604–2613, 2019. 6   
+[22] Wenjie Luo, Bin Yang, and Raquel Urtasun. Fast and furious: Real time end-to-end 3d detection, tracking and motion forecasting with a single convolutional net. In Proceedings of the IEEE conference on Computer Vision and Pattern Recognition, pages 3569–3577, 2018. 1   
+[23] Seyed Mojtaba Marvasti-Zadeh, Li Cheng, Hossein Ghanei-Yakhdan, and Shohreh Kasaei. Deep learning for visual tracking: A comprehensive survey. IEEE Transactions on Intelligent Transportation Systems, 2021. 1   
+[24] Jonathan Masci, Ueli Meier, Dan Cire¸san, and Jürgen Schmidhuber. Stacked convolutional auto-encoders for hierarchical feature extraction. In International conference on artificial neural networks, pages 52–59, 2011. 4   
+[25] Shervin Minaee, Yuri Boykov, F. Porikli, A. Plaza, N. Kehtarnavaz, and Demetri Terzopoulos. Image segmentation using deep learning: A survey. IEEE transactions on pattern analysis and machine intelligence, PP, 2021. 1   
+[26] Adriana Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. Fitnets: Hints for thin deep nets. CoRR, abs/1412.6550, 2015. 2   
+[27] Shaoshuai Shi, Xiaogang Wang, and Hongsheng Li. Pointrcnn: 3d object proposal generation and detection from point cloud. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 770–779, 2019. 1   
+[28] Shaoshuai Shi, Zhe Wang, Jianping Shi, Xiaogang Wang, and Hongsheng Li. From points to parts: 3d object detection from point cloud with part-aware and part-aggregation network. IEEE transactions on pattern analysis and machine intelligence, 2020. 2   
+[29] Weijing Shi and Raj Rajkumar. Point-gnn: Graph neural network for 3d object detection in a point cloud. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 1711–1719, 2020. 2   
+[30] Yoav Shoham and Kevin Leyton-Brown. Multiagent systems: Algorithmic, game-theoretic, and logical foundations. Cambridge University Press, 2008. 5   
+[31] Amanpreet Singh, Tushar Jain, and Sainbayar Sukhbaatar. Learning when to communicate at scale in multiagent cooperative and competitive tasks. In International Conference on Learning Representations, 2018. 5   
+[32] Sainbayar Sukhbaatar, Arthur D. Szlam, and Rob Fergus. Learning multiagent communication with backpropagation. In NeurIPS, 2016. 5   
+[33] Nicholas Vadivelu, Mengye Ren, James Tu, Jingkang Wang, and Raquel Urtasun. Learning to communicate and correct pose errors. In 4th Conference on Robot Learning (CoRL), 2020. 6   
+[34] Tsun-Hsuan Wang, Sivabalan Manivasagam, Ming Liang, Bin Yang, Wenyuan Zeng, and Raquel Urtasun. V2vnet: Vehicle-to-vehicle communication for joint perception and prediction. In Proceedings of the European Conference on Computer Vision (ECCV), pages 605–621, 2020. 2, 4, 6, 7, 8   
+[35] Yue Wang, Alireza Fathi, Jiajun Wu, Thomas Funkhouser, and Justin Solomon. Multi-frame to singleframe: Knowledge distillation for 3d object detection. In Proceedings of the European Conference on Computer Vision Workshops, 2020. 6   
+[36] Yufeng Yue, Chunyang Zhao, Mingxing Wen, Zhenyu Wu, and Danwei Wang. Collaborative semantic perception and relative localization based on map matching. In IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 6188–6193, 2020. 6   
+[37] Yin Zhou and Oncel Tuzel. Voxelnet: End-to-end learning for point cloud based 3d object detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4490–4499, 2018. 2

parse/train/ZRcjSOmYraB/ZRcjSOmYraB_content_list.json

@@ -0,0 +1,932 @@
+[
+    {
+        "type": "text",
+        "text": "Learning Distilled Collaboration Graph for Multi-Agent Perception ",
+        "text_level": 1,
+        "bbox": [
+            256,
+            122,
+            740,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yiming Li New York University yimingli@nyu.edu ",
+        "bbox": [
+            196,
+            226,
+            356,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Shunli Ren Shanghai Jiao Tong University renshunli@sjtu.edu.cn ",
+        "bbox": [
+            387,
+            226,
+            591,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pengxiang Wu Rutgers University pxiangwu@gmail.com ",
+        "bbox": [
+            622,
+            226,
+            802,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Siheng Chen∗ Shanghai Jiao Tong University sihengc@sjtu.edu.cn ",
+        "bbox": [
+            191,
+            289,
+            392,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chen Feng∗ New York University cfeng@nyu.edu ",
+        "bbox": [
+            416,
+            289,
+            557,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wenjun Zhang Shanghai Jiao Tong University zhangwenjun@sjtu.edu.cn ",
+        "bbox": [
+            580,
+            289,
+            807,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            367,
+            535,
+            382
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To promote better performance-bandwidth trade-off for multi-agent perception, we propose a novel distilled collaboration graph (DiscoGraph) to model trainable, pose-aware, and adaptive collaboration among agents. Our key novelties lie in two aspects. First, we propose a teacher-student framework to train DiscoGraph via knowledge distillation. The teacher model employs an early collaboration with holistic-view inputs; the student model is based on intermediate collaboration with single-view inputs. Our framework trains DiscoGraph by constraining postcollaboration feature maps in the student model to match the correspondences in the teacher model. Second, we propose a matrix-valued edge weight in DiscoGraph. In such a matrix, each element reflects the inter-agent attention at a specific spatial region, allowing an agent to adaptively highlight the informative regions. During inference, we only need to use the student model named as the distilled collaboration network (DiscoNet). Attributed to the teacher-student framework, multiple agents with the shared DiscoNet could collaboratively approach the performance of a hypothetical teacher model with a holistic view. Our approach is validated on V2X$\\mathrm { S i m } 1 . 0$ , a large-scale multi-agent perception dataset that we synthesized using CARLA and SUMO co-simulation. Our quantitative and qualitative experiments in multi-agent 3D object detection show that DiscoNet could not only achieve a better performance-bandwidth trade-off than the state-of-the-art collaborative perception methods, but also bring more straightforward design rationale. Our code is available on https://github.com/ai4ce/DiscoNet. ",
+        "bbox": [
+            232,
+            397,
+            766,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            710,
+            310,
+            727
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Perception, which involves organizing, identifying and interpreting sensory information, is a crucial ability for intelligent agents to understand the environment. Single-agent perception [4] has been studied extensively in recent years, e.g., 2D/3D object detection [18, 27], tracking [23, 22] and segmentation [25, 16], etc. Despite its great progress, single-agent perception suffers from a number of shortcomings stemmed from its individual perspective. For example, in autonomous driving [8], the LiDAR-based perception system can hardly perceive the target in the occluded or long-range areas. Intuitively, with an appropriate collaboration strategy, multi-agent perception could fundamentally upgrade the perception ability over single-agent perception. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            844
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To design a collaboration strategy, current approaches mainly include raw-measurement-based early collaboration, output-based late collaboration and feature-based intermediate collaboration. ",
+        "bbox": [
+            176,
+            852,
+            825,
+            878
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/1c66afcc6198f0995246098a2b12241266dfde33ae9237b23f6b144bf6eb2c3c.jpg",
+        "image_caption": [
+            "Figure 1: Scheme comparison. (a) Early collaboration requires an expensive bandwidth for raw data transmission. (b) Intermediate collaboration needs an appropriate collaboration strategy. (c) The proposed method incorporates both early and intermediate collaboration into a knowledge distillation framework, enabling the knowledge of early collaboration to guide the training of an intermediate collaboration strategy, leading to better trade-off between performance and bandwidth. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            227,
+            89,
+            789,
+            290
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Early collaboration [3] aggregates the raw measurements from all the agents, promoting a holistic perspective; see Fig. 1 (a). It can fundamentally solve the occlusion and long-range issues occurring in the single-agent perception; however, it requires a lot of communication bandwidth. Contrarily, late collaboration aggregates each agent’s perception outputs. Although it is bandwidth-efficient, each individual perception output could be noisy and incomplete, causing unsatisfying fusion results. To deal with the performance-bandwidth trade-off, intermediate collaboration [19, 34, 20] has been proposed to aggregate intermediate features across agents; see Fig. 1 (b). Since we can squeeze representative information to compact features, this approach can potentially both achieve communication bandwidth efficiency and upgrade perception ability; however, a bad design of collaboration strategy might cause information loss during feature abstraction and fusion, leading to limited improvement of the perception ability. ",
+        "bbox": [
+            174,
+            385,
+            825,
+            536
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To achieve an effective design of intermediate collaboration, we propose a distilled collaboration graph (DiscoGraph) to model the collaboration among agents. In DiscoGraph, each node is an agent with real-time pose information and each edge reflects the pair-wise collaboration between two agents. The proposed DiscoGraph is trainable, pose-aware, and adaptive to real-time measurements, reflecting dynamic collaboration among agents. It is novel from two aspects. First, from the training aspect, we propose a teacher-student framework to train DiscoGraph through knowledge distillation [1, 10, 26]; see Fig. 1 (c). Here the teacher model is based on early collaboration with holistic-view inputs and the student model is based on intermediate collaboration with single-view inputs. The knowledge-distillation-based framework enhances the training of DiscoGraph by constraining the postcollaboration feature maps in the student model to match the correspondences in the teacher model. With the guidance of both output-level supervision from perception and feature-level supervision from knowledge distillation, the distilled collaboration graph promotes better feature abstraction and aggregation, improving the performance-bandwidth trade-off. Second, from the modeling aspect, we propose a matrix-valued edge weight in DiscoGraph to reflect the collaboration strength with a high spatial resolution. In the matrix, each element represents the inter-agent attention at a specific spatial region. This design allows the agents to adaptively highlight the informative regions and strategically select appropriate partners to request supplementary information. ",
+        "bbox": [
+            173,
+            542,
+            826,
+            777
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "During inference, we only need to use the student model. Since it leverages DiscoGraph as the key component, we call the student model as the distilled collaboration network (DiscoNet). Multiple agents with the shared DiscoNet could collaboratively approach the performance of a hypothetical teacher model with the holistic view. ",
+        "bbox": [
+            174,
+            785,
+            823,
+            839
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To validate the proposed method, we build V2X-Sim 1.0, a new large-scale multi-agent 3D object detection dataset in autonomous driving scenarios based on CARLA and SUMO co-simulation platform [6]. Comprehensive experiments conducted in 3D object detection [37, 28, 29, 17] have shown that the proposed DiscoNet achieves better performance-bandwidth trade-off and lower communication latency than the state-of-the-art intermediate collaboration methods. ",
+        "bbox": [
+            174,
+            847,
+            823,
+            915
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/840c243044307a32e675ccc3354761110a2f63d547ea8c4da9f56dd0b071cd01.jpg",
+        "image_caption": [
+            "Figure 2: Overall teacher-student training framework. In the student model, for Agent 1 (in red), its input single-view point cloud can be converted to a BEV map, and then be consumed by a shared encoder $\\Theta ^ { \\mathrm { s } }$ to obtain the feature map $\\mathbf { F } _ { i } ^ { \\mathrm { s } }$ . Based on the collaboration graph $\\mathcal { G } _ { \\Pi }$ , Agent 1 aggregates the neural messages from other agents and obtains the updated feature map $\\mathbf { H } _ { i } ^ { \\mathrm { s } }$ . The shared header following the shared decoder outputs the 3D detection results. In the teacher model, we aggregate the points collected from all agents to obtain a holistic-view point cloud. We crop the region and align the pose to ensure the BEV maps in both teacher and student models are synchronized. We constrain all the post-collaboration feature maps in the student model to match the correspondences in the teacher model through knowledge distillation, resulting in a collaborative student model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            89,
+            813,
+            313
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Multi-Agent Perception System with Distilled Collaboration Graph ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            458,
+            764,
+            477
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This work considers a collaborative perception system to perceive a scene, where multiple agents can perceive and collaborate with each other through a broadcast communication channel. We assume each agent is provided with an accurate pose and the perceived measurements are well synchronized. Then, given a certain communication bandwidth, we aim to maximize the perception ability of each agent through optimizing a collaboration strategy. To design such a strategy, we consider a teacher-student training framework to integrate the strengths from both early and intermediate collaboration. During training, we leverage an early-collaboration model (teacher) to teach an intermediate-collaboration model (student) how to collaborate through knowledge distillation. Here the teacher model and the student model are shared by all the agents, but each agent would input raw measurements from its own view to either model; see Fig. 2. During inference, we only need the student model, where multiple agents with the shared student model could collaboratively approach the performance of the teacher model with the hypothetical holistic view. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            650
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus on the perception task of LiDAR-based 3D object detection because the unifying 3D space naturally allows the aggregation of multiple LiDAR scans. Note that in principle the proposed method is generally-applicable in collaborative perception if there exists a unified space to aggregate raw data across multiple agents. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            712
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Student: Intermediate collaboration via graphs ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            724,
+            542,
+            738
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Feature encoder. The functionality is to extract informative features from raw measurements for each agent. Let $\\mathcal { X } _ { i }$ be the 3D point cloud collected by the $i$ th agent ( $M$ agents in total), the feature of the ith agent is obtained as $\\mathbf { F } _ { i } ^ { \\mathrm { s } } \\gets \\Theta ^ { \\mathrm { s } } ( \\mathcal { X } _ { i } )$ , where $\\Theta ^ { \\mathrm { s } } ( \\cdot )$ is the feature encoder shared by all the agents and the superscript s reflects the student mode. To implement the encoder, we convert a 3D point cloud to a bird’s-eye-view (BEV) map, which is amenable to classic 2D convolutions. Specifically, we quantize the 3D points into regular voxels and represent the 3D voxel lattice as a 2D pseudo-image, with the height dimension corresponding to image channels. Such a 2D image is virtually a BEV map, whose basic element is a cell that is associated with a binary vector along the vertical axis. Let $\\mathbf { B } _ { i } \\in \\{ 0 , 1 \\} ^ { K \\times K \\times C }$ be the BEV map of the $i$ th agent associated with $\\mathcal { X } _ { i }$ . With this map, we can apply four blocks composed of 2D convolutions, batch normalization and ReLU activation to gradually reduce the spatial dimension and increase the number of channels for the BEV, to obtain the feature map $\\mathbf { F } _ { i } ^ { \\mathrm { s } } \\in \\bar { \\mathbb { R } } ^ { \\bar { K } \\times \\bar { K } \\times \\bar { C } }$ with $\\bar { K } \\times \\bar { K }$ the spatial resolution and $\\bar { C }$ the number of channels. ",
+        "bbox": [
+            173,
+            743,
+            826,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Feature compression. To save the communication bandwidth, each agent could compress its feature map prior to transmission. Here we consider a $1 \\times 1$ convolutional autoencoder [24] to compress/decompress the feature maps along the channel dimension. The autoencoder is trained together with the whole system, making the system work with limited collaboration information. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            147
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Collaboration graph process. The functionality is to update the feature map through data transmission among the agents. The core component here is a collaboration graph1 $\\dot { \\mathcal { G } } _ { \\Pi } ( \\nu , \\bar { \\mathcal { E } } _ { \\Pi } )$ , where $\\nu$ is the fixed node set and $\\mathcal { E } _ { \\Pi }$ is the trainable edge set. Each node in $\\nu$ is an agent with the real-time pose information; for instance, $\\pmb { \\xi } _ { i } \\in \\mathfrak { s e } ( 3 )$ is the ith agent’s pose in the global coordinate system; and each edge in $\\mathcal { E } _ { \\Pi }$ is trainable and models the collaboration between two agents, with $\\Pi$ an edge-weight encoder, reflecting the trainable collaboration strength between agents. Let $\\mathcal { M } _ { \\mathcal { G } _ { \\Pi } } ( \\cdot )$ be the collaboration process defined on the collaboration graph $\\mathcal { G } _ { \\Pi }$ . The feature maps of all the agents after collaboration are $\\{ \\mathbf { H } _ { i } ^ { \\mathrm { s } } \\} _ { i = 1 } ^ { M }  \\mathcal { M } _ { \\mathcal { G } _ { \\Pi } } ( \\{ \\mathbf { F } _ { i } ^ { \\mathrm { s } } \\} _ { i = 1 } ^ { M } )$ . This process has three stages: neural message transmission (S1), neural message attention (S2) and neural message aggregation (S3). ",
+        "bbox": [
+            174,
+            152,
+            825,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the neural message transmission stage (S1), each agent transmits its BEV-based feature map to the other agents. Since the BEV-based feature map summarizes the information of each agent, we consider it as a neural message. In the neural message attention stage (S2), each agent receives others’ neural messages and determines the matrix-valued edge weights, which reflect the importance of the neural message from one agent to another at each individual cell. Since each agent has its unique pose, we leverage the collaboration graph to achieve feature transformation across agents. For the ith agent, the transformed BEV-based feature map from the $j$ th agent is then $\\mathbf { F } _ { j  i } ^ { \\mathrm { s } } = \\bar { \\Gamma } _ { j  i } ( \\mathbf { F } _ { i } ^ { \\mathrm { s } } ) \\in \\mathbb { R } ^ { \\bar { K } \\times \\bar { K } \\times \\bar { C } }$ where the transformation $\\Gamma _ { j  i } ( \\cdot )$ is based on two ego poses $\\xi _ { j }$ and $\\pmb { \\xi } _ { i }$ . Now $\\mathbf { F } _ { j  i } ^ { \\mathrm { s } }$ and $\\mathbf { F } _ { i } ^ { \\mathrm { s } }$ are supported in the same coordinate system. To determine the edge weights, we use the edge encoder $\\Pi$ to correlate the ego feature map and the feature map from another agent; that is, the matrix-valued edge weight from the $j$ th agent to the ith agent is $\\mathbf { W } _ { j  i } = \\bar { \\Pi } ( \\bar { \\mathbf { F } _ { j  i } ^ { \\mathrm { s } } } , \\mathbf { F } _ { i } ^ { \\mathrm { s } } ) \\in \\mathbb { R } ^ { \\bar { K } \\times \\bar { K } }$ , where $\\Pi$ concatenates two feature maps along the channel dimension and then uses four $1 \\times 1$ convolutional layers to gradually reduce the number of channels from $2 \\bar { C }$ to 1. Meanwhile, there is a softmax operation applied at each cell in the feature map to normalize the edge weights across multiple agents. Note that previous works [19, 20, 34] generally consider a scalar-valued edge weight to reflect the overall collaboration strength between two agents; while we consider a matrix-valued edge weight $\\mathbf { W } _ { j  i }$ , which models the collaboration strength from the $j$ th agent to the ith agent with a ${ \\bar { K } } \\times { \\bar { K } }$ spatial resolution. In this matrix, each element corresponds to a cell in the BEV map, indicating a specific spatial region; thus, this matrix reflects the spatial attention at a cell-level resolution. In the neural message aggregation stage (S3), each agent aggregates the feature maps from all the agents based on the normalized matrix-valued edge weights. The updated feature map of the agent $i$ is $\\begin{array} { r } { \\mathbf { H } _ { i } ^ { \\mathrm { s } } = \\sum _ { j = 1 } ^ { M } \\mathbf { W } _ { j  i } \\odot \\mathbf { F } _ { j  i } ^ { \\mathrm { s } } } \\end{array}$ , where $\\odot$ denotes the dot product with channel-wise broadcasting. ",
+        "bbox": [
+            173,
+            284,
+            825,
+            598
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Remark. The proposed collaboration graph is trainable because each matrix-valued edge weight is a trainable matrix to reflect the agent-to-agent attention in a cell-level spatial resolution; it is poseaware, empowering all the agents to work with the synchronized coordinate system; furthermore, it is dynamic at each timestamp as each edge weight would adapt to the real-time neural messages. According to the proposed collaboration graph, the agents can discover the region requiring collaboration on the fly, and strategically select appropriate partners to request supplementary information. ",
+        "bbox": [
+            173,
+            604,
+            825,
+            688
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Decoder and header. After collaboration, each agent decodes the updated BEV-based feature map. The decoded feature map is ${ \\bf M } _ { i } ^ { \\mathrm { s } }  \\Psi ^ { \\mathrm { s } } ( { \\bf H } _ { i } ^ { \\mathrm { s } } )$ . To implement the decoder $\\Psi ^ { \\mathrm { s } } ( \\cdot )$ , we progressively up-sample $\\mathbf { H } _ { i } ^ { \\mathrm { s } }$ with four layers, where each layer first concatenates the previous feature map with the corresponding feature map in the encoder and then uses a $1 \\times 1$ convolutional operation to halve the number of channels. Finally, we use an output header to generate the final detection outputs, $\\hat { \\mathbf { Y } } _ { i } ^ { \\mathrm { s } } \\gets \\Phi ^ { \\mathrm { s } } ( \\mathbf { M } _ { i } ^ { \\mathrm { s } } )$ . To implement the header $\\Psi ^ { \\mathrm { s } } ( \\cdot )$ , we use two branches of convolutional layers to classify the foreground-background categories and regress the bounding boxes. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            794
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 Teacher: Early collaboration ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            799,
+            413,
+            814
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "During the training phase, an early-collaboration model, as the teacher, is introduced to guide the intermediate-collaboration model, which is a student. Similar to the student model, the teacher’s pipeline has the feature encoder $\\Theta ^ { \\mathrm { t } }$ , feature decoder $\\Psi ^ { \\mathrm { t } }$ and the output header $\\Phi ^ { \\mathrm { t } }$ . Note that all the agents share the same teacher model to guide one student model; however, each agent provides the inputs with its own pose, and its inputs to both the teacher and student models should be well aligned. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            887
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Feature encoder. Let $\\mathcal { X } = \\mathcal { A } ( \\pmb { \\xi } _ { 1 } \\circ \\mathcal { X } _ { 1 } , \\pmb { \\xi } _ { 2 } \\circ \\mathcal { X } _ { 2 } , . . . , \\pmb { \\xi } _ { M } \\circ \\mathcal { X } _ { M } )$ be a holistic-view 3D point cloud that aggregates all the points from all $M$ agents in the global coordinate system, where $\\mathcal { A } ( \\cdot , . . . , \\cdot )$ is the aggregation operator of multiple 3D point clouds, and $\\pmb { \\xi } _ { i }$ and $\\mathcal { X } _ { i }$ are the pose and the 3D point cloud of the ith agent, respectively. To ensure the inputs to the teacher model and the student model are aligned, we transform the holistic-view point cloud $\\mathcal { X }$ to an agent’s own coordinate based on the pose information. Now, for the ith agent, the input to the teacher model $\\pmb { \\xi } _ { i } ^ { - 1 } \\circ \\pmb { \\chi }$ and the input to the student model $\\mathcal { X } _ { i }$ are in the same coordinate system. Similarly to the feature encoder in the student model, we convert the 3D point cloud $\\pmb { \\xi } _ { i } ^ { - 1 } \\circ \\mathscr { X }$ to a BEV map and use 2D convolutions to obtain the feature map of the ith agent in the teacher model, $\\mathbf { H } _ { i } ^ { \\mathrm { t } } \\in \\mathbb { R } ^ { \\bar { K } \\times \\bar { K } \\times \\bar { C } }$ . Here we crop the BEV map to ensure it has the same spatial range and resolution with the BEV map in the student model. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            236
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Decoder and header. Similarly to the decoder and header in the student model, we adopt $\\mathbf { M } _ { i } ^ { \\mathrm { t } } \\gets$ $\\Psi ^ { \\mathrm { t } } ( \\mathbf { H } _ { i } ^ { \\mathrm { t } } )$ to obtain the decoded BEV-based feature map and $\\widehat { \\mathbf { Y } } _ { i } ^ { \\mathrm { t } } \\gets \\Phi ^ { \\mathrm { t } } ( \\mathbf { M } _ { i } ^ { \\mathrm { t } } )$ to obtain the predicted foreground-background categories and regressed bounding boxes. ",
+        "bbox": [
+            174,
+            241,
+            825,
+            286
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Teacher training scheme. As in common teacher-student frameworks, we train the teacher model   \nseparately. We employ the binary cross-entropy loss to supervise foreground-background classifi  \ncation andloss functidenoted as $L _ { 1 }$ ise the bounding-box regression. Overall, we min, where classification and regression losses are cound-truth detection in the perception region of the mize thelectivelyth agent. $\\begin{array} { r } { \\mathcal { L } ^ { \\mathrm { t } } = \\sum _ { i = 1 } ^ { M } \\mathcal { L } _ { \\mathrm { d e t } } ( \\mathbf { Y } _ { i } ^ { \\mathrm { t } } , \\widehat { \\mathbf { Y } } _ { i } ^ { \\mathrm { t } } ) } \\end{array}$ $\\mathcal { L } _ { \\mathrm { d e t } }$ $\\mathbf { Y } _ { i } ^ { \\mathrm { t } } = \\mathbf { Y } _ { i } ^ { \\mathrm { s } }$ $i$ ",
+        "bbox": [
+            173,
+            292,
+            825,
+            366
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 System training with knowledge distillation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            369,
+            516,
+            385
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given a well-trained teacher model, we use both detection loss and knowledge distillation loss to supervise the training of the student model. We consider minimizing the following loss ",
+        "bbox": [
+            174,
+            386,
+            823,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5eb583b04d98a3eeb458cc35cc50b09c0ccee6af703317d14c232ae4f0b061b9.jpg",
+        "text": "$$\n\\mathcal { L } ^ { \\mathrm { s } } = \\sum _ { i = 1 } ^ { M } \\left( \\mathcal { L } _ { \\mathrm { d e t } } ( \\mathbf { Y } _ { i } ^ { \\mathrm { s } } , \\widehat { \\mathbf { Y } } _ { i } ^ { \\mathrm { s } } ) + \\lambda _ { \\mathrm { k d } } \\mathcal { L } _ { \\mathrm { k d } } ( \\mathbf { H } _ { i } ^ { \\mathrm { s } } , \\mathbf { H } _ { i } ^ { \\mathrm { t } } ) + \\lambda _ { \\mathrm { k d } } \\mathcal { L } _ { \\mathrm { k d } } ( \\mathbf { M } _ { i } ^ { \\mathrm { s } } , \\mathbf { M } _ { i } ^ { \\mathrm { t } } ) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            411,
+            727,
+            454
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The detection loss $\\mathcal { L } _ { \\mathrm { d e t } }$ is similar to that of the teacher, including both foreground-background classification loss and the bounding box regression loss, pushing the detection result of each agent to be close to its local ground-truth. The second and third terms form a knowledge distillation loss, regularizing the student model to generate similar feature maps with the teacher model. The hyperparameter $\\lambda _ { \\mathrm { k d } }$ controls the weight of the knowledge distillation loss $\\mathcal { L } _ { \\mathrm { k d } }$ defined as follows ",
+        "bbox": [
+            174,
+            458,
+            825,
+            529
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2847bbc5a51ed27e7dd1b0c0221ad5fc0cbaaa154b8f9d8677755ad6648a2a30.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { k d } } ( \\mathbf { H } _ { i } ^ { \\mathrm { s } } , \\mathbf { H } _ { i } ^ { \\mathrm { t } } ) = \\sum _ { n = 1 } ^ { { \\bar { K } } \\times { \\bar { K } } } D _ { \\mathrm { K L } } \\left( \\sigma \\left( \\left( \\mathbf { H } _ { i } ^ { \\mathrm { t } } \\right) _ { n } \\right) \\vert \\vert \\sigma \\left( \\left( \\mathbf { H } _ { i } ^ { \\mathrm { s } } \\right) _ { n } \\right) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            526,
+            676,
+            570
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $D _ { K L } ( p ( \\mathbf { x } ) | | q ( \\mathbf { x } ) )$ denotes the Kullback-Leibler (KL) divergence of distribution $q ( \\mathbf { x } )$ from distribution $p ( \\mathbf { x } ) , \\sigma ( \\cdot )$ indicates the softmax operation of the feature vector along the channel dimension, and $( \\mathbf { H } _ { i } ^ { \\mathrm { s } } ) _ { n }$ and $( { \\bf { H } } _ { i } ^ { \\mathrm { { t } } } ) _ { n }$ denote the feature vectors at the $n$ th cell of the ith agent’s feature map in the student model and teacher model, respectively. Similarly, the loss on decoded feature maps $\\mathcal { L } _ { \\mathrm { k d } } ( \\mathbf { M } _ { i } ^ { \\mathrm { s } } , \\mathbf { M } _ { i } ^ { \\mathrm { t } } )$ can be introduced to enhance the regularization. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            646
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Remark. As mentioned in Section 2.in the student model is computed by $\\{ \\mathbf { H } _ { i } ^ { \\mathrm { s } } \\} _ { i = 1 } ^ { M }  \\mathcal { M } _ { \\mathcal { G } _ { \\Pi } } ( \\{ \\mathbf { \\dot { F } } _ { i } ^ { \\mathrm { s } } \\} _ { i = 1 } ^ { M ^ { - } } ) .$ the collaboration graph process. Intuitively, the feature map of the teacher model $\\{ \\mathbf { H } _ { i } ^ { \\mathrm { t } } \\} _ { i = 1 } ^ { M }$ would be the desired output of the collaboration graph process $\\mathcal { M } _ { \\mathcal { G } _ { \\Pi } } ( \\cdot )$ . Therefore, we constrain all the post-collaboration feature maps in the student model to match the correspondences in the teacher model through knowledge distillation. This constraint would further regularize the upfront trainable components: i) the distilled student encoder $\\Theta ^ { \\mathrm { s } }$ , which abstracts the features from raw measurements and produces the input to $\\mathcal { M } _ { \\mathcal { G } _ { \\Pi } } ( \\cdot )$ , and ii) the edge-weight encoder $\\Pi$ in the distilled collaboration graph. Consequently, through knowledge distillation and back-propagation, the distilled student encoder would learn to abstract informative features from raw data for better collaboration; and the distilled edge-weight encoder would learn how to control the collaboration based on agents’ features. In a word, our distilled collaboration network (DiscoNet) can comprehend feature abstraction and fusion via the proposed knowledge distillation framework. ",
+        "bbox": [
+            173,
+            650,
+            826,
+            820
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            830,
+            323,
+            848
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Multi-agent communication. As core components in a multi-agent system, communication strategy among agents has been actively studied in previous works [30, 7, 31]. For example, CommNet [32] adopted the averaging operation to achieve continuous communication in multi-agent system; VAIN [11] considered an attention mechanism to determine which agents would share information; ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/8102d95755f63e0f194402216f3f8f1f81f9dc1f52403b9bae6360d3da1ad034.jpg",
+        "image_caption": [
+            "Figure $3 \\colon \\mathrm { V } 2 \\mathrm { X } { \\cdot } \\mathrm { S i m } 1 . 0$ dataset. (a) Point clouds from multiple agents in a top-down view (each color indicates an individual agent). (b) Snapshot of the rendered CARLA-SUMO co-simulation. (c) The map of Town05 which is a squared-grid town with cross junctions and multiple lanes per direction. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            93,
+            810,
+            246
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "ATOC [12] exploited an attention unit to determine what information to share with other agents; and TarMAC [5] implicitly learned a signature-based soft attention mechanism to let agents actively select which agents should receive the messages. In this work, we focus on the 3D perception task and propose a trainable, dynamic collaboration graph to control the communication among agents. ",
+        "bbox": [
+            174,
+            314,
+            825,
+            369
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Collaborative perception. Collaborative perception is an application of multi-agent communication system to perception tasks [9, 36, 14]. Who2com [20] exploited a handshake communication mechanism to determine which two agents should communicate for image segmentation; When2com [19] introduced an asymmetric attention mechanism to decide when to communicate and how to create communication groups for image segmentation; V2VNet [34] proposed multiple rounds of message passing on a spatial-aware graph neural network for joint perception and prediction in autonomous driving; and [33] proposed a pose error regression module to learn to correct pose errors when the pose information from other agents is noisy. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            487
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Knowledge distillation. Knowledge distillation (KD) is a widely used technique to compress a larger teacher network to a smaller student network by pushing the student to approach the teacher in either output or intermediate feature space [10], and it has been applied to various tasks such as semantic segmentation [21], single-agent 3D detection [35], and object re-identification [13]. In this work, we apply the KD technique to a new application scenario: multi-agent graph learning. The teacher is an early-collaboration model with privileged information, and the student is an intermediatecollaboration model with limited viewpoint. The distilled collaboration graph could enable effective and efficient inference for the student model without teacher’s supervision. ",
+        "bbox": [
+            174,
+            493,
+            825,
+            603
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Advantages and limitation of DiscoNet. First, previous collaborative perception only rely on the final detection supervision; while DiscoNet leverages both detection supervision and intermediate feature supervision, acquiring more explicit guidance. Second, the collaboration attention in previous methods is a scalar, which cannot reflect the significance of each region; while DiscoNet uses a matrix, leading to more flexible collaboration at various spatial regions. Third, previous methods uses multiple-round collaboration: When2com needs at least one more round of communication after the first handshake, and V2VNet claims three rounds to ensure reliable performance; while DiscoNet only requires one round, suffering less from latency. Admittedly, DiscoNet has a limitation by assuming accurate pose for each agent, which could be improved by method like [33]. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            734
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiment ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            748,
+            303,
+            766
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 V2X-Sim 1.0: A multi-agent 3D object detection dataset ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            776,
+            602,
+            792
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since there is no public dataset to support the research on multi-agent 3D object detection in selfdriving scenarios, we build such a dataset named as $\\mathrm { V } 2 \\mathrm { X } { \\mathrm { - } } \\mathrm { S i m ~ } 1 . 0 ^ { \\circ }$ , based on both SUMO [15], a micro-traffic simulation, and CARLA [6], a widely-used open-source simulator for autonomous driving research. SUMO is firstly used to produce numerically-realistic traffic flow and CARLA is employed to get realistic sensory streams including LiDAR and RGB data, from multiple vehicles located in the same geographical area. The simulated LiDAR is rotated at a frequency of $2 0 \\mathrm { H z }$ and has 32 channels; the range which denotes the maximum distance to capture is 70 meters. We use Town05 with multiple lanes and cross junctions for dense traffic simulation; see Fig. 3. ",
+        "bbox": [
+            174,
+            803,
+            825,
+            859
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/5faa349dce73bb052d4f1953397bc845db1f2114e413bb9bac7cb1b9c167d1b1.jpg",
+        "table_caption": [
+            "Table 1: Detection comparison. Our method is in bold and ∗ indicates the pose-aware version. The proposed DiscoNet is the best among intermediate collaboration. Even with 16 times compression, DiscoNet(16) still outperforms V2VNet without compression. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td colspan=\"3\">Collaboration Approach Early Intermediate Late</td><td colspan=\"2\">Average Precision (AP)</td></tr><tr><td>Upper-bound</td><td></td><td></td><td>X</td><td>IoU=0.5 63.3</td><td>IoU=0.7 60.2</td></tr><tr><td></td><td>、</td><td>X</td><td>√</td><td>59.7</td><td>55.8</td></tr><tr><td>When2com*[19]</td><td>X</td><td>√</td><td>X</td><td>45.7</td><td>41.7</td></tr><tr><td>When2com[19]</td><td>X</td><td>√</td><td>X</td><td>45.7</td><td>41.8</td></tr><tr><td>Who2com*[20]</td><td>X</td><td>√</td><td>X</td><td>44.3</td><td>40.3</td></tr><tr><td>Who2com [20]</td><td>X</td><td>√</td><td>X</td><td>44.8</td><td>40.4</td></tr><tr><td>V2VNet [34]</td><td>X</td><td>√</td><td>X</td><td>56.8</td><td>50.7</td></tr><tr><td>DiscoNet</td><td>X</td><td>√</td><td>X</td><td>60.3</td><td>53.9</td></tr><tr><td>DiscoNet(16)</td><td>X</td><td>√</td><td>X</td><td>58.5</td><td>53.0</td></tr><tr><td>Lower-bound</td><td>X</td><td>X</td><td>√</td><td>57.6</td><td>54.2</td></tr><tr><td></td><td>X</td><td>X</td><td>X</td><td>45.8</td><td>42.3</td></tr></table>",
+        "bbox": [
+            174,
+            184,
+            464,
+            319
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/cdabaf0cbd0b4b45241bf688e834bff16144eed8d9fdda9baf78ff66e5e8d9ca.jpg",
+        "table_caption": [
+            "Table 2: Detection performance by regularizing various layers via knowledge distillation (KD). ${ \\bf M } _ { i } ^ { \\mathrm { s } } \\{ n \\} ( n \\stackrel { \\cdot } { = } 1 , 2 , 3 , 4 )$ denotes different layers in the decoder. The performance significantly boots once the KD regularization is applied. Further regularization has a slight effect on the detection performance. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"4\">KD Regularization M{3}</td><td colspan=\"2\">Average Precision (AP)</td></tr><tr><td colspan=\"4\">H M{1} M{2}</td><td>IoU=0.5</td><td>IoU=0.7</td></tr><tr><td>xν&lt;√</td><td></td><td></td><td>M{4}</td><td>57.2</td><td>52.3</td></tr><tr><td></td><td></td><td>xxxx&lt;&lt;&gt;</td><td>xxxxx&lt;v</td><td>57.5</td><td>52.7</td></tr><tr><td></td><td></td><td></td><td></td><td>58.2</td><td>52.7</td></tr><tr><td></td><td></td><td></td><td></td><td>59.7</td><td>53.5</td></tr><tr><td></td><td></td><td></td><td></td><td>60.3</td><td>53.9</td></tr><tr><td></td><td></td><td></td><td></td><td>59.1 58.3</td><td>53.8</td></tr><tr><td>v/x</td><td>xx&lt;&lt;&lt;&lt;&gt;</td><td>xxx&lt;&lt;&lt;&gt;</td><td></td><td></td><td>52.6</td></tr></table>",
+        "bbox": [
+            480,
+            202,
+            816,
+            314
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            340,
+            825,
+            396
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "$\\mathrm { V } 2 \\mathrm { X } { \\cdot } \\mathrm { S i m } 1 . 0$ follows the same storage format of nuScenes [2], a widely-used autonomous driving dataset. nuScenes collected real-world single-agent data; while we simulate multi-agent scenarios. Each scene includes a 20 second traffic flow at a certain intersection of Town05, and the LiDAR streams are recorded every 0.2 second, so each scene consists of 100 frames. We generate 100 scenes with a total of 10,000 frames, and in each scene, we randomly select 2-5 vehicles as the collaboration agents. We use 8,000/900/1,100 frames for training/validation/testing. Each frame has multiple samples, and there are 23,500 samples in the training set and 3,100 samples in the test set. ",
+        "bbox": [
+            173,
+            401,
+            825,
+            500
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Quantitative evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            510,
+            377,
+            523
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Implementation and evaluation. We crop the points located in the region of $[ - 3 2 , 3 2 ] \\times [ - 3 2 , 3 2 ] \\times$ $[ - 3 , 2 ]$ meters defined in the ego-vehicle $X Y Z$ coordinate. We set the width/length of each voxel as 0.25 meter, and the height as 0.4 meter; therefore the BEV map input to the student/teacher encoder has a dimension of $2 5 6 \\times 2 5 6 \\times 1 3$ . The intermediate feature output by the encoder has a dimension of $3 2 \\times 3 2 \\times 2 5 6$ , and we use an autoencoder (AE) for compression to save bandwidth: the sent message is the embedding output by AE. After the agents receive the embedding, they will decode it to the original resolution $3 2 \\times 3 2 \\times 2 5 6$ for intermediate collaboration. The hyperparameter $\\lambda _ { \\mathrm { k d } }$ is set as $1 0 ^ { 5 }$ . We train all the models using NVIDIA GeForce RTX 3090 GPU. We employ the generic BEV detection evaluation metric: Average Precision (AP) at Intersection-over-Union (IoU) threshold of 0.5 and 0.7. We target the detection of the car category and report the results on the test set. ",
+        "bbox": [
+            173,
+            525,
+            825,
+            662
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Baselines and existing methods. We consider the single-agent perception model; called Lowerbound, which consumes a single-view point cloud. The teacher model based on early collaboration with a holistic view is considered as the Upper-bound. Both lower-bound and upper-bound can involve late collaboration, which aggregates all the boxes and applies a global non-maximum suppression (NMS). We also consider three intermediate-collaboration methods, Who2com [20], When2com [19] and V2VNet [34]. Since the original Who2com and When2com do not consider pose information, we consider both pose-aware and pose-agnostic versions to achieve fair comparisons. All the methods use the same detection architecture and conduct collaboration at the same intermediate feature layer. ",
+        "bbox": [
+            173,
+            670,
+            825,
+            780
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results and comparisons. Table 1 shows the comparisons in terms of AP ( $\\textcircled { a } \\mathrm { I o U } = 0 . 5 / 0 . 7 $ ). We see that i) early collaboration (first row) achieves the best detection performance, and there is an obvious improvement over no collaboration (last row), i.e., $\\mathrm { A P } @ 0 . 5$ and $\\mathrm { A P @ 0 . 7 }$ are increased by $3 8 . 2 \\%$ and $4 2 . 3 \\%$ respectively, reflecting the significance of collaboration; ii) late collaboration improves the lower-bound (second last row), but hurts the upper-bound (second row), reflecting the unreliability of late collaboration. This is because the final, global NMS can remove a lot of noisy boxes for the lower-bound, but would also remove many useful boxes for the upper-bound; and iii) among the intermediate collaboration-based methods, the proposed DiscoNet achieves the best performance. Comparing to the pose-aware When2com, DiscoNet improves by $3 1 . 9 \\%$ in $\\mathrm { A P } @ 0 . 5$ and $2 9 . 3 \\%$ in $\\mathrm { A P @ 0 . 7 }$ . Comparing to V2VNet, DiscoNet improves by $6 . 2 \\%$ in $\\mathsf { A P @ 0 . 5 }$ and $6 . 3 \\ \\%$ in $\\mathrm { A P @ 0 . 7 }$ Even with 16-times compression by the autoencoder, DiscoNet(16) still outperforms V2VNet. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/71e223f7cb5de70800b9fac28d1068dd0b00ad874617f68b45bb782c95c1330d.jpg",
+        "table_caption": [
+            "Table 3: Comparison of various intermediate collaboration strategies. KD indicates knowledge distillation. With KD and matrix-valued edge weights, our DiscoGraph outperforms the others. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Collaboration Strategy</td><td colspan=\"4\">Scalar Weight</td><td colspan=\"3\">Matrix Weight</td></tr><tr><td>No</td><td>Sum</td><td>Average</td><td>Weighted Average</td><td>Max</td><td>Cat</td><td>DiscoGraph</td></tr><tr><td>w/o KD (AP@IoU 0.5/0.7)</td><td>45.8/42.3</td><td>55.7/50.9</td><td>55.7/50.4</td><td>56.1/51.4</td><td>56.7/51.4</td><td>55.0/50.2</td><td>57.2/52.3</td></tr><tr><td>w/ KD (AP@IoU 0.5/0.7)</td><td>46.5/42.9</td><td>54.4/46.3</td><td>56.4/51.1</td><td>56.7/50.9</td><td>56.7/51.8</td><td>57.5/52.6</td><td>60.3/53.9</td></tr><tr><td>Gain</td><td>0.7/0.6</td><td>-1.3/-4.6</td><td>0.7/0.7</td><td>0.6/-0.5</td><td>0.0/0.4</td><td>2.5/2.4</td><td>3.1/1.6</td></tr><tr><td>Gain (%)</td><td>1.5/1.4</td><td>-2.3/-9.0</td><td>1.3/1.4</td><td>1.1/-1.0</td><td>0.0/0.7</td><td>3.3/4.6</td><td>5.4/3.1</td></tr></table>",
+        "bbox": [
+            176,
+            123,
+            818,
+            208
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/94f9630b277421bc78f106f725e6c54e342f61f6fb6857034dede40d2030fcb0.jpg",
+        "image_caption": [
+            "Figure 4: Performance-bandwidth trade-off. DiscoNet(64) achieves 192 times less communication volume and still outperforms V2VNet [34]. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            236,
+            782,
+            478
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            517,
+            825,
+            546
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Performance-bandwidth trade-off analysis. Fig. 4 thoroughly compares the proposed DiscoNet with the baseline methods in terms of the trade-off between detection performance and communication bandwidth. In Plots (a) and (b), the lower-bound with no collaboration is shown as a dashed line since the communication volume is zero, and the other method is shown as one dot in the plot. We see that i) DiscoNet with feature-map compression by an autoencoder achieves a far-more superior trade-off than the other methods; ii) DiscoNet(64), which is DiscoNet with 64-times feature compression by autoencoder, achieves 192 times less communication volume and still outperforms V2VNet for both $\\mathrm { A P } @ 0 . 5$ and 0.7; and iii) feature compression does not significantly hurt the detection performance. ",
+        "bbox": [
+            173,
+            551,
+            825,
+            662
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparison of training times with and without KD. Incorporating KD will increase the training time a little bit, from ${ \\sim } 1 2 0 0 \\mathrm { s }$ to ${ \\sim } 1 5 0 0 \\mathrm { s }$ per epoch (each epoch consists of 2,000 iterations). However, during inference, DiscoNet does not need the teacher model anymore and can work alone without extra computations. Note that our key advantage is to push the computation burden into the training stage in pursuit of efficient and effective inference which is crucial in the real-world deployment. ",
+        "bbox": [
+            174,
+            669,
+            825,
+            738
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Qualitative evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            744,
+            367,
+            758
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Visualization of edge weight. To understand the working mechanism of the proposed collaboration graph, we visualize the detection results and the corresponding edge weights; see Fig. 5 and Fig. 7. Note that the proposed edge weight is a matrix, reflecting the collaboration attention in a cell-level resolution, which is shown as a heat map. Fig. 5 (a), (b) and (c) show three exemplar detection results of Agent 1 based on the lower-bound, upper-bound and the proposed DiscoNet, respectively. We see that with the collaboration, DiscoNet is able to detect boxes in those occluded and long-range regions. To understand why, Fig. 5 (d) and (e) provide the corresponding ego edge weight and the edge weight from agent 2 to agent 1, respectively. We clearly see that with the proposed collaboration graph, Agent 1 is able to receive complementary information from the other agents. Take the first row in Fig. 5 as an example, we see that in Plot (d), the bottom-left spatial region has a much darker color, indicating that Agent 1 has less confidence about this region; while in Plot (e), the bottom-left spatial region has a much brighter color, indicating that Agent 1 has much stronger demands to request information from Agent 2. ",
+        "bbox": [
+            173,
+            760,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f9e147c78da7f3c0138848ca13b5cbee6a5beb02d6f1e7fad34e2efc16b7424.jpg",
+        "image_caption": [
+            "Figure 5: Detection and matrix-valued edge weight for Agent 1. Green and red boxes denote groundtruth (GT) and predictions, respectively. (a-c) shows the outputs of lower-bound, upper-bound and DiscoNet compared to GT. (d) Ego matrix-valued edge weight for Agent 1. Attention to the region with sparse/no measurement is suppressed. (e) Matrix-valued edge weight from Agent 2 to Agent 1. Attention to the region with complementary information from Agent 2 is enhanced. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            98,
+            818,
+            359
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/d2db0446ec6e857e4e2fc34a2f9cbc4fb04277e3bcd1ced0b2260b2d983fb515.jpg",
+        "image_caption": [
+            "Figure 6: DiscoNet qualitatively outperforms the state-of-the-art methods. Green and red boxes denote ground-truth and detection, respectively. (a) Output of when2com. (b) Output of V2VNet. (c) Output of DiscoNet. (d)-(f) Matrix-valued edge weights. (Ego agent: 1; neighbour agents: 2 and 3.) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            454,
+            833,
+            613
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            671,
+            823,
+            700
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Comparison with When2com and V2VNet. Fig. 6 shows two examples to compare the proposed DiscoNet with When2com, V2VNet. We see that DiscoNet is able to detect more objects. The reason is that both V2VNet and when2com employ a scalar to denote the agent-to-agent attention, which cannot distinguish which region is more informative; while DiscoNet can adaptively find beneficial region in a cell-level resolution; see the visualization of matrix-valued edge weights in Fig. 6 (d)-(f). ",
+        "bbox": [
+            174,
+            707,
+            825,
+            776
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 Ablation study ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            782,
+            315,
+            796
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effect of collaboration strategy. Table 3 compares the proposed method with five baselines using different intermediate collaboration strategies. Sum simply sums all the intermediate feature maps. Average calculates the mean of all the feature maps. Max selects the maximum value of all the feature maps at each cell to produce the final feature. Cat concatenates the mean of others’ features with its own feature, and then uses a convolution layer to halve the channel number. Weighted Average appends one convolutional layer to our edge encoder $\\Pi$ , to generate a scalar value as the agent-wise edge weight. We use a matrix-valued edge weight to model the collaboration among agents. Without knowledge distillation, Max has achieved the second best performance probably because it ignores the noisy information with lower value. We see that with the proposed matrix-valued edge weight and knowledge distillation, DiscoGraph significantly outperforms all the other collaboration choices. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/67f9b034777ad954f1f371bd61a8d1c42e83002a642125dbfaff38747b0b1953.jpg",
+        "image_caption": [
+            "Figure 7: Detection and matrix-valued edge weight for Agent 1. Green/red boxes denote GT/predictions. (a)(b) show the outputs of upper-bound and DiscoNet. (c) Ego edge weight for Agent 1. (d) Edge weight from Agent 2 to Agent 1. The spatial regions containing complementary information for Agent 1 are highlighted by green circles in (d) and red circles in (a). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            92,
+            820,
+            444
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            531,
+            825,
+            559
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Effect of knowledge distillation. In Table 3 we investigate the versions with and without knowledge distillation, We see that i) for our method, the knowledge distillation can guide the learning of collaboration graph, and the agents can work collaboratively to approach the teacher’s performance; ii) for max without a learnable module during collaboration, knowledge distillation has no impact; and iii) for cat and average, their performances are improved a little bit, as knowledge distillation can influence the feature abstraction process. Table 2 further shows the detection performances when we apply knowledge-distillation regularization at various network layers. We see that i) once we apply knowledge distillation to regularize the feature map, the proposed method starts to achieve improvement; and ii) applying regularization on four layers has the best performance. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            690
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            708,
+            299,
+            726
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We propose a novel intermediate-collaboration method, called distilled collaboration network (DiscoNet), for multi-agent perception. Its core component is a distilled collaboration graph (DiscoGraph), which is novel in both the training paradigm and the edge weight setting. DiscoGraph is also pose-aware and adaptive to perception measurements, allowing multiple agents with the shared DiscoNet to collaboratively approach the performance of the teacher model. To validate, we build $\\mathrm { V } 2 \\mathrm { X } { \\cdot } \\mathrm { S i m } 1 . 0$ , a large-scale multi-agent 3D object detection dataset based on CARLA and SUMO. Comprehensive quantitative and qualitative experiments show that DiscoNet achieves appealing performance-bandwidth trade-off with a more straightforward design rationale. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            849
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgment. This research is partially supported by the NSF CPS program under CMMI1932187, the National Natural Science Foundation of China under Grant 6217010074, and the Science and Technology Commission of Shanghai Municipal under Grant 21511100900. The authors gratefully acknowledge the useful comments and suggestions from anonymous reviewers. ",
+        "bbox": [
+            176,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Rohan Anil, Gabriel Pereyra, Alexandre Passos, Robert Ormandi, George E Dahl, and Geoffrey E Hinton. Large scale distributed neural network training through online distillation. In International Conference on Learning Representations, 2018. 2   \n[2] Holger Caesar, Varun Bankiti, Alex H Lang, Sourabh Vora, Venice Erin Liong, Qiang Xu, Anush Krishnan, Yu Pan, Giancarlo Baldan, and Oscar Beijbom. nuscenes: A multimodal dataset for autonomous driving. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 11621–11631, 2020. 7   \n[3] Qi Chen, Sihai Tang, Qing Yang, and Song Fu. Cooper: Cooperative perception for connected autonomous vehicles based on 3d point clouds. In IEEE International Conference on Distributed Computing Systems (ICDCS), pages 514–524, 2019. 2   \n[4] Siheng Chen, Baoan Liu, Chen Feng, Carlos Vallespi-Gonzalez, and Carl K. Wellington. 3d point cloud processing and learning for autonomous driving: Impacting map creation, localization, and perception. IEEE Signal Processing Magazine, 38:68–86, 2021. 1   \n[5] Abhishek Das, Théophile Gervet, Joshua Romoff, Dhruv Batra, Devi Parikh, Mike Rabbat, and Joelle Pineau. Tarmac: Targeted multi-agent communication. In International Conference on Machine Learning, pages 1538–1546, 2019. 6   \n[6] Alexey Dosovitskiy, German Ros, Felipe Codevilla, Antonio Lopez, and Vladlen Koltun. CARLA: An open urban driving simulator. In Proceedings of the 1st Annual Conference on Robot Learning, pages 1–16, 2017. 2, 6   \n[7] Jakob N. Foerster, Yannis M. Assael, N. D. Freitas, and S. Whiteson. Learning to communicate with deep multi-agent reinforcement learning. In NeurIPS, 2016. 5   \n[8] Andreas Geiger, Philip Lenz, and Raquel Urtasun. Are we ready for autonomous driving? the kitti vision benchmark suite. In 2012 IEEE Conference on Computer Vision and Pattern Recognition, pages 3354–3361, 2012. 1   \n[9] Ramyad Hadidi, Jiashen Cao, Matthew Woodward, Michael S Ryoo, and Hyesoon Kim. Distributed perception by collaborative robots. IEEE Robotics and Automation Letters, 3(4):3709–3716, 2018. 6   \n[10] Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015. 2, 6   \n[11] Yedid Hoshen. Vain: Attentional multi-agent predictive modeling. In NeurIPS, 2017. 5   \n[12] Jiechuan Jiang and Zongqing Lu. Learning attentional communication for multi-agent cooperation. In NeurIPS, 2018. 6   \n[13] Xin Jin, Cuiling Lan, Wenjun Zeng, and Zhibo Chen. Uncertainty-aware multi-shot knowledge distillation for image-based object re-identification. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 11165–11172, 2020. 6   \n[14] Saifullah Khan, Franz Andert, Nicolai Wojke, Julian Schindler, Alejandro Correa, and Anton Wijbenga. Towards collaborative perception for automated vehicles in heterogeneous traffic. In International Forum on Advanced Microsystems for Automotive Applications, pages 31–42, 2018. 6   \n[15] Daniel Krajzewicz, Jakob Erdmann, Michael Behrisch, and Laura Bieker. Recent development and applications of sumo-simulation of urban mobility. International journal on advances in systems and measurements, 5(3&4), 2012. 6   \n[16] Loic Landrieu and Martin Simonovsky. Large-scale point cloud semantic segmentation with superpoint graphs. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4558–4567, 2018. 1   \n[17] Yiming Li, Congcong Wen, Felix Juefei-Xu, and Chen Feng. Fooling lidar perception via adversarial trajectory perturbation. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 7898–7907, October 2021. 2   \n[18] Li Liu, Wanli Ouyang, Xiaogang Wang, Paul Fieguth, Jie Chen, Xinwang Liu, and Matti Pietikäinen. Deep learning for generic object detection: A survey. International journal of computer vision, 128(2):261–318, 2020. 1   \n[19] Yen-Cheng Liu, Junjiao Tian, Nathaniel Glaser, and Zsolt Kira. When2com: multi-agent perception via communication graph grouping. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4106–4115, 2020. 2, 4, 6, 7   \n[20] Yen-Cheng Liu, Junjiao Tian, Chih-Yao Ma, Nathan Glaser, Chia-Wen Kuo, and Zsolt Kira. Who2com: Collaborative perception via learnable handshake communication. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 6876–6883, 2020. 2, 4, 6, 7   \n[21] Yifan Liu, Ke Chen, Chris Liu, Zengchang Qin, Zhenbo Luo, and Jingdong Wang. Structured knowledge distillation for semantic segmentation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 2604–2613, 2019. 6   \n[22] Wenjie Luo, Bin Yang, and Raquel Urtasun. Fast and furious: Real time end-to-end 3d detection, tracking and motion forecasting with a single convolutional net. In Proceedings of the IEEE conference on Computer Vision and Pattern Recognition, pages 3569–3577, 2018. 1   \n[23] Seyed Mojtaba Marvasti-Zadeh, Li Cheng, Hossein Ghanei-Yakhdan, and Shohreh Kasaei. Deep learning for visual tracking: A comprehensive survey. IEEE Transactions on Intelligent Transportation Systems, 2021. 1   \n[24] Jonathan Masci, Ueli Meier, Dan Cire¸san, and Jürgen Schmidhuber. Stacked convolutional auto-encoders for hierarchical feature extraction. In International conference on artificial neural networks, pages 52–59, 2011. 4   \n[25] Shervin Minaee, Yuri Boykov, F. Porikli, A. Plaza, N. Kehtarnavaz, and Demetri Terzopoulos. Image segmentation using deep learning: A survey. IEEE transactions on pattern analysis and machine intelligence, PP, 2021. 1   \n[26] Adriana Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. Fitnets: Hints for thin deep nets. CoRR, abs/1412.6550, 2015. 2   \n[27] Shaoshuai Shi, Xiaogang Wang, and Hongsheng Li. Pointrcnn: 3d object proposal generation and detection from point cloud. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 770–779, 2019. 1   \n[28] Shaoshuai Shi, Zhe Wang, Jianping Shi, Xiaogang Wang, and Hongsheng Li. From points to parts: 3d object detection from point cloud with part-aware and part-aggregation network. IEEE transactions on pattern analysis and machine intelligence, 2020. 2   \n[29] Weijing Shi and Raj Rajkumar. Point-gnn: Graph neural network for 3d object detection in a point cloud. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 1711–1719, 2020. 2   \n[30] Yoav Shoham and Kevin Leyton-Brown. Multiagent systems: Algorithmic, game-theoretic, and logical foundations. Cambridge University Press, 2008. 5   \n[31] Amanpreet Singh, Tushar Jain, and Sainbayar Sukhbaatar. Learning when to communicate at scale in multiagent cooperative and competitive tasks. In International Conference on Learning Representations, 2018. 5   \n[32] Sainbayar Sukhbaatar, Arthur D. Szlam, and Rob Fergus. Learning multiagent communication with backpropagation. In NeurIPS, 2016. 5   \n[33] Nicholas Vadivelu, Mengye Ren, James Tu, Jingkang Wang, and Raquel Urtasun. Learning to communicate and correct pose errors. In 4th Conference on Robot Learning (CoRL), 2020. 6   \n[34] Tsun-Hsuan Wang, Sivabalan Manivasagam, Ming Liang, Bin Yang, Wenyuan Zeng, and Raquel Urtasun. V2vnet: Vehicle-to-vehicle communication for joint perception and prediction. In Proceedings of the European Conference on Computer Vision (ECCV), pages 605–621, 2020. 2, 4, 6, 7, 8   \n[35] Yue Wang, Alireza Fathi, Jiajun Wu, Thomas Funkhouser, and Justin Solomon. Multi-frame to singleframe: Knowledge distillation for 3d object detection. In Proceedings of the European Conference on Computer Vision Workshops, 2020. 6   \n[36] Yufeng Yue, Chunyang Zhao, Mingxing Wen, Zhenyu Wu, and Danwei Wang. Collaborative semantic perception and relative localization based on map matching. In IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 6188–6193, 2020. 6   \n[37] Yin Zhou and Oncel Tuzel. Voxelnet: End-to-end learning for point cloud based 3d object detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4490–4499, 2018. 2 ",
+        "bbox": [
+            173,
+            58,
+            828,
+            919
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            64,
+            828,
+            915
+        ],
+        "page_idx": 11
+    }
+]

parse/train/_x4A8IZ-rRv/_x4A8IZ-rRv.md

@@ -0,0 +1,540 @@
+# Differentiable Sparsification for Deep Neural Networks
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Deep neural networks have relieved the feature engineering burden on human   
+2 experts. However, comparable efforts are instead required to determine an effective   
+3 architecture. In addition, as the sizes of networks have over-grown, a considerable   
+4 amount of resources is also invested in reducing the sizes. The sparsification of an   
+5 over-complete model addresses these problems as it removes redundant parameters   
+6 or connections. In this study, we propose a fully differentiable sparsification   
+7 method for deep neural networks, which allows parameters to be zero during   
+8 training with the stochastic gradient descent. Thus, the proposed method can   
+9 simultaneously learn the sparsified structure and weights of networks in an end  
+10 to-end manner, which can be directly applies to modern deep neural networks   
+11 and imposes minimum overhead to the training process. To the authors’ best   
+12 knowledge, it is the first fully [sub-]differentiable sparsification method that zeroes   
+13 out components, and it provides a foundation for future structure learning and   
+14 model compression methods.
+
+# 15 1 Introduction
+
+16 The success of deep neural networks has changed the paradigm of machine learning and pattern   
+17 recognition from feature engineering to architecture engineering [16, 14, 22, 7, 32]. Although deep   
+18 neural networks have relieved the burden of feature engineering, comparable human efforts are instead   
+19 required to determine an effective architecture, such as the number of neurons or layers and the   
+20 connections between nodes. In addition, as deep neural networks have over-grown (even up to 10–68   
+21 million parameters) [8, 10, 15, 32], considerable effort is also being invested in reducing existing   
+22 model sizes and in meeting the demands of deploying such networks on constrained platforms at   
+23 inference time [26, 25].   
+24 These problems can be addressed by the sparsification of an over-complete model [20]. A network   
+25 structure can be carved out of an over-complete model by removing redundant blocks [3, 29] or   
+26 deleting unnecessary connections between nodes or blocks [2, 18, 30], which also reduces the network   
+27 size. Among several approaches, pruning has long been adapted [17, 6, 26, 19, 5]. It typically requires   
+28 a pre-trained model and several steps (select unimportant parameters of a pre-trained model, delete   
+29 the parameters, and retrain the pruned model) and may repeat the process multiple times. Another   
+30 approach is a sparsity regularizer with the proximal gradient [21, 3, 29, 33] which shrinks redundant   
+31 parameters to zero during training and requires no pre-trained model. Among the most popular ones   
+32 is $l _ { 1 }$ -regularizer [28]. However, as it acts on an individual parameter, it often produces unstructured   
+33 irregular models; thus, it diminishes the benefit of parallel hardware computation, such as GPUs [29].   
+34 In order to obtain regular sparse structures, a sparse regularization with $l _ { 2 }$ -norm [3, 29] was adopted   
+35 on a group of parameters so that all parameters under the same group are either retained or zeroed  
+36 out together. By zeroing-out parameters at a group level, the number of neurons or layers can be   
+37 automatically determined as a part of training. However, the optimization of a regularization term is   
+38 performed as a separate step separately from the gradient descent-based optimization for prediction   
+39 loss. The update rules should be implemented manually and the approach is limited to the cases   
+40 where closed form solutions for the proximal operation are known.   
+41 In this work, we propose a fully [sub-]differentiable sparsification method for deep neural networks,   
+42 which directly optimizes a regularized objective function and allows parameters to be exactly zero   
+43 during training with the stochastic gradient descent. Thus, it can simultaneously learn the sparsified   
+44 structure and weights of deep neural networks in an end-to-end manner. It leads to simpler implemen  
+45 tation and it does not require to manually code a pruning step or an update rule like a soft-thresholding   
+46 operator. It can adopt various norms as a regularizer regardless of whether their closed form solutions   
+47 for the proximal operator are known or not. Another advantage of the proposed method is that it   
+48 can be easily applied on a group of parameters or a building block; thus, it can produce a structured   
+49 model and maximize the benefits of parallel hardware computation (e.g., GPUs) and it well suits the   
+50 trend of a modularized design in deep learning [22, 27, 7, 32].
+
+# 51 2 Related Work
+
+# 2.1 Proximal Gradient
+
+Our proposed method is related to sparsity regularization with the proximal gradient [21]. A regularized objective function is written as
+
+$$
+\mathcal { L } \left( D , W \right) + \lambda \mathcal { R } \left( W \right) ,
+$$
+
+55 where $\mathcal { L }$ denotes a prediction loss, $\mathcal { R }$ is a regularization term, $D$ is a set of training data, $W$ is a set   
+56 of model parameters, and $\lambda$ controls the trade-off between prediction loss and model complexity. The   
+57 most popular regularizer is $l _ { 1 }$ -norm,
+
+$$
+{ \mathcal { R } } \left( W \right) = \sum _ { i } \left| w _ { i } \right| ,
+$$
+
+58 where $w _ { i }$ is an individual element of $W$ . To optimize the regularization term, parameter updating is   
+59 performed with a proximal operator,
+
+$$
+w _ { i }  s i g n ( w _ { i } ) ( | w _ { i } | - \eta \lambda ) _ { + } ,
+$$
+
+60 where denotes an assignment operator, $\eta$ is a learning rate, and $( \cdot ) _ { + }$ represents $\operatorname* { m a x } ( \cdot , 0 )$ . As this   
+61 approach acts on an individual parameter, it often produces unstructured irregular models. In order   
+62 to obtain regular sparse structures, the sparse regularization with $l _ { 2 , 1 }$ -norm can be adopted [3, 29].   
+63 All parameters in the same group are either retained or zeroed-out together. The regularization with   
+64 $l _ { 2 , 1 }$ -norm is written as
+
+$$
+\mathcal { R } \left( W \right) = \sum _ { g } \left. \mathbf { w } _ { g } \right. _ { 2 } = \sum _ { g } \sqrt { \sum _ { i } w _ { g , i } ^ { 2 } } ,
+$$
+
+65 where $W = \{ \mathbf { w } _ { g } \}$ and ${ \bf w } _ { g }$ represents a group of model parameters. The regularization term is   
+66 optimized with a proximal operator,
+
+$$
+w _ { g , i } \gets \left( \frac { \left\| \mathbf { w } _ { g } \right\| _ { 2 } - \eta \lambda } { \left\| \mathbf { w } _ { g } \right\| _ { 2 } } \right) _ { + } w _ { g , i } .
+$$
+
+67 When a group has only one single parameter, it degenerates to the $l _ { 1 }$ -norm regularization.
+
+68 Another group regularization is exclusive lasso with $l _ { 1 , 2 }$ -norm [34, 33]. Rather than either retaining   
+69 or removing an entire group altogether, it promotes the competition or sparsity within a group. The   
+70 regularization term is written as
+
+$$
+\mathcal { R } \left( W \right) = \frac { 1 } { 2 } \sum _ { g } \left. \mathbf { w } _ { g } \right. _ { 1 } ^ { 2 } = \frac { 1 } { 2 } \sum _ { g } \left( \sum _ { i } \left. w _ { g , i } \right. \right) ^ { 2 } ,
+$$
+
+71 and its updating rule is derived as
+
+$$
+w _ { g , i }  s i g n ( w _ { g , i } ) ( | w _ { g , i } | - \eta \lambda \big | \big | \mathbf { w } _ { g } \big | \big | _ { 1 } ) _ { + } .
+$$
+
+72 These proximal operators consist of weight decaying and thresholding steps, and they are performed   
+73 at every mini-batch or epoch in a sperate step after the optimization of a prediction loss. It requires   
+74 some extra efforts to implement the update rules manually and applications are limited to the cases   
+75 where closed form solutions for the proximal operator are known. In contrast, our approach optimizes   
+76 a regularized objective function directly and allows parameters to be zero during training with the   
+77 stochastic gradient descent. It leads to simpler implementations and it can employ various norms   
+78 regardless of whether closed form solutions for proximal operators are known or not, for example   
+79 $p$ -norm with $p < 1$ .
+
+# 80 2.2 Differentiable Approach
+
+81 Similar to our work, previous differentiable approaches [2, 18] learn the structure of a neural   
+82 network by optimizing architecture parameters in a relaxed continuous domain, where architecture   
+83 parameters represent the importance scores of building blocks or the connection strengths between   
+84 them. However, as the architecture parameter magnitudes cannot be zero during training, the   
+85 top $k$ connections or components are stochastically or deterministically selected according to the   
+86 architecture parameter values to derive a discretized architecture. Therefore, the approach may suffer   
+87 from the discrepancy between a learned architecture and a final discretized one. Moreover, the   
+88 value of $k$ should be pre-specified manually; thus, the same value is set for all blocks or modules,   
+89 which may be sub-optimal. Our approach drives the architecture parameters to zero by optimizing a   
+90 regularized objective function. This can minimize the model discrepancy, and a network can choose   
+91 the different numbers of components or connections in each module through training.
+
+# 92 3 Proposed Approach
+
+# 3.1 Base Model
+
+94 We assume that there are $n$ components in a module. A component can be any building block for a   
+95 deep neural network or its output. For example, it can be a channel or a layer of convolutional neural   
+96 networks such as ResNet [7, 8] and DenseNet layer [10]. It can also represent a node in a neural   
+97 graph [30] or a convolutional neural network [11]. A module represents a composite of components,   
+98 such as a group of channels or nodes. For illustration purposes, we assume that a module $\mathbf { y }$ can be   
+99 written as the linear combination of components $\mathbf { f } _ { i }$ :
+
+$$
+\mathbf { y } \left( \mathbf { x } \right) = \sum _ { i = 1 } ^ { n } a _ { i } \mathbf { f } _ { i } \left( \mathbf { x } ; \mathbf { w } _ { i } \right) ,
+$$
+
+100 where $\mathbf { X }$ denotes a module input, $\mathbf { w } _ { i }$ model parameters for component $\mathbf { f } _ { i }$ , and $a _ { i }$ an architecture   
+101 parameter. Model parameters $\mathbf { w } _ { i }$ denote ordinary parameters, such as a filter in a convolutional layer   
+102 or weight in a fully connected layer. The value of $a _ { i }$ represents the importance of component $i$ , and it   
+103 represents the connection strength between nodes in another context. Enforcing $a _ { i }$ to be zero amounts   
+104 to removing component $\mathbf { f } _ { i }$ or zeroing-out $\mathbf { w } _ { i }$ . Thus, by creating the competition between elements of   
+105 $a$ and driving them to be zero, we can eliminate unnecessary components or connections. The sample   
+106 model is simple, but we will show that it can be applied to various cases.
+
+# 107 3.2 Differentiable Sparse Parameterization
+
+08 First, we show how to parameterize architecture parameters with non-negative constraints, which is   
+09 useful for the attention mechanism with the softmax. To set up the competition between the elements   
+110 of $a$ and allow them to be zero, we parameterize the architecture parameters as follows:
+
+$$
+\gamma _ { i } = \exp \left( \alpha _ { i } \right)
+$$
+
+$$
+\tilde { \gamma } _ { i } = \left( \gamma _ { i } - \sigma \left( \beta \right) \cdot \left. \gamma \right. _ { 1 } \right) _ { + }
+$$
+
+$$
+a _ { i } = \frac { \tilde { \gamma } _ { i } } { \sum _ { j = 1 } ^ { n } \tilde { \gamma } _ { j } } ,
+$$
+
+113 where $\alpha _ { i }$ and $\beta$ are unconstrained free parameters, $\sigma ( \cdot )$ denotes a sigmoid function, and $( \cdot ) _ { + }$ rep  
+114 resents $r e l u ( \cdot ) = \operatorname* { m a x } ( \cdot , 0 )$ . When a parameter is non-negative, the proximal operator of Eq. (7)   
+115 is reduced to Eq. (10). Although the forms are similar, they have completely different meanings.   
+116 The proximal operator is a learning rule, whereas Eq. (10) is the parameterized form of architecture   
+117 parameters, which is part of a neural network.   
+118 We can easily verify that $a _ { i }$ is allowed to be zero and is also differentiable from a modern deep   
+119 learning perspective. The free parameters $\alpha _ { i }$ and $\beta$ are real-valued and they do not restrict a training   
+120 process with the stochastic gradient descent. Thus, we can train $a _ { i }$ through $\alpha _ { i }$ and $\beta$ . The exponential   
+121 function in Eq. (9) ensures that the architecture parameters are non-negative. Typically, $a _ { i }$ cannot   
+122 be zero due to the exponential function of Eq. (9). However, $\tilde { \gamma } _ { i }$ in Eq. (10) can be zero by the   
+123 thresholding operation; hence, $a _ { i }$ can be zero as well. The term $\sigma \left( \beta \right) \cdot \| \gamma \| _ { 1 }$ plays the role of a   
+124 threshold, and the thresholding operation is interpreted as follows: if the strength of component $i$   
+125 in a competition group is small compared to the total strength, it is dropped from the competition.   
+126 Note that the scalar parameter $\beta$ in Eq. (10), which determines the magnitude of a threshold, is   
+127 not a hyper-parameter, but its value is automatically determined through training. Mathematically,   
+128 the thresholding operator is not differentiable, but this should not pose an issue considering the   
+129 support of relu as a built-in differentiable function in a modern deep learning tool. Additionally, $\gamma$ is   
+130 non-negative; thus, its $l _ { 1 }$ -norm is simply the sum of $\gamma _ { i }$ (i.e., $\| \gamma \| _ { 1 } = \sum \gamma _ { i } )$ . The softmax of Eq. (11)   
+131 is also differentiable. The softmax is optional but useful when we need to promote the competition   
+132 between components as in the attention mechanism.
+
+33 By relaxing the differentiability, singed architecture parameter can be similarly formed as
+
+$$
+a _ { i } = s i g n ( \alpha _ { i } ) ( | \alpha _ { i } | - \sigma ( \beta ) | | \alpha | | _ { 1 } ) _ { + } ,
+$$
+
+134 where $\alpha$ and $\beta$ are free parameters. The gradient of the sign function is zero almost everywhere, but   
+135 it does not cause a problem for a modern deep learning tool. The equation can be rewritten as
+
+$$
+a _ { i } = \left\{ \begin{array} { l l } { \left( \alpha _ { i } + \sigma \left( \beta \right) \lVert \alpha \rVert _ { 1 } \right) _ { - } } & { \mathrm { i f } \ \alpha _ { i } < 0 } \\ { \left( \alpha _ { i } - \sigma \left( \beta \right) \lVert \alpha \rVert _ { 1 } \right) _ { + } } & { \mathrm { o t h e r w i s e } , } \end{array} \right.
+$$
+
+136 where $( \cdot ) _ { - } = \operatorname* { m i n } ( \cdot , 0 )$ . The gradient can be computed separately according to whether its value   
+137 is negative or not. To the authors’ understanding, sign function is already taken care in the ex  
+138 plained manner by TensorFlow [1], and thus $t f . m a t h . s i g n ( )$ can be simply used without the manual   
+139 implementation of the conditional statement.
+
+# 3.3 Sparsity Regularizer
+
+141 In the proposed approach, an objective function is written as
+
+$$
+\mathcal { L } \left( D , W , a \right) + \lambda \mathcal { R } \left( a \right) ,
+$$
+
+142 where $a$ denotes the vector of architecture parameters. Sparsifying $a$ is equivalent to sparsifying a   
+143 deep neural network. Therefore, we can use the regularization term on $a$ to encourage the sparsity of   
+144 $a$ . The proposed method is not limited to a particular norm and we can drive different sparsity patterns   
+145 depending on the types of norms. For example, the most popular choice for parameter selection is   
+146 $l _ { 1 }$ -norm, but it is unsuitable on $a$ in Eq. (11) as it is normalized using the softmax. Its $l _ { 1 }$ -norm is   
+147 always 1, i.e., $\begin{array} { r } { \| a \| _ { 1 } = \sum _ { i = 1 } ^ { n } | a _ { i } | = 1 } \end{array}$ . Therefore, we should employ $p$ -norm with $p < 1$ :
+
+$$
+\mathcal { R } \left( a \right) = \left( \sum _ { i = 1 } ^ { n } \lvert a _ { i } \rvert ^ { p } \right) ^ { \frac { 1 } { p } } = \left( \sum _ { i = 1 } ^ { n } a _ { i } ^ { p } \right) ^ { \frac { 1 } { p } } ,
+$$
+
+148 where the second equality holds as $a _ { i }$ is always non-negative. To the authors’ best knowledge, a closed   
+149 form solution for the proximal operator of $p$ -norm with $p < 1$ is unknown, but the regularization term   
+150 is differentiable almost everywhere as relu is. Thus, the proposed approach can directly optimize the   
+151 regularized objective function and zero-out components with the stochastic gradient descent.   
+152 By simply switching one norm to another one for a regularizer, different sparsity patterns can be   
+153 derived. For example, an individual component can be removed with $l _ { 1 }$ -norm (Eq. 2) and a group of   
+154 components or an entire module can be zeroed-out with $l _ { 2 , 1 }$ -norm (Eq. 4). Note that we do not need   
+155 to manually implement different updating rules as in the proximal gradient approach. We just need to   
+156 rewrite a regularization term in the objective function. Examples codes and experiment results are   
+157 shown in the supplementary material.
+
+If $\gamma _ { i }$ Eq. (10) or $\alpha _ { i }$ in Eq. (12) is less than the threshold, the gradient will be zero, and it will not receive learning signals. However, note that it does not necessarily mean that a component dies permanently once its importance score is less than the threshold. The component still has a chance to recover because the threshold is adjustable and the importance scores of other components may decrease. Nevertheless, to ensure that the architecture parameters of dropped components continuously receive learning signals, we propose approximating the gradient of the thresholding function. As in [31] where the gradient of a step function was approximated using that of leaky relu or soft plus, we suggest employing elu [4] as a variant of the proposed method: relu is used in the forward pass, but elu is used in the backward pass.
+
+168 This heuristic approach leads to a similar learning mechanism proposed in [30], where the gradient   
+169 flows to dropped (or zeroed out) edges but does not flow through these dropped edges. The architecture   
+170 parameters in our proposed method correspond to the edges in [30]. Note that our approach can   
+171 be easily implemented, and it does not require additional codes to control the gradient flow. The   
+172 implementation codes are shown in the appendix.
+
+# 173 4 Application and Experiment
+
+174 In this section, we show that the proposed approach can be applied to reduce the size of a network as   
+175 well as to learn the structure. Our aim is not to achieve state-of-the-art performance but to validate the   
+176 idea and the broad applicability of the proposed approach. In order to show the broad applicability   
+177 with limited computing resources, we perform experiments with relative small datasets such as   
+178 CIFAR-10/100 [13]. Our implementations closely follow those of baseline models, including model   
+179 structures and hyper-parameter settings.
+
+# 180 4.1 Channel Pruning in Convolutional Network
+
+Table 1: Performance on CIFAR-10, DenseNet-100-BC-K12   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">Sparsity(%)</td><td colspan="2">Top-1 Error(%)</td><td colspan="2">Parmas</td><td colspan="2">FLOPs</td></tr><tr><td>Avg.</td><td>Std.</td><td>Avg.</td><td>Std.</td><td>Avg.</td><td>Std.</td><td>Avg.</td><td>Std.</td></tr><tr><td>Base</td><td>00.0</td><td>0.0</td><td>5.44</td><td>0.11</td><td>7.6×105</td><td>0.0</td><td>5.8×108</td><td>0.0</td></tr><tr><td>NS</td><td>70.0</td><td>0.0</td><td>6.53</td><td>0.19</td><td>2.9×105</td><td>9.3×10²</td><td>1.9×108</td><td>5.0×106</td></tr><tr><td>NS</td><td>80.0</td><td>0.0</td><td>8.39</td><td>0.28</td><td>2.0×105</td><td>2.0×103</td><td>1.4 × 108</td><td>3.4×106</td></tr><tr><td>DS</td><td>70.3</td><td>0.1</td><td>5.77</td><td>0.09</td><td>2.7×105</td><td>2.3×10</td><td>1.8×108</td><td>1.6 ×106</td></tr><tr><td>DS</td><td>80.4</td><td>0.1</td><td>6.64</td><td>0.11</td><td>1.7 × 105</td><td>0.6×103</td><td>1.3×108</td><td>2.0×106</td></tr></table>
+
+181 Network-slimming(NS) [20] prunes unimportant channels in convolutional layers by leveraging the 182 scaling factors in batch normalization. Let $x _ { i }$ and $y _ { i }$ be the input and output of batch normalization 183 for channel $i$ and then the operation can be written as
+
+$$
+\tilde { x } _ { i } = \frac { x _ { i } - \mu _ { i } } { \sqrt { \sigma _ { i } ^ { 2 } + \epsilon } } ; y _ { i } = a _ { i } \tilde { x } _ { i } + b _ { i } ,
+$$
+
+184 where $\mu _ { i }$ and $\sigma _ { i }$ denotes the mean and standard deviation of input activations, $a$ and $b$ are scale   
+185 and shift parameters, $\epsilon$ is a small constant for numerical stability. The scaling parameter $a$ can be   
+186 considered as an importance score or an architecture parameter, and the affine transformation can be   
+187 re-written as
+
+$$
+y _ { i } = a \left( \tilde { x } _ { i } + b _ { i } \right) .
+$$
+
+188 By pushing $a _ { i }$ to be zero, a corresponding channel can be removed. Network-slimming trains an   
+189 initial network with $l _ { 1 }$ -regularization on $a$ to identify insignificant channels. After the training,   
+190 channels with small values of $a$ are pruned. To compensate the damage caused by pruning, a pruned   
+191 network is fine-tuned. In our approach, we parameterize the scaling parameter using Eq. (12) and train   
+192 a network with $l _ { 1 }$ -norm on $a$ using the stochastic gradient descent without pruning and fine-tuning.   
+193 We perform comparison experiments on CIFAR-10/100 [13]. The training and test sets contain   
+194 $5 0 , 0 0 0$ and 10, 000 samples respectively, and the final test error is reported at the end of training or   
+195 fine-tuning on all training images. We adopt a standard data augmentation scheme (random shifting   
+196 and flipping) as in [7, 8]. In network-slimming, $\lambda$ in Eq. 13 is fixed to $1 0 ^ { - 5 }$ , but in our approach   
+197 we vary its value to induce different level of sparsity. DenseNet-BC-K12 with 100 layers [10] and   
+198 ResNet with 164 layers [7, 8] are employed as base networks. In network-slimming, pre-trained   
+199 models are obtained by training networks for 160 epochs with the initial learning of 0.1. The learning   
+200 rate is divided by 10 at $5 0 \%$ and $7 5 \%$ of the total number of training epochs. After the training,   
+201 channels with small values of $a$ are pruned and a slimmed network is fine-turned for another 160   
+202 epochs with the same setting as in the initial training, but learned weights are not re-initialized. In our   
+203 approach, we train networks for 320 epochs without fine-tuning or re-training. Network-slimming   
+204 initializes the scaling factor to be 0.5 and we set $\alpha = 0 . 5 ( n + \bar { 1 } ) / n$ and $\beta = \log \left( n ^ { 2 } + n - 1 \right)$ in   
+205 Eq. 12 so that $a$ starts with 0.5.
+
+Table 1 shows experiment results on CIFAR-10 with DenseNet. More experiments, including ResNet and CIFAR-100, are given in the supplementary materials due to page limitation. The authors strongly urge readers to see the supplementary materials. We ran each experiments 5 times and showed the 9 average and the standard deviation. Our proposed method is denoted by Differentiable Sparsification (DS). We controlled the value of $\lambda$ such that similar pruning rate with that of the network-slimming approach. In the tables, sparsity denotes the number of removed channels in hidden layers. The experiments show that the proposed differentiable approach more effectively learns slimed models.
+
+# 213 4.2 Discovering Neural Wirings
+
+Table 2: Performance on CIFAR-10, Discovering Neural Wirings   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">Top-1 Error(%)</td><td colspan="2">Parmas</td><td colspan="2">Mult-Adds</td></tr><tr><td>Avg.</td><td>Std.</td><td>Avg.</td><td>Std.</td><td>Avg.</td><td>Std.</td></tr><tr><td>MobileNetV1(×0.25)</td><td>13.44</td><td>0.24</td><td>2.2 × 105</td><td>0.0</td><td>3.3× 106</td><td>0.0</td></tr><tr><td>No Update(×0.225)</td><td>13.86</td><td>0.27</td><td>2.2×105</td><td>3.7×101</td><td>4.5×106</td><td>3.7×104</td></tr><tr><td>DNW(×0.225)</td><td>10.30</td><td>0.20</td><td>1.8×105</td><td>6.7×101</td><td>3.1 × 106</td><td>4.6×104</td></tr><tr><td>PG-l1-norm</td><td>12.17</td><td>0.44</td><td>2.1×104</td><td>9.4×10²</td><td>3.3× 106</td><td>1.7× 105</td></tr><tr><td>PG-l1,2-norm</td><td>13.62</td><td>0.56</td><td>9.6×104</td><td>1.6 ×104</td><td>3.4 ×106</td><td>8.6×104</td></tr><tr><td>DS-No Rectified Grad.</td><td>10.55</td><td>0.23</td><td>6.1×104</td><td>5.7×10²</td><td>3.4×106</td><td>4.5×104</td></tr><tr><td>DS-Rectified Grad.</td><td>9.36</td><td>0.27</td><td>4.7×104</td><td>8.4×10²</td><td>3.3× 106</td><td>6.7×104</td></tr></table>
+
+214 Discovering Neural Wirings(DNW) [30] relaxes the notion of layers and treats channels as nodes 215 in a neural graph. By allowing channels to learn connections between them, it jointly discovers the 216 structure and learns the parameters of a neural network. An input to node $v$ , $\mathbf { x } _ { v }$ , is expressed
+
+$$
+\mathbf { y } _ { v } = \sum _ { ( u , v ) \in \mathcal E } w _ { u , v } \mathbf { x } _ { u } ,
+$$
+
+217 where $\mathbf { X } _ { u }$ denotes the state of a proceeding node, $\mathcal { E }$ represents a edge set and $w _ { u , v }$ is a connection   
+218 weight of an edge. The structure of a neural graph can be determined by choosing a subset of edges.   
+219 At each iteration of training, DNW chooses the top $k$ edges with the highest magnitude, which is   
+220 called a real edge set, and refers to the remaining edges as a hallucinated edge set. On the forwards   
+221 pass or at inference time, real edges are only used. As DNW allows the magnitude of the weights   
+222 in both sets to change throughout training, a hallucinated edge may replace a real edge when it   
+223 strengthens enough. The weights of real edges are updated in an ordinary manner with the stochastic   
+224 gradient descent, but those of hallucinated edges are updated by a specialized leaning rule: the   
+225 gradient flows to hallucinated edges but does not flow through them.   
+226 The architecture parameters in our proposed method correspond to the edges in DNW. We parame  
+227 terize the edges using Eq. (12) and train a network with $l _ { 1 }$ -norm on edges to induce sparsity. The   
+228 rectified gradient leads to an update rule which is similar to that of DNW: the rectified gradient   
+229 ensures that dropped architecture parameters continuously receive learning signals by approximating   
+230 the gradient of the thresholding function. However, we do not need to keep track of the real and   
+231 hallucinated edge sets. We simply optimize the objective function with approximated gradients. The   
+232 rectified gradient can be implemented in a couple of lines using modern deep learning tools and the   
+233 code is shown in the supplementary material.   
+234 We perform experiments on CIFAR-10/100 [13]. The final test error is reported at the end of training   
+235 without using separate validation data set. MobileNetV1 $( \times 0 . 2 5 )$ [9] is employed as a base model   
+236 and our implementation closely follows that of DNW. We train for 160 epochs with initial learning   
+237 rate 0.1. The learning rate is scheduled using Cosine Annealing. DNW chose the value of $k$ such that   
+238 a final learned model has similar Mult-Adds with the base model, and we also set the value of $\lambda$ in   
+239 the same manner.
+
+![](images/b8633fb0588a99814e592a6c09111cabc2ee3097de52f50463ab1b4b99f07718.jpg)  
+Figure 1: Left: Structure of a GCN block. Each block consists of a shared adjacency, an input feature, and a weight matrix. Each row and column of an adjacent matrix are treated as groups to enable the learning of relationship between a node (indexed by $i$ ) and its neighbors. Right: Row grouping creates the competition between in-coming nodes, and column grouping creates the competition between out-going nodes.
+
+Table 2 shows experiment results on CIFAR-10. We ran each experiments 5 times and showed the average and the standard deviation. Our proposed method is denoted by DS. DNW without the update rule corresponds to DS without the rectified gradient method. Even without the rectified gradient, the performance of the proposed method is close to that of DNW with the update rule. It validates the effectiveness of our approach. We also performed experiments with the proximal gradients of Eq.(3) and Eq.(7), which is denoted by PG in Table 2. PG-l1-norm also uses the $l _ { 1 }$ -norm as a regularizer, but the learning is not as effective as ours. Similarly, $\mathrm { P G } \mathrm { - } l _ { 1 , 2 }$ -norm uses the update rule of Eq.(7) whose shape is similar to our sparse parameterization Eq. (12), but the performance is worse than ours. More experiments, including CIFAR-100, are given in the supplementary materials due to page limitation.
+
+DNW determines the size and the structure of a network by choosing $k$ edges. However, there is no clear notion how to choose $k$ for different stages (or blocks) and thus it uses the same pruning rate for all stages, which may be restrict because each stage may play a different role and need a different amount of resources. In contrast, our approach controls the model complexity by adjusting the value of $\lambda$ in the objective function, and a different amount of resources is allocated for each stage through training. As shown in Table 2, the proposed method uses model parameters more efficiently.
+
+# 4.3 Learning relationship between Nodes in Graph
+
+In this section, we applied the proposed approach to learn the structure of an adjacency matrix in a graph convolutional network (GCN). The purpose of this case study is to test whether our approach can learn semantic structure from data rather than reducing the size of a neural network.
+
+260 We adopted the model of [11], one of the most successful GCN models. A GCN block or a layer is   
+261 defined (see Fig. 1) as
+
+$$
+H ^ { l + 1 } = F \left( A H ^ { l } W ^ { l } \right) ,
+$$
+
+262 where $A$ is an adjacency matrix; $H ^ { l }$ and $W ^ { l }$ are an input feature and a weight matrix for layer $l$ ,   
+263 respectively; and $F$ is a nonlinear activation function. In general, $A$ is non-negative and shared   
+264 across GCN blocks. It is obtained by normalization. For example, $A = \tilde { D } ^ { - 1 } \tilde { A }$ or $\overset { \mathbf { \tilde { \lambda } } } { A } = \overset { \mathbf { \tilde { \mu } } } { D } ^ { - \frac { 1 } { 2 } } \overset { \mathbf { \tilde { \lambda } } } { A } \overset { \mathbf { \tilde { \mu } } } { D } ^ { - \frac { 1 } { 2 } }$ ,   
+265 where $\tilde { A }$ is an unnormalized adjacency matrix; and $\tilde { D }$ is a diagonal matrix, where $\begin{array} { r } { \tilde { D } _ { i } = \sum _ { j } \tilde { A } _ { i , j } } \end{array}$ .   
+266 The adjacency matrix represents the connections or relationships between nodes on a graph and is   
+267 usually given by prior knowledge. Learning the value of $A _ { i , j }$ amounts to determining the relationship   
+268 between nodes $i$ and $j$ . If the value of $A _ { i , j }$ is zero, it can be considered that the two nodes are   
+269 unrelated.   
+270 As shown in Fig. 1, we defined each row and column as a group. Row grouping creates the competition   
+271 between in-coming nodes, whereas column grouping creates the competition between out-going   
+272 nodes. Each row and column of unnormalized adjacency matrix $\tilde { A }$ can be parameterized similarly as   
+273 in $\tilde { \gamma }$ of in Eq. (10):
+
+![](images/51d38ea1e3fe87b5acd0059170ea3038964ee3255771db31766416a92efc1517.jpg)  
+Figure 2: The gray lines represent 170 road links where the experimental data were collected.
+
+274
+
+$$
+\begin{array} { c } { \gamma _ { i , j } = \exp \left( \alpha _ { i , j } \right) } \\ { \tilde { A } _ { i , j } = \left( \gamma _ { i , j } - \sigma \left( \beta _ { i } ^ { r } \right) \cdot \left. \gamma _ { i , : } \right. _ { 1 } - \sigma \left( \beta _ { j } ^ { c } \right) \cdot \left. \gamma _ { : , j } \right. _ { 1 } \right) _ { + } . } \end{array}
+$$
+
+275 The softmax normalization of Eq. (11) is replaced with Sinkhorn normalization [23, 24, 12] to make   
+276 $A$ is doubly-stochastic: each row and column sum up to 1. Initializing $A$ with $\tilde { A }$ , we can convert $\tilde { A }$   
+277 into a doubly stochastic matrix by iteratively applying the following equations:
+
+$$
+A = D _ { r } ^ { - 1 } A { \mathrm { a n d } } A = A D _ { c } ^ { - 1 } ,
+$$
+
+where 278 $D _ { r }$ and $D _ { c }$ are diagonal matrices; $\begin{array} { r } { [ D _ { r } ] _ { i } = \sum _ { j } A _ { i , j } } \end{array}$ ; $\begin{array} { r } { \left[ D _ { c } \right] _ { j } = \sum _ { i } A _ { i , j } } \end{array}$ . Note that although the 279 normalization is iterative, it is differentiable. Balanced normalization is also possible by iteratively 280 applying
+
+$$
+A = D _ { r } ^ { - { \frac { 1 } { 2 } } } A D _ { c } ^ { - { \frac { 1 } { 2 } } } .
+$$
+
+281 We verified through numerical experiments that iteratively applying the above equation also makes $\tilde { A }$   
+282 to doubly stochastic, but we could not find a theoretical justification. We leave the mathematical proof   
+283 as an open question for a future work. As competition groups are created in row- and column-wise   
+284 approaches, a regularized objective function can be written as
+
+$$
+\mathcal { L } \left( D , W , A \right) + \frac { \lambda } { 2 } \sum _ { i = 1 } ^ { N } \left\{ \mathcal { R } \left( A _ { i , : } \right) + \mathcal { R } \left( A _ { : , i } \right) \right\} ,
+$$
+
+where 285 $W = \{ W ^ { l } \}$ , $N$ is the size of square matrix $A$ , and $A _ { i , }$ : and $A _ { : , i }$ denote ith row and column 286 vector of $A$ , respectively. We employ $l _ { p }$ -norm of Eq. (14) with $p = 0 . 5$ for a regularizer.
+
+287 To validate our purposed method, we applied a GCN to estimate future traffic speeds in a road network.   
+288 The traffic speed data were collected from 170 road segments.Thus, the sizes of an adjacent matrix is   
+289 $1 7 0 \times 1 7 0$ . The map of the data area collected is shown in 2. One-step ahead observation is estimated   
+290 from eight past observations and an output layer generates 170 estimates, one for each road segment.   
+291 A prediction loss is measured using the mean relative error (MRE). More detailed specifications of   
+292 the experimental data and our GCN model can be found in the supplementary material. A prediction   
+293 loss is measured using the mean relative error (MRE).   
+294 Three baseline models were used: two were given the road connectivity and the other was not. For   
+295 the first baseline, we set the value of $A _ { i , j }$ as a constant such that $\begin{array} { r } { A _ { i , j } = \frac { 1 } { n _ { i } } } \end{array}$ if node (or road) $i$ and $j$   
+296 are adjacent to each other $\mathbf { \chi } _ { n _ { i } }$ is the number of neighbors of node $i$ ), and $\mathbf { \nabla } _ { A _ { i , j } } = 0$ otherwise. The   
+297 second baseline was taken in a similar approach, but we set $\tilde { A } _ { i , j } = \exp \left( \alpha _ { i , j } \right)$ if node $i$ and $j$ were   
+298 adjacent to each other to ensure that the strengths of the connections were learned. For the third   
+299 baseline, the connectivity was not given. However, we set $\tilde { A } _ { i , j } = \exp \left( \alpha _ { i , j } \right)$ for all $i , j$ regardless of   
+300 the actual connections. For the proposed method, we parameterized the adjacency matrix as in the   
+301 third baseline but applied the sparsification technique. The balanced normalization was applied to all   
+302 cases except the first baseline, for which the row sum is 1.
+
+303 To measure the learned relationship between nodes, we propose the following scoring function:
+
+$$
+\frac { 1 } { 2 N } \sum _ { i = 1 } ^ { N } \sum _ { j = 1 } ^ { N } \left[ \left( A ^ { r } + A ^ { c } \right) \odot M ^ { k } \right] _ { i , j } ,
+$$
+
+304 where $A ^ { r } = D _ { r } ^ { - 1 } A$ , $A ^ { c } = A D _ { c } ^ { - 1 }$ , $\odot$ denotes the element-wise product, and $[ M ^ { k } ] _ { i , j } = 1$ if the   
+305 geodesic distance between node $i$ and $j$ is less than or equal to $k$ , whereas $[ M ^ { k } ] _ { i , j } = 0$ otherwise.   
+306 The maximum value is 1, and the minimum is 0. For example, the first and second baselines always   
+307 have the maximum value because their adjacency matrices have exactly the same structure of $\dot { M } ^ { 1 }$ .   
+308 We calculated the scores for $k = 1$ and 2. Note that we used $A ^ { r }$ and $A ^ { c }$ instead of $A$ because a   
+309 sparsified matrix is not guaranteed to be doubly stochastic even if the original Sinkhorn normalization   
+310 is adopted.   
+311 The performance of the baseline models is shown in Table 4a. We ran each experiment five times and   
+312 selected the median among the five lowest validation errors. For the first and second baselines, the   
+313 road connectivity is given, and the number of non-zero elements of the adjacent matrices is 878. Note   
+314 that the value of the learned relationship for Baselines I and II is constant, but we show it for reference.   
+315 The road connectivity is not given for the third baseline, and the number of non-zero elements of   
+316 the adjacent matrix is 28, $9 0 0 ( = 1 7 0 \times 1 7 0 )$ . The performance of the proposed model is shown in   
+317 Table 4b. The experiment of Baseline III shows that a GCN finds a nonlinear mapping between input   
+318 and target values simply in the way of reducing the prediction loss without learning the semantic   
+319 relationships between nodes, but the proposed approach finds actual relationships between nodes. We   
+320 further compared the proposed method with the proximal gradient method. The experimental results   
+321 are reported in the supplementary material due to page limitation.
+
+Table 3: Traffic speed prediction with GCN   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">#N.Z.</td><td rowspan="2">MAPE(%)</td><td colspan="2">L.R.(×100)</td></tr><tr><td>k=1</td><td>k=2</td></tr><tr><td>I</td><td>878</td><td>5.6623</td><td>100.00</td><td>100.00</td></tr><tr><td>I</td><td>878</td><td>5.5160</td><td>100.00</td><td>100.00</td></tr><tr><td>Ⅲ</td><td>28.900</td><td>5.6343</td><td>13.76</td><td>20.87</td></tr></table>
+
+(a) Baseline models
+
+<table><tr><td rowspan="2">入</td><td rowspan="2">#N.Z.</td><td rowspan="2">MAPE(%)</td><td colspan="2">L.R.(×100)</td></tr><tr><td>k=1</td><td>k=2</td></tr><tr><td>0.050</td><td>1,220</td><td>5.4744</td><td>87.06</td><td>89.94</td></tr><tr><td>0.075</td><td>1,009</td><td>5.4957</td><td>88.62</td><td>91.39</td></tr><tr><td>0.100</td><td>835</td><td>5.5336</td><td>89.79</td><td>92.13</td></tr></table>
+
+(b) Proposed method
+
+# 322 5 Scope and Limitation
+
+323 Our aim is not to achieve state-of-the-art performance but to validate the idea and the broad applicabil  
+324 ity of the proposed approach. To the authors’ best knowledge, it is the first fully [sub-]differentiable   
+325 sparsification method that zeroes out components, and we wish our work would provide a foundation   
+326 for future structure learning and model compression methods. The limitation of our approach is that   
+327 a sparsity rate cannot be explicitly specified before training as in conventional pruning approaches. If   
+328 a specific sparsity rate is required, it should be obtained by a try-and-error. The rectified gradient is   
+329 effective as shown in the experiments of discovering neural wirings, but it is not clear in which cases   
+330 it is effective or not. We need more theoretical analysis and leave it for a future work.
+
+# 331 6 Conclusion
+
+332 In this study, we proposed a fully differentiable sparsification method that can simultaneously learn   
+333 the sparsified structure and weights of deep neural networks. Our proposed method is versatile in that   
+334 it can be seamlessly integrated into different types of neural networks and various problems.
+
+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] See the scope and limitation section.   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [N/A]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+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] Main Codes are included in the supplemental material and a snippet is also given in the appendix(pdf supplemental material)   
+(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] We ran each experiment five times and gave the mean and the standard deviation.   
+(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)? [No] However, readers may easily estimate required resources because we used well-known data and models in most experiments.
+
+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? [N/A]   
+(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]
+
+# 377 References
+
+[1] Martín Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dandelion Mané, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viégas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Largescale machine learning on heterogeneous systems, 2015. URL https://www.tensorflow. org/. Software available from tensorflow.org.
+
+[2] Karim Ahmed and Lorenzo Torresani. Connectivity learning in multi-branch networks. CoRR, abs/1709.09582, 2017. URL http://arxiv.org/abs/1709.09582. [3] Jose M. Alvarez and Mathieu Salzmann. Learning the number of neurons in deep networks. In NIPS, 2016. [4] Djork-Arné Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network learning by exponential linear units (elus). In ICLR, 2016. [5] Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In ICLR, 2019. [6] Babak Hassibi, David G. Stork, and Gregory J . Wolff. Optimal brain surgeon and general network pruning. In ICNN, 1993. [7] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. [8] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In ECCV, 2016. [9] Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. CoRR, abs/1704.04861, 2017. URL https://arxiv. org/abs/1704.04861. [10] Gao Huang, Zhuang Liu, and Laurens van der Maaten. Densely connected convolutional networks. In CVPR, 2017.   
+07 [11] Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017.   
+09 [12] P. A. Knight. The sinkhorn-knopp algorithm: convergence and applications. SIAM Journal on Matrix Analysis and Applications, 30(1), 2008. [13] Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical Report, 2009.   
+13 [14] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, 2012. [15] Gustav Larsson, Michael Maire, and Gregory Shakhnarovich. Fractalnet: Ultra-deep neural networks without residuals. In ICLR, 2017. [16] Y. LeCun, B. Boser, J. S. Denker, D. Henderson, R. E. Howard, W. Hubbard, and L. D. Jackel. Backpropagation applied to handwritten zip code recognition. Neural Computation, 1(4): 541–551, Dec 1989. ISSN 0899-7667. doi: 10.1162/neco.1989.1.4.541.   
+420 [17] Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In NIPS, 1989.   
+21 [18] Hanxiao Liu, Karen Simonyan, and Yiming Yang. Darts: Differentiable architecture search. In ICLR, 2019.   
+23 [19] Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In ICCV, 2017.   
+425 [20] Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. Rethinking the value of network pruning. In ICLR, 2019.   
+27 [21] Neal Parikh and Stephen Boyd. Proximal algorithms. Found. Trends Optim., 1(3):127–239, January 2014. ISSN 2167-3888. doi: 10.1561/2400000003. URL http://dx.doi.org/10. 1561/2400000003.   
+30 [22] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   
+[23] R. Sinkhorn. A relationship between arbitrary positive matrices and doubly stochastic matrices. The annals of mathematicalstatistics, 35(2):876–879, 1964.   
+[24] R. Sinkhorn and P. Knopp. Concerning nonnegative matrices and doubly stochastic matrices. Pacific Journal of Mathematics, 21(2), 1967.   
+[25] Huizi Mao Song Han and William J. Dally. Deep compression: Compressing deep neural network with pruning, trained quantization and huffman coding. In ICLR, 2016.   
+[26] John Tran Song Han, Jeff Pool and William Dally. Learning both weights and connections for efficient neural network. In NIPS, 2015.   
+[27] Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In CVPR, 2016.   
+[28] Robert Tibshirani. Regression shrinkage and selection via the lasso. Journal of the Royal Statistical Society. Series B (Methodological), 58(1):267–288, 1996.   
+[29] Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In NIPS, 2016.   
+[30] Mitchell Wortsman, Ali Farhadi, and Mohammad Rastegari. Discovering neural wirings. In NeurIPS, 2019.   
+[31] Xia Xiao, Zigeng Wang, and Sanguthevar Rajasekaran. Autoprune: Automatic network pruning by regularizing auxiliary parameters. In NeurIPS, 2019.   
+[32] Saining Xie, Ross Girshick, Piotr Dollar, Zhuowen Tu, and Kaiming He. Aggregated residual transformations for deep neural networks. In CVPR, 2017.   
+[33] Jaehong Yoon and Sung Ju Hwang. Combined group and exclusive sparsity for deep neural networks. In ICML, 2017.   
+[34] Yang Zhou, Rong Jin, and Steven Chu–Hong Hoi. Exclusive lasso for multi-task feature selection. In AISTATS, 2010.

parse/train/_x4A8IZ-rRv/_x4A8IZ-rRv_content_list.json

@@ -0,0 +1,1410 @@
+[
+    {
+        "type": "text",
+        "text": "Differentiable Sparsification for Deep Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            122,
+            823,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            200,
+            580,
+            256
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            292,
+            535,
+            309
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Deep neural networks have relieved the feature engineering burden on human   \n2 experts. However, comparable efforts are instead required to determine an effective   \n3 architecture. In addition, as the sizes of networks have over-grown, a considerable   \n4 amount of resources is also invested in reducing the sizes. The sparsification of an   \n5 over-complete model addresses these problems as it removes redundant parameters   \n6 or connections. In this study, we propose a fully differentiable sparsification   \n7 method for deep neural networks, which allows parameters to be zero during   \n8 training with the stochastic gradient descent. Thus, the proposed method can   \n9 simultaneously learn the sparsified structure and weights of networks in an end  \n10 to-end manner, which can be directly applies to modern deep neural networks   \n11 and imposes minimum overhead to the training process. To the authors’ best   \n12 knowledge, it is the first fully [sub-]differentiable sparsification method that zeroes   \n13 out components, and it provides a foundation for future structure learning and   \n14 model compression methods. ",
+        "bbox": [
+            148,
+            324,
+            766,
+            518
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "15 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            544,
+            312,
+            561
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "16 The success of deep neural networks has changed the paradigm of machine learning and pattern   \n17 recognition from feature engineering to architecture engineering [16, 14, 22, 7, 32]. Although deep   \n18 neural networks have relieved the burden of feature engineering, comparable human efforts are instead   \n19 required to determine an effective architecture, such as the number of neurons or layers and the   \n20 connections between nodes. In addition, as deep neural networks have over-grown (even up to 10–68   \n21 million parameters) [8, 10, 15, 32], considerable effort is also being invested in reducing existing   \n22 model sizes and in meeting the demands of deploying such networks on constrained platforms at   \n23 inference time [26, 25].   \n24 These problems can be addressed by the sparsification of an over-complete model [20]. A network   \n25 structure can be carved out of an over-complete model by removing redundant blocks [3, 29] or   \n26 deleting unnecessary connections between nodes or blocks [2, 18, 30], which also reduces the network   \n27 size. Among several approaches, pruning has long been adapted [17, 6, 26, 19, 5]. It typically requires   \n28 a pre-trained model and several steps (select unimportant parameters of a pre-trained model, delete   \n29 the parameters, and retrain the pruned model) and may repeat the process multiple times. Another   \n30 approach is a sparsity regularizer with the proximal gradient [21, 3, 29, 33] which shrinks redundant   \n31 parameters to zero during training and requires no pre-trained model. Among the most popular ones   \n32 is $l _ { 1 }$ -regularizer [28]. However, as it acts on an individual parameter, it often produces unstructured   \n33 irregular models; thus, it diminishes the benefit of parallel hardware computation, such as GPUs [29].   \n34 In order to obtain regular sparse structures, a sparse regularization with $l _ { 2 }$ -norm [3, 29] was adopted   \n35 on a group of parameters so that all parameters under the same group are either retained or zeroed  \n36 out together. By zeroing-out parameters at a group level, the number of neurons or layers can be   \n37 automatically determined as a part of training. However, the optimization of a regularization term is   \n38 performed as a separate step separately from the gradient descent-based optimization for prediction   \n39 loss. The update rules should be implemented manually and the approach is limited to the cases   \n40 where closed form solutions for the proximal operation are known.   \n41 In this work, we propose a fully [sub-]differentiable sparsification method for deep neural networks,   \n42 which directly optimizes a regularized objective function and allows parameters to be exactly zero   \n43 during training with the stochastic gradient descent. Thus, it can simultaneously learn the sparsified   \n44 structure and weights of deep neural networks in an end-to-end manner. It leads to simpler implemen  \n45 tation and it does not require to manually code a pruning step or an update rule like a soft-thresholding   \n46 operator. It can adopt various norms as a regularizer regardless of whether their closed form solutions   \n47 for the proximal operator are known or not. Another advantage of the proposed method is that it   \n48 can be easily applied on a group of parameters or a building block; thus, it can produce a structured   \n49 model and maximize the benefits of parallel hardware computation (e.g., GPUs) and it well suits the   \n50 trend of a modularized design in deep learning [22, 27, 7, 32]. ",
+        "bbox": [
+            147,
+            575,
+            825,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            694,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            151,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            125,
+            826,
+            265
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "51 2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            155,
+            284,
+            320,
+            300
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Proximal Gradient ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            314,
+            344,
+            329
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our proposed method is related to sparsity regularization with the proximal gradient [21]. A regularized objective function is written as ",
+        "bbox": [
+            161,
+            339,
+            825,
+            367
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/61c2f6e45b9050a68575121d1d07449ece2fc3b8f4fca0e7e3c594d1c612cf5e.jpg",
+        "text": "$$\n\\mathcal { L } \\left( D , W \\right) + \\lambda \\mathcal { R } \\left( W \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            373,
+            575,
+            391
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "55 where $\\mathcal { L }$ denotes a prediction loss, $\\mathcal { R }$ is a regularization term, $D$ is a set of training data, $W$ is a set   \n56 of model parameters, and $\\lambda$ controls the trade-off between prediction loss and model complexity. The   \n57 most popular regularizer is $l _ { 1 }$ -norm, ",
+        "bbox": [
+            147,
+            396,
+            825,
+            439
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bd37b2568b6ba6570ee383644838c3cd7867b1df6d03eb2fb42955fbe0775925.jpg",
+        "text": "$$\n{ \\mathcal { R } } \\left( W \\right) = \\sum _ { i } \\left| w _ { i } \\right| ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            444,
+            562,
+            478
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "58 where $w _ { i }$ is an individual element of $W$ . To optimize the regularization term, parameter updating is   \n59 performed with a proximal operator, ",
+        "bbox": [
+            143,
+            483,
+            826,
+            512
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2909e820c7c69163aafba2e603e6a40d7402b66ce20d4bcc770999c20ef83326.jpg",
+        "text": "$$\nw _ { i }  s i g n ( w _ { i } ) ( | w _ { i } | - \\eta \\lambda ) _ { + } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            517,
+            601,
+            537
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "60 where denotes an assignment operator, $\\eta$ is a learning rate, and $( \\cdot ) _ { + }$ represents $\\operatorname* { m a x } ( \\cdot , 0 )$ . As this   \n61 approach acts on an individual parameter, it often produces unstructured irregular models. In order   \n62 to obtain regular sparse structures, the sparse regularization with $l _ { 2 , 1 }$ -norm can be adopted [3, 29].   \n63 All parameters in the same group are either retained or zeroed-out together. The regularization with   \n64 $l _ { 2 , 1 }$ -norm is written as ",
+        "bbox": [
+            147,
+            542,
+            826,
+            613
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/24a13b498413f65e55d7f376a1d36a6cf37f0eab8ae052bcc61a820ac729e98e.jpg",
+        "text": "$$\n\\mathcal { R } \\left( W \\right) = \\sum _ { g } \\left. \\mathbf { w } _ { g } \\right. _ { 2 } = \\sum _ { g } \\sqrt { \\sum _ { i } w _ { g , i } ^ { 2 } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            612,
+            629,
+            655
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "65 where $W = \\{ \\mathbf { w } _ { g } \\}$ and ${ \\bf w } _ { g }$ represents a group of model parameters. The regularization term is   \n66 optimized with a proximal operator, ",
+        "bbox": [
+            147,
+            657,
+            823,
+            686
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/07508fa72893eba72399716b1c13b5d240038fe97bdfd16a6a319061ca042a31.jpg",
+        "text": "$$\nw _ { g , i } \\gets \\left( \\frac { \\left\\| \\mathbf { w } _ { g } \\right\\| _ { 2 } - \\eta \\lambda } { \\left\\| \\mathbf { w } _ { g } \\right\\| _ { 2 } } \\right) _ { + } w _ { g , i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            691,
+            606,
+            736
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "67 When a group has only one single parameter, it degenerates to the $l _ { 1 }$ -norm regularization. ",
+        "bbox": [
+            151,
+            741,
+            754,
+            756
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "68 Another group regularization is exclusive lasso with $l _ { 1 , 2 }$ -norm [34, 33]. Rather than either retaining   \n69 or removing an entire group altogether, it promotes the competition or sparsity within a group. The   \n70 regularization term is written as ",
+        "bbox": [
+            147,
+            761,
+            825,
+            804
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/df0310446ccd6d289522e167b554fda23a0dee017261c395953a749e5031fdde.jpg",
+        "text": "$$\n\\mathcal { R } \\left( W \\right) = \\frac { 1 } { 2 } \\sum _ { g } \\left. \\mathbf { w } _ { g } \\right. _ { 1 } ^ { 2 } = \\frac { 1 } { 2 } \\sum _ { g } \\left( \\sum _ { i } \\left. w _ { g , i } \\right. \\right) ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            809,
+            660,
+            862
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "71 and its updating rule is derived as ",
+        "bbox": [
+            147,
+            867,
+            397,
+            882
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4625a133e0d1a150bbe71efd2cd8be738bea178ec0e51ddced8e04dc150b4520.jpg",
+        "text": "$$\nw _ { g , i }  s i g n ( w _ { g , i } ) ( | w _ { g , i } | - \\eta \\lambda \\big | \\big | \\mathbf { w } _ { g } \\big | \\big | _ { 1 } ) _ { + } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            887,
+            645,
+            916
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "72 These proximal operators consist of weight decaying and thresholding steps, and they are performed   \n73 at every mini-batch or epoch in a sperate step after the optimization of a prediction loss. It requires   \n74 some extra efforts to implement the update rules manually and applications are limited to the cases   \n75 where closed form solutions for the proximal operator are known. In contrast, our approach optimizes   \n76 a regularized objective function directly and allows parameters to be zero during training with the   \n77 stochastic gradient descent. It leads to simpler implementations and it can employ various norms   \n78 regardless of whether closed form solutions for proximal operators are known or not, for example   \n79 $p$ -norm with $p < 1$ . ",
+        "bbox": [
+            147,
+            92,
+            825,
+            203
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "80 2.2 Differentiable Approach ",
+        "text_level": 1,
+        "bbox": [
+            156,
+            219,
+            382,
+            234
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "81 Similar to our work, previous differentiable approaches [2, 18] learn the structure of a neural   \n82 network by optimizing architecture parameters in a relaxed continuous domain, where architecture   \n83 parameters represent the importance scores of building blocks or the connection strengths between   \n84 them. However, as the architecture parameter magnitudes cannot be zero during training, the   \n85 top $k$ connections or components are stochastically or deterministically selected according to the   \n86 architecture parameter values to derive a discretized architecture. Therefore, the approach may suffer   \n87 from the discrepancy between a learned architecture and a final discretized one. Moreover, the   \n88 value of $k$ should be pre-specified manually; thus, the same value is set for all blocks or modules,   \n89 which may be sub-optimal. Our approach drives the architecture parameters to zero by optimizing a   \n90 regularized objective function. This can minimize the model discrepancy, and a network can choose   \n91 the different numbers of components or connections in each module through training. ",
+        "bbox": [
+            147,
+            246,
+            826,
+            398
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "92 3 Proposed Approach ",
+        "text_level": 1,
+        "bbox": [
+            155,
+            419,
+            370,
+            436
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Base Model ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            450,
+            294,
+            465
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "94 We assume that there are $n$ components in a module. A component can be any building block for a   \n95 deep neural network or its output. For example, it can be a channel or a layer of convolutional neural   \n96 networks such as ResNet [7, 8] and DenseNet layer [10]. It can also represent a node in a neural   \n97 graph [30] or a convolutional neural network [11]. A module represents a composite of components,   \n98 such as a group of channels or nodes. For illustration purposes, we assume that a module $\\mathbf { y }$ can be   \n99 written as the linear combination of components $\\mathbf { f } _ { i }$ : ",
+        "bbox": [
+            148,
+            477,
+            825,
+            560
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a8588624ab66e0b5cc9f70ebc946051903733853d15bc705fba4fd8fdace7b19.jpg",
+        "text": "$$\n\\mathbf { y } \\left( \\mathbf { x } \\right) = \\sum _ { i = 1 } ^ { n } a _ { i } \\mathbf { f } _ { i } \\left( \\mathbf { x } ; \\mathbf { w } _ { i } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            568,
+            578,
+            609
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "100 where $\\mathbf { X }$ denotes a module input, $\\mathbf { w } _ { i }$ model parameters for component $\\mathbf { f } _ { i }$ , and $a _ { i }$ an architecture   \n101 parameter. Model parameters $\\mathbf { w } _ { i }$ denote ordinary parameters, such as a filter in a convolutional layer   \n102 or weight in a fully connected layer. The value of $a _ { i }$ represents the importance of component $i$ , and it   \n103 represents the connection strength between nodes in another context. Enforcing $a _ { i }$ to be zero amounts   \n104 to removing component $\\mathbf { f } _ { i }$ or zeroing-out $\\mathbf { w } _ { i }$ . Thus, by creating the competition between elements of   \n105 $a$ and driving them to be zero, we can eliminate unnecessary components or connections. The sample   \n106 model is simple, but we will show that it can be applied to various cases. ",
+        "bbox": [
+            142,
+            616,
+            825,
+            714
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "107 3.2 Differentiable Sparse Parameterization ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            731,
+            485,
+            746
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "08 First, we show how to parameterize architecture parameters with non-negative constraints, which is   \n09 useful for the attention mechanism with the softmax. To set up the competition between the elements   \n110 of $a$ and allow them to be zero, we parameterize the architecture parameters as follows: ",
+        "bbox": [
+            150,
+            757,
+            825,
+            799
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/21f047a9c3a9fc33dce30ab8bbc69e0d5f8c8593e5a995b92d280665872c7456.jpg",
+        "text": "$$\n\\gamma _ { i } = \\exp \\left( \\alpha _ { i } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            450,
+            808,
+            547,
+            824
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/09656c7a260bde4c53547235019ad09d1ae5eff73a76647d3eeb71b0825d65de.jpg",
+        "text": "$$\n\\tilde { \\gamma } _ { i } = \\left( \\gamma _ { i } - \\sigma \\left( \\beta \\right) \\cdot \\left. \\gamma \\right. _ { 1 } \\right) _ { + }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            845,
+            588,
+            867
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8a8fa70e8ff51f642013c17b1339a23f450080fdf2a753a154c3d91ed48c8d89.jpg",
+        "text": "$$\na _ { i } = \\frac { \\tilde { \\gamma } _ { i } } { \\sum _ { j = 1 } ^ { n } \\tilde { \\gamma } _ { j } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            881,
+            550,
+            916
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "113 where $\\alpha _ { i }$ and $\\beta$ are unconstrained free parameters, $\\sigma ( \\cdot )$ denotes a sigmoid function, and $( \\cdot ) _ { + }$ rep  \n114 resents $r e l u ( \\cdot ) = \\operatorname* { m a x } ( \\cdot , 0 )$ . When a parameter is non-negative, the proximal operator of Eq. (7)   \n115 is reduced to Eq. (10). Although the forms are similar, they have completely different meanings.   \n116 The proximal operator is a learning rule, whereas Eq. (10) is the parameterized form of architecture   \n117 parameters, which is part of a neural network.   \n118 We can easily verify that $a _ { i }$ is allowed to be zero and is also differentiable from a modern deep   \n119 learning perspective. The free parameters $\\alpha _ { i }$ and $\\beta$ are real-valued and they do not restrict a training   \n120 process with the stochastic gradient descent. Thus, we can train $a _ { i }$ through $\\alpha _ { i }$ and $\\beta$ . The exponential   \n121 function in Eq. (9) ensures that the architecture parameters are non-negative. Typically, $a _ { i }$ cannot   \n122 be zero due to the exponential function of Eq. (9). However, $\\tilde { \\gamma } _ { i }$ in Eq. (10) can be zero by the   \n123 thresholding operation; hence, $a _ { i }$ can be zero as well. The term $\\sigma \\left( \\beta \\right) \\cdot \\| \\gamma \\| _ { 1 }$ plays the role of a   \n124 threshold, and the thresholding operation is interpreted as follows: if the strength of component $i$   \n125 in a competition group is small compared to the total strength, it is dropped from the competition.   \n126 Note that the scalar parameter $\\beta$ in Eq. (10), which determines the magnitude of a threshold, is   \n127 not a hyper-parameter, but its value is automatically determined through training. Mathematically,   \n128 the thresholding operator is not differentiable, but this should not pose an issue considering the   \n129 support of relu as a built-in differentiable function in a modern deep learning tool. Additionally, $\\gamma$ is   \n130 non-negative; thus, its $l _ { 1 }$ -norm is simply the sum of $\\gamma _ { i }$ (i.e., $\\| \\gamma \\| _ { 1 } = \\sum \\gamma _ { i } )$ . The softmax of Eq. (11)   \n131 is also differentiable. The softmax is optional but useful when we need to promote the competition   \n132 between components as in the attention mechanism. ",
+        "bbox": [
+            140,
+            90,
+            826,
+            162
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            167,
+            826,
+            376
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "33 By relaxing the differentiability, singed architecture parameter can be similarly formed as ",
+        "bbox": [
+            156,
+            382,
+            759,
+            397
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7e6f7d120cdf2badb3c2d6a44b52a7980378a24cb227b1f89a51a37166e6e4c2.jpg",
+        "text": "$$\na _ { i } = s i g n ( \\alpha _ { i } ) ( | \\alpha _ { i } | - \\sigma ( \\beta ) | | \\alpha | | _ { 1 } ) _ { + } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            397,
+            620,
+            417
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "134 where $\\alpha$ and $\\beta$ are free parameters. The gradient of the sign function is zero almost everywhere, but   \n135 it does not cause a problem for a modern deep learning tool. The equation can be rewritten as ",
+        "bbox": [
+            148,
+            417,
+            825,
+            446
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5de23e486c48520e09e7528ec6df7e2f50ddb8c1ecfc65c1b3b3c32ff6f3542c.jpg",
+        "text": "$$\na _ { i } = \\left\\{ \\begin{array} { l l } { \\left( \\alpha _ { i } + \\sigma \\left( \\beta \\right) \\lVert \\alpha \\rVert _ { 1 } \\right) _ { - } } & { \\mathrm { i f } \\ \\alpha _ { i } < 0 } \\\\ { \\left( \\alpha _ { i } - \\sigma \\left( \\beta \\right) \\lVert \\alpha \\rVert _ { 1 } \\right) _ { + } } & { \\mathrm { o t h e r w i s e } , } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            446,
+            630,
+            496
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "136 where $( \\cdot ) _ { - } = \\operatorname* { m i n } ( \\cdot , 0 )$ . The gradient can be computed separately according to whether its value   \n137 is negative or not. To the authors’ understanding, sign function is already taken care in the ex  \n138 plained manner by TensorFlow [1], and thus $t f . m a t h . s i g n ( )$ can be simply used without the manual   \n139 implementation of the conditional statement. ",
+        "bbox": [
+            142,
+            497,
+            826,
+            553
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 Sparsity Regularizer ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            568,
+            356,
+            583
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "141 In the proposed approach, an objective function is written as ",
+        "bbox": [
+            143,
+            593,
+            571,
+            608
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/83ed1988d32c5deadcb4bde47b5bb1be3c452e9963a2e0ab262520b192b77a4d.jpg",
+        "text": "$$\n\\mathcal { L } \\left( D , W , a \\right) + \\lambda \\mathcal { R } \\left( a \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            609,
+            576,
+            626
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "142 where $a$ denotes the vector of architecture parameters. Sparsifying $a$ is equivalent to sparsifying a   \n143 deep neural network. Therefore, we can use the regularization term on $a$ to encourage the sparsity of   \n144 $a$ . The proposed method is not limited to a particular norm and we can drive different sparsity patterns   \n145 depending on the types of norms. For example, the most popular choice for parameter selection is   \n146 $l _ { 1 }$ -norm, but it is unsuitable on $a$ in Eq. (11) as it is normalized using the softmax. Its $l _ { 1 }$ -norm is   \n147 always 1, i.e., $\\begin{array} { r } { \\| a \\| _ { 1 } = \\sum _ { i = 1 } ^ { n } | a _ { i } | = 1 } \\end{array}$ . Therefore, we should employ $p$ -norm with $p < 1$ : ",
+        "bbox": [
+            147,
+            627,
+            825,
+            712
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ba469137c4d5fca4fcfb863ed18967ebf26f0009c8444364abf97babb41d4e02.jpg",
+        "text": "$$\n\\mathcal { R } \\left( a \\right) = \\left( \\sum _ { i = 1 } ^ { n } \\lvert a _ { i } \\rvert ^ { p } \\right) ^ { \\frac { 1 } { p } } = \\left( \\sum _ { i = 1 } ^ { n } a _ { i } ^ { p } \\right) ^ { \\frac { 1 } { p } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            712,
+            630,
+            766
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "148 where the second equality holds as $a _ { i }$ is always non-negative. To the authors’ best knowledge, a closed   \n149 form solution for the proximal operator of $p$ -norm with $p < 1$ is unknown, but the regularization term   \n150 is differentiable almost everywhere as relu is. Thus, the proposed approach can directly optimize the   \n151 regularized objective function and zero-out components with the stochastic gradient descent.   \n152 By simply switching one norm to another one for a regularizer, different sparsity patterns can be   \n153 derived. For example, an individual component can be removed with $l _ { 1 }$ -norm (Eq. 2) and a group of   \n154 components or an entire module can be zeroed-out with $l _ { 2 , 1 }$ -norm (Eq. 4). Note that we do not need   \n155 to manually implement different updating rules as in the proximal gradient approach. We just need to   \n156 rewrite a regularization term in the objective function. Examples codes and experiment results are   \n157 shown in the supplementary material. ",
+        "bbox": [
+            140,
+            766,
+            825,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            827,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If $\\gamma _ { i }$ Eq. (10) or $\\alpha _ { i }$ in Eq. (12) is less than the threshold, the gradient will be zero, and it will not receive learning signals. However, note that it does not necessarily mean that a component dies permanently once its importance score is less than the threshold. The component still has a chance to recover because the threshold is adjustable and the importance scores of other components may decrease. Nevertheless, to ensure that the architecture parameters of dropped components continuously receive learning signals, we propose approximating the gradient of the thresholding function. As in [31] where the gradient of a step function was approximated using that of leaky relu or soft plus, we suggest employing elu [4] as a variant of the proposed method: relu is used in the forward pass, but elu is used in the backward pass. ",
+        "bbox": [
+            156,
+            116,
+            825,
+            242
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "168 This heuristic approach leads to a similar learning mechanism proposed in [30], where the gradient   \n169 flows to dropped (or zeroed out) edges but does not flow through these dropped edges. The architecture   \n170 parameters in our proposed method correspond to the edges in [30]. Note that our approach can   \n171 be easily implemented, and it does not require additional codes to control the gradient flow. The   \n172 implementation codes are shown in the appendix. ",
+        "bbox": [
+            142,
+            247,
+            825,
+            316
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "173 4 Application and Experiment ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            335,
+            444,
+            353
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "174 In this section, we show that the proposed approach can be applied to reduce the size of a network as   \n175 well as to learn the structure. Our aim is not to achieve state-of-the-art performance but to validate the   \n176 idea and the broad applicability of the proposed approach. In order to show the broad applicability   \n177 with limited computing resources, we perform experiments with relative small datasets such as   \n178 CIFAR-10/100 [13]. Our implementations closely follow those of baseline models, including model   \n179 structures and hyper-parameter settings. ",
+        "bbox": [
+            140,
+            366,
+            825,
+            450
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "180 4.1 Channel Pruning in Convolutional Network ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            464,
+            516,
+            481
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/ee94f93c69c46fcf7049e3ceb0294a49c27aea80dd7be2e3163c0c4dab2ab024.jpg",
+        "table_caption": [
+            "Table 1: Performance on CIFAR-10, DenseNet-100-BC-K12 "
+        ],
+        "table_footnote": [
+            "181 Network-slimming(NS) [20] prunes unimportant channels in convolutional layers by leveraging the 182 scaling factors in batch normalization. Let $x _ { i }$ and $y _ { i }$ be the input and output of batch normalization 183 for channel $i$ and then the operation can be written as "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"2\">Sparsity(%)</td><td colspan=\"2\">Top-1 Error(%)</td><td colspan=\"2\">Parmas</td><td colspan=\"2\">FLOPs</td></tr><tr><td>Avg.</td><td>Std.</td><td>Avg.</td><td>Std.</td><td>Avg.</td><td>Std.</td><td>Avg.</td><td>Std.</td></tr><tr><td>Base</td><td>00.0</td><td>0.0</td><td>5.44</td><td>0.11</td><td>7.6×105</td><td>0.0</td><td>5.8×108</td><td>0.0</td></tr><tr><td>NS</td><td>70.0</td><td>0.0</td><td>6.53</td><td>0.19</td><td>2.9×105</td><td>9.3×10²</td><td>1.9×108</td><td>5.0×106</td></tr><tr><td>NS</td><td>80.0</td><td>0.0</td><td>8.39</td><td>0.28</td><td>2.0×105</td><td>2.0×103</td><td>1.4 × 108</td><td>3.4×106</td></tr><tr><td>DS</td><td>70.3</td><td>0.1</td><td>5.77</td><td>0.09</td><td>2.7×105</td><td>2.3×10</td><td>1.8×108</td><td>1.6 ×106</td></tr><tr><td>DS</td><td>80.4</td><td>0.1</td><td>6.64</td><td>0.11</td><td>1.7 × 105</td><td>0.6×103</td><td>1.3×108</td><td>2.0×106</td></tr></table>",
+        "bbox": [
+            178,
+            517,
+            816,
+            647
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/96dd966a58f85cf006ae04d4763cf0b57a9567e64042394e6a4e9f94ef647c6b.jpg",
+        "text": "$$\n\\tilde { x } _ { i } = \\frac { x _ { i } - \\mu _ { i } } { \\sqrt { \\sigma _ { i } ^ { 2 } + \\epsilon } } ; y _ { i } = a _ { i } \\tilde { x } _ { i } + b _ { i } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            696,
+            606,
+            732
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "184 where $\\mu _ { i }$ and $\\sigma _ { i }$ denotes the mean and standard deviation of input activations, $a$ and $b$ are scale   \n185 and shift parameters, $\\epsilon$ is a small constant for numerical stability. The scaling parameter $a$ can be   \n186 considered as an importance score or an architecture parameter, and the affine transformation can be   \n187 re-written as ",
+        "bbox": [
+            142,
+            734,
+            825,
+            790
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e0737cfcff0631d5ce1c3c2080042b87ab72f5132ba1970931f0b7751e9dea54.jpg",
+        "text": "$$\ny _ { i } = a \\left( \\tilde { x } _ { i } + b _ { i } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            439,
+            789,
+            557,
+            806
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "188 By pushing $a _ { i }$ to be zero, a corresponding channel can be removed. Network-slimming trains an   \n189 initial network with $l _ { 1 }$ -regularization on $a$ to identify insignificant channels. After the training,   \n190 channels with small values of $a$ are pruned. To compensate the damage caused by pruning, a pruned   \n191 network is fine-tuned. In our approach, we parameterize the scaling parameter using Eq. (12) and train   \n192 a network with $l _ { 1 }$ -norm on $a$ using the stochastic gradient descent without pruning and fine-tuning.   \n193 We perform comparison experiments on CIFAR-10/100 [13]. The training and test sets contain   \n194 $5 0 , 0 0 0$ and 10, 000 samples respectively, and the final test error is reported at the end of training or   \n195 fine-tuning on all training images. We adopt a standard data augmentation scheme (random shifting   \n196 and flipping) as in [7, 8]. In network-slimming, $\\lambda$ in Eq. 13 is fixed to $1 0 ^ { - 5 }$ , but in our approach   \n197 we vary its value to induce different level of sparsity. DenseNet-BC-K12 with 100 layers [10] and   \n198 ResNet with 164 layers [7, 8] are employed as base networks. In network-slimming, pre-trained   \n199 models are obtained by training networks for 160 epochs with the initial learning of 0.1. The learning   \n200 rate is divided by 10 at $5 0 \\%$ and $7 5 \\%$ of the total number of training epochs. After the training,   \n201 channels with small values of $a$ are pruned and a slimmed network is fine-turned for another 160   \n202 epochs with the same setting as in the initial training, but learned weights are not re-initialized. In our   \n203 approach, we train networks for 320 epochs without fine-tuning or re-training. Network-slimming   \n204 initializes the scaling factor to be 0.5 and we set $\\alpha = 0 . 5 ( n + \\bar { 1 } ) / n$ and $\\beta = \\log \\left( n ^ { 2 } + n - 1 \\right)$ in   \n205 Eq. 12 so that $a$ starts with 0.5. ",
+        "bbox": [
+            140,
+            808,
+            825,
+            877
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            882,
+            826,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            90,
+            825,
+            243
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows experiment results on CIFAR-10 with DenseNet. More experiments, including ResNet and CIFAR-100, are given in the supplementary materials due to page limitation. The authors strongly urge readers to see the supplementary materials. We ran each experiments 5 times and showed the 9 average and the standard deviation. Our proposed method is denoted by Differentiable Sparsification (DS). We controlled the value of $\\lambda$ such that similar pruning rate with that of the network-slimming approach. In the tables, sparsity denotes the number of removed channels in hidden layers. The experiments show that the proposed differentiable approach more effectively learns slimed models. ",
+        "bbox": [
+            156,
+            250,
+            825,
+            347
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "213 4.2 Discovering Neural Wirings ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            362,
+            406,
+            377
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/991689a48a66458dad1603e4ffb210152acc0f3a622eec4c4f70543296e00515.jpg",
+        "table_caption": [
+            "Table 2: Performance on CIFAR-10, Discovering Neural Wirings "
+        ],
+        "table_footnote": [
+            "214 Discovering Neural Wirings(DNW) [30] relaxes the notion of layers and treats channels as nodes 215 in a neural graph. By allowing channels to learn connections between them, it jointly discovers the 216 structure and learns the parameters of a neural network. An input to node $v$ , $\\mathbf { x } _ { v }$ , is expressed "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"2\">Top-1 Error(%)</td><td colspan=\"2\">Parmas</td><td colspan=\"2\">Mult-Adds</td></tr><tr><td>Avg.</td><td>Std.</td><td>Avg.</td><td>Std.</td><td>Avg.</td><td>Std.</td></tr><tr><td>MobileNetV1(×0.25)</td><td>13.44</td><td>0.24</td><td>2.2 × 105</td><td>0.0</td><td>3.3× 106</td><td>0.0</td></tr><tr><td>No Update(×0.225)</td><td>13.86</td><td>0.27</td><td>2.2×105</td><td>3.7×101</td><td>4.5×106</td><td>3.7×104</td></tr><tr><td>DNW(×0.225)</td><td>10.30</td><td>0.20</td><td>1.8×105</td><td>6.7×101</td><td>3.1 × 106</td><td>4.6×104</td></tr><tr><td>PG-l1-norm</td><td>12.17</td><td>0.44</td><td>2.1×104</td><td>9.4×10²</td><td>3.3× 106</td><td>1.7× 105</td></tr><tr><td>PG-l1,2-norm</td><td>13.62</td><td>0.56</td><td>9.6×104</td><td>1.6 ×104</td><td>3.4 ×106</td><td>8.6×104</td></tr><tr><td>DS-No Rectified Grad.</td><td>10.55</td><td>0.23</td><td>6.1×104</td><td>5.7×10²</td><td>3.4×106</td><td>4.5×104</td></tr><tr><td>DS-Rectified Grad.</td><td>9.36</td><td>0.27</td><td>4.7×104</td><td>8.4×10²</td><td>3.3× 106</td><td>6.7×104</td></tr></table>",
+        "bbox": [
+            184,
+            414,
+            810,
+            577
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/67da417f589f94ca998926f67221113e3533dc09e3116cd9f6bc12e2e76aeb9f.jpg",
+        "text": "$$\n\\mathbf { y } _ { v } = \\sum _ { ( u , v ) \\in \\mathcal E } w _ { u , v } \\mathbf { x } _ { u } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            625,
+            568,
+            660
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "217 where $\\mathbf { X } _ { u }$ denotes the state of a proceeding node, $\\mathcal { E }$ represents a edge set and $w _ { u , v }$ is a connection   \n218 weight of an edge. The structure of a neural graph can be determined by choosing a subset of edges.   \n219 At each iteration of training, DNW chooses the top $k$ edges with the highest magnitude, which is   \n220 called a real edge set, and refers to the remaining edges as a hallucinated edge set. On the forwards   \n221 pass or at inference time, real edges are only used. As DNW allows the magnitude of the weights   \n222 in both sets to change throughout training, a hallucinated edge may replace a real edge when it   \n223 strengthens enough. The weights of real edges are updated in an ordinary manner with the stochastic   \n224 gradient descent, but those of hallucinated edges are updated by a specialized leaning rule: the   \n225 gradient flows to hallucinated edges but does not flow through them.   \n226 The architecture parameters in our proposed method correspond to the edges in DNW. We parame  \n227 terize the edges using Eq. (12) and train a network with $l _ { 1 }$ -norm on edges to induce sparsity. The   \n228 rectified gradient leads to an update rule which is similar to that of DNW: the rectified gradient   \n229 ensures that dropped architecture parameters continuously receive learning signals by approximating   \n230 the gradient of the thresholding function. However, we do not need to keep track of the real and   \n231 hallucinated edge sets. We simply optimize the objective function with approximated gradients. The   \n232 rectified gradient can be implemented in a couple of lines using modern deep learning tools and the   \n233 code is shown in the supplementary material.   \n234 We perform experiments on CIFAR-10/100 [13]. The final test error is reported at the end of training   \n235 without using separate validation data set. MobileNetV1 $( \\times 0 . 2 5 )$ [9] is employed as a base model   \n236 and our implementation closely follows that of DNW. We train for 160 epochs with initial learning   \n237 rate 0.1. The learning rate is scheduled using Cosine Annealing. DNW chose the value of $k$ such that   \n238 a final learned model has similar Mult-Adds with the base model, and we also set the value of $\\lambda$ in   \n239 the same manner. ",
+        "bbox": [
+            142,
+            662,
+            826,
+            691
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            696,
+            825,
+            795
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/b8633fb0588a99814e592a6c09111cabc2ee3097de52f50463ab1b4b99f07718.jpg",
+        "image_caption": [
+            "Figure 1: Left: Structure of a GCN block. Each block consists of a shared adjacency, an input feature, and a weight matrix. Each row and column of an adjacent matrix are treated as groups to enable the learning of relationship between a node (indexed by $i$ ) and its neighbors. Right: Row grouping creates the competition between in-coming nodes, and column grouping creates the competition between out-going nodes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            1,
+            750,
+            210
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            321,
+            825,
+            406
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows experiment results on CIFAR-10. We ran each experiments 5 times and showed the average and the standard deviation. Our proposed method is denoted by DS. DNW without the update rule corresponds to DS without the rectified gradient method. Even without the rectified gradient, the performance of the proposed method is close to that of DNW with the update rule. It validates the effectiveness of our approach. We also performed experiments with the proximal gradients of Eq.(3) and Eq.(7), which is denoted by PG in Table 2. PG-l1-norm also uses the $l _ { 1 }$ -norm as a regularizer, but the learning is not as effective as ours. Similarly, $\\mathrm { P G } \\mathrm { - } l _ { 1 , 2 }$ -norm uses the update rule of Eq.(7) whose shape is similar to our sparse parameterization Eq. (12), but the performance is worse than ours. More experiments, including CIFAR-100, are given in the supplementary materials due to page limitation. ",
+        "bbox": [
+            166,
+            411,
+            825,
+            551
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "DNW determines the size and the structure of a network by choosing $k$ edges. However, there is no clear notion how to choose $k$ for different stages (or blocks) and thus it uses the same pruning rate for all stages, which may be restrict because each stage may play a different role and need a different amount of resources. In contrast, our approach controls the model complexity by adjusting the value of $\\lambda$ in the objective function, and a different amount of resources is allocated for each stage through training. As shown in Table 2, the proposed method uses model parameters more efficiently. ",
+        "bbox": [
+            171,
+            556,
+            825,
+            641
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 Learning relationship between Nodes in Graph ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            659,
+            540,
+            674
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we applied the proposed approach to learn the structure of an adjacency matrix in a graph convolutional network (GCN). The purpose of this case study is to test whether our approach can learn semantic structure from data rather than reducing the size of a neural network. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            727
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "260 We adopted the model of [11], one of the most successful GCN models. A GCN block or a layer is   \n261 defined (see Fig. 1) as ",
+        "bbox": [
+            148,
+            732,
+            826,
+            761
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5ea93fb3501dbf28f9b1e7e6ac9d96bec2d1d9547131570656df76347647f032.jpg",
+        "text": "$$\nH ^ { l + 1 } = F \\left( A H ^ { l } W ^ { l } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            761,
+            576,
+            789
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "262 where $A$ is an adjacency matrix; $H ^ { l }$ and $W ^ { l }$ are an input feature and a weight matrix for layer $l$ ,   \n263 respectively; and $F$ is a nonlinear activation function. In general, $A$ is non-negative and shared   \n264 across GCN blocks. It is obtained by normalization. For example, $A = \\tilde { D } ^ { - 1 } \\tilde { A }$ or $\\overset { \\mathbf { \\tilde { \\lambda } } } { A } = \\overset { \\mathbf { \\tilde { \\mu } } } { D } ^ { - \\frac { 1 } { 2 } } \\overset { \\mathbf { \\tilde { \\lambda } } } { A } \\overset { \\mathbf { \\tilde { \\mu } } } { D } ^ { - \\frac { 1 } { 2 } }$ ,   \n265 where $\\tilde { A }$ is an unnormalized adjacency matrix; and $\\tilde { D }$ is a diagonal matrix, where $\\begin{array} { r } { \\tilde { D } _ { i } = \\sum _ { j } \\tilde { A } _ { i , j } } \\end{array}$ .   \n266 The adjacency matrix represents the connections or relationships between nodes on a graph and is   \n267 usually given by prior knowledge. Learning the value of $A _ { i , j }$ amounts to determining the relationship   \n268 between nodes $i$ and $j$ . If the value of $A _ { i , j }$ is zero, it can be considered that the two nodes are   \n269 unrelated.   \n270 As shown in Fig. 1, we defined each row and column as a group. Row grouping creates the competition   \n271 between in-coming nodes, whereas column grouping creates the competition between out-going   \n272 nodes. Each row and column of unnormalized adjacency matrix $\\tilde { A }$ can be parameterized similarly as   \n273 in $\\tilde { \\gamma }$ of in Eq. (10): ",
+        "bbox": [
+            140,
+            794,
+            826,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/51d38ea1e3fe87b5acd0059170ea3038964ee3255771db31766416a92efc1517.jpg",
+        "image_caption": [
+            "Figure 2: The gray lines represent 170 road links where the experimental data were collected. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            383,
+            88,
+            614,
+            223
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            287,
+            825,
+            345
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "274 ",
+        "bbox": [
+            140,
+            358,
+            161,
+            369
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c8e8948bc6a0176af31365c63357718b60df8bc7831cd615d18e460fe23e70f0.jpg",
+        "text": "$$\n\\begin{array} { c } { \\gamma _ { i , j } = \\exp \\left( \\alpha _ { i , j } \\right) } \\\\ { \\tilde { A } _ { i , j } = \\left( \\gamma _ { i , j } - \\sigma \\left( \\beta _ { i } ^ { r } \\right) \\cdot \\left. \\gamma _ { i , : } \\right. _ { 1 } - \\sigma \\left( \\beta _ { j } ^ { c } \\right) \\cdot \\left. \\gamma _ { : , j } \\right. _ { 1 } \\right) _ { + } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            342,
+            681,
+            404
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "275 The softmax normalization of Eq. (11) is replaced with Sinkhorn normalization [23, 24, 12] to make   \n276 $A$ is doubly-stochastic: each row and column sum up to 1. Initializing $A$ with $\\tilde { A }$ , we can convert $\\tilde { A }$   \n277 into a doubly stochastic matrix by iteratively applying the following equations: ",
+        "bbox": [
+            140,
+            411,
+            823,
+            457
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bed54a440efe11aa11aa39719b23efb88f31f146ffcad4403973452e4b5bb394.jpg",
+        "text": "$$\nA = D _ { r } ^ { - 1 } A { \\mathrm { a n d } } A = A D _ { c } ^ { - 1 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            462,
+            598,
+            481
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where 278 $D _ { r }$ and $D _ { c }$ are diagonal matrices; $\\begin{array} { r } { [ D _ { r } ] _ { i } = \\sum _ { j } A _ { i , j } } \\end{array}$ ; $\\begin{array} { r } { \\left[ D _ { c } \\right] _ { j } = \\sum _ { i } A _ { i , j } } \\end{array}$ . Note that although the 279 normalization is iterative, it is differentiable. Balanced normalization is also possible by iteratively 280 applying ",
+        "bbox": [
+            140,
+            486,
+            825,
+            531
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b9542bf93714573b15e01547f461b66d7a9b9f29b08b887f3292a01834af8f10.jpg",
+        "text": "$$\nA = D _ { r } ^ { - { \\frac { 1 } { 2 } } } A D _ { c } ^ { - { \\frac { 1 } { 2 } } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            437,
+            529,
+            562,
+            551
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "281 We verified through numerical experiments that iteratively applying the above equation also makes $\\tilde { A }$   \n282 to doubly stochastic, but we could not find a theoretical justification. We leave the mathematical proof   \n283 as an open question for a future work. As competition groups are created in row- and column-wise   \n284 approaches, a regularized objective function can be written as ",
+        "bbox": [
+            140,
+            555,
+            825,
+            612
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4096b6ee18a50449710045ad4c7358d9780ab3effcc7dba282712b755aac3c43.jpg",
+        "text": "$$\n\\mathcal { L } \\left( D , W , A \\right) + \\frac { \\lambda } { 2 } \\sum _ { i = 1 } ^ { N } \\left\\{ \\mathcal { R } \\left( A _ { i , : } \\right) + \\mathcal { R } \\left( A _ { : , i } \\right) \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            618,
+            653,
+            662
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where 285 $W = \\{ W ^ { l } \\}$ , $N$ is the size of square matrix $A$ , and $A _ { i , }$ : and $A _ { : , i }$ denote ith row and column 286 vector of $A$ , respectively. We employ $l _ { p }$ -norm of Eq. (14) with $p = 0 . 5$ for a regularizer. ",
+        "bbox": [
+            145,
+            670,
+            823,
+            700
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "287 To validate our purposed method, we applied a GCN to estimate future traffic speeds in a road network.   \n288 The traffic speed data were collected from 170 road segments.Thus, the sizes of an adjacent matrix is   \n289 $1 7 0 \\times 1 7 0$ . The map of the data area collected is shown in 2. One-step ahead observation is estimated   \n290 from eight past observations and an output layer generates 170 estimates, one for each road segment.   \n291 A prediction loss is measured using the mean relative error (MRE). More detailed specifications of   \n292 the experimental data and our GCN model can be found in the supplementary material. A prediction   \n293 loss is measured using the mean relative error (MRE).   \n294 Three baseline models were used: two were given the road connectivity and the other was not. For   \n295 the first baseline, we set the value of $A _ { i , j }$ as a constant such that $\\begin{array} { r } { A _ { i , j } = \\frac { 1 } { n _ { i } } } \\end{array}$ if node (or road) $i$ and $j$   \n296 are adjacent to each other $\\mathbf { \\chi } _ { n _ { i } }$ is the number of neighbors of node $i$ ), and $\\mathbf { \\nabla } _ { A _ { i , j } } = 0$ otherwise. The   \n297 second baseline was taken in a similar approach, but we set $\\tilde { A } _ { i , j } = \\exp \\left( \\alpha _ { i , j } \\right)$ if node $i$ and $j$ were   \n298 adjacent to each other to ensure that the strengths of the connections were learned. For the third   \n299 baseline, the connectivity was not given. However, we set $\\tilde { A } _ { i , j } = \\exp \\left( \\alpha _ { i , j } \\right)$ for all $i , j$ regardless of   \n300 the actual connections. For the proposed method, we parameterized the adjacency matrix as in the   \n301 third baseline but applied the sparsification technique. The balanced normalization was applied to all   \n302 cases except the first baseline, for which the row sum is 1. ",
+        "bbox": [
+            138,
+            704,
+            825,
+            803
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            808,
+            825,
+            912
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "303 To measure the learned relationship between nodes, we propose the following scoring function: ",
+        "bbox": [
+            142,
+            125,
+            797,
+            141
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ec7fef89587600c0fb8063c2a153311481ee402b8fbb52a0c87f73e9683e354a.jpg",
+        "text": "$$\n\\frac { 1 } { 2 N } \\sum _ { i = 1 } ^ { N } \\sum _ { j = 1 } ^ { N } \\left[ \\left( A ^ { r } + A ^ { c } \\right) \\odot M ^ { k } \\right] _ { i , j } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            151,
+            617,
+            196
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "304 where $A ^ { r } = D _ { r } ^ { - 1 } A$ , $A ^ { c } = A D _ { c } ^ { - 1 }$ , $\\odot$ denotes the element-wise product, and $[ M ^ { k } ] _ { i , j } = 1$ if the   \n305 geodesic distance between node $i$ and $j$ is less than or equal to $k$ , whereas $[ M ^ { k } ] _ { i , j } = 0$ otherwise.   \n306 The maximum value is 1, and the minimum is 0. For example, the first and second baselines always   \n307 have the maximum value because their adjacency matrices have exactly the same structure of $\\dot { M } ^ { 1 }$ .   \n308 We calculated the scores for $k = 1$ and 2. Note that we used $A ^ { r }$ and $A ^ { c }$ instead of $A$ because a   \n309 sparsified matrix is not guaranteed to be doubly stochastic even if the original Sinkhorn normalization   \n310 is adopted.   \n311 The performance of the baseline models is shown in Table 4a. We ran each experiment five times and   \n312 selected the median among the five lowest validation errors. For the first and second baselines, the   \n313 road connectivity is given, and the number of non-zero elements of the adjacent matrices is 878. Note   \n314 that the value of the learned relationship for Baselines I and II is constant, but we show it for reference.   \n315 The road connectivity is not given for the third baseline, and the number of non-zero elements of   \n316 the adjacent matrix is 28, $9 0 0 ( = 1 7 0 \\times 1 7 0 )$ . The performance of the proposed model is shown in   \n317 Table 4b. The experiment of Baseline III shows that a GCN finds a nonlinear mapping between input   \n318 and target values simply in the way of reducing the prediction loss without learning the semantic   \n319 relationships between nodes, but the proposed approach finds actual relationships between nodes. We   \n320 further compared the proposed method with the proximal gradient method. The experimental results   \n321 are reported in the supplementary material due to page limitation. ",
+        "bbox": [
+            140,
+            207,
+            826,
+            308
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/cbe994cde07d1c3f848f4771108a974f8c26854745a7f3ed8400b5b633369325.jpg",
+        "table_caption": [
+            "Table 3: Traffic speed prediction with GCN "
+        ],
+        "table_footnote": [
+            "(a) Baseline models "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">#N.Z.</td><td rowspan=\"2\">MAPE(%)</td><td colspan=\"2\">L.R.(×100)</td></tr><tr><td>k=1</td><td>k=2</td></tr><tr><td>I</td><td>878</td><td>5.6623</td><td>100.00</td><td>100.00</td></tr><tr><td>I</td><td>878</td><td>5.5160</td><td>100.00</td><td>100.00</td></tr><tr><td>Ⅲ</td><td>28.900</td><td>5.6343</td><td>13.76</td><td>20.87</td></tr></table>",
+        "bbox": [
+            179,
+            368,
+            504,
+            454
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/4bcb7d8383101349f9139f66a13e3996acc092e0a97d4475c1b7cad79b53d9fe.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(b) Proposed method "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">入</td><td rowspan=\"2\">#N.Z.</td><td rowspan=\"2\">MAPE(%)</td><td colspan=\"2\">L.R.(×100)</td></tr><tr><td>k=1</td><td>k=2</td></tr><tr><td>0.050</td><td>1,220</td><td>5.4744</td><td>87.06</td><td>89.94</td></tr><tr><td>0.075</td><td>1,009</td><td>5.4957</td><td>88.62</td><td>91.39</td></tr><tr><td>0.100</td><td>835</td><td>5.5336</td><td>89.79</td><td>92.13</td></tr></table>",
+        "bbox": [
+            514,
+            368,
+            821,
+            454
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            489,
+            826,
+            643
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "322 5 Scope and Limitation ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            666,
+            383,
+            684
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "323 Our aim is not to achieve state-of-the-art performance but to validate the idea and the broad applicabil  \n324 ity of the proposed approach. To the authors’ best knowledge, it is the first fully [sub-]differentiable   \n325 sparsification method that zeroes out components, and we wish our work would provide a foundation   \n326 for future structure learning and model compression methods. The limitation of our approach is that   \n327 a sparsity rate cannot be explicitly specified before training as in conventional pruning approaches. If   \n328 a specific sparsity rate is required, it should be obtained by a try-and-error. The rectified gradient is   \n329 effective as shown in the experiments of discovering neural wirings, but it is not clear in which cases   \n330 it is effective or not. We need more theoretical analysis and leave it for a future work. ",
+        "bbox": [
+            140,
+            700,
+            826,
+            811
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "331 6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            145,
+            835,
+            299,
+            852
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "332 In this study, we proposed a fully differentiable sparsification method that can simultaneously learn   \n333 the sparsified structure and weights of deep neural networks. Our proposed method is versatile in that   \n334 it can be seamlessly integrated into different types of neural networks and various problems. ",
+        "bbox": [
+            142,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            341,
+            130
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] See the scope and limitation section.   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [N/A] ",
+        "bbox": [
+            238,
+            133,
+            825,
+            237
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            239,
+            493,
+            255
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            236,
+            257,
+            738,
+            289
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            292,
+            393,
+            306
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(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] Main Codes are included in the supplemental material and a snippet is also given in the appendix(pdf supplemental material)   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We ran each experiment five times and gave the mean and the standard deviation.   \n(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)? [No] However, readers may easily estimate required resources because we used well-known data and models in most experiments. ",
+        "bbox": [
+            238,
+            310,
+            825,
+            494
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            210,
+            500,
+            823,
+            513
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [N/A]   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            517,
+            825,
+            636
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            215,
+            638,
+            705,
+            654
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            657,
+            825,
+            744
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "377 References ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            763,
+            267,
+            780
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Martín Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dandelion Mané, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viégas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Largescale machine learning on heterogeneous systems, 2015. URL https://www.tensorflow. org/. Software available from tensorflow.org. ",
+        "bbox": [
+            178,
+            786,
+            826,
+            912
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[2] Karim Ahmed and Lorenzo Torresani. Connectivity learning in multi-branch networks. CoRR, abs/1709.09582, 2017. URL http://arxiv.org/abs/1709.09582. [3] Jose M. Alvarez and Mathieu Salzmann. Learning the number of neurons in deep networks. In NIPS, 2016. [4] Djork-Arné Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network learning by exponential linear units (elus). In ICLR, 2016. [5] Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In ICLR, 2019. [6] Babak Hassibi, David G. Stork, and Gregory J . Wolff. Optimal brain surgeon and general network pruning. In ICNN, 1993. [7] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. [8] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In ECCV, 2016. [9] Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. CoRR, abs/1704.04861, 2017. URL https://arxiv. org/abs/1704.04861. [10] Gao Huang, Zhuang Liu, and Laurens van der Maaten. Densely connected convolutional networks. In CVPR, 2017.   \n07 [11] Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017.   \n09 [12] P. A. Knight. The sinkhorn-knopp algorithm: convergence and applications. SIAM Journal on Matrix Analysis and Applications, 30(1), 2008. [13] Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical Report, 2009.   \n13 [14] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, 2012. [15] Gustav Larsson, Michael Maire, and Gregory Shakhnarovich. Fractalnet: Ultra-deep neural networks without residuals. In ICLR, 2017. [16] Y. LeCun, B. Boser, J. S. Denker, D. Henderson, R. E. Howard, W. Hubbard, and L. D. Jackel. Backpropagation applied to handwritten zip code recognition. Neural Computation, 1(4): 541–551, Dec 1989. ISSN 0899-7667. doi: 10.1162/neco.1989.1.4.541.   \n420 [17] Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In NIPS, 1989.   \n21 [18] Hanxiao Liu, Karen Simonyan, and Yiming Yang. Darts: Differentiable architecture search. In ICLR, 2019.   \n23 [19] Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In ICCV, 2017.   \n425 [20] Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. Rethinking the value of network pruning. In ICLR, 2019.   \n27 [21] Neal Parikh and Stephen Boyd. Proximal algorithms. Found. Trends Optim., 1(3):127–239, January 2014. ISSN 2167-3888. doi: 10.1561/2400000003. URL http://dx.doi.org/10. 1561/2400000003.   \n30 [22] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   \n[23] R. Sinkhorn. A relationship between arbitrary positive matrices and doubly stochastic matrices. The annals of mathematicalstatistics, 35(2):876–879, 1964.   \n[24] R. Sinkhorn and P. Knopp. Concerning nonnegative matrices and doubly stochastic matrices. Pacific Journal of Mathematics, 21(2), 1967.   \n[25] Huizi Mao Song Han and William J. Dally. Deep compression: Compressing deep neural network with pruning, trained quantization and huffman coding. In ICLR, 2016.   \n[26] John Tran Song Han, Jeff Pool and William Dally. Learning both weights and connections for efficient neural network. In NIPS, 2015.   \n[27] Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In CVPR, 2016.   \n[28] Robert Tibshirani. Regression shrinkage and selection via the lasso. Journal of the Royal Statistical Society. Series B (Methodological), 58(1):267–288, 1996.   \n[29] Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In NIPS, 2016.   \n[30] Mitchell Wortsman, Ali Farhadi, and Mohammad Rastegari. Discovering neural wirings. In NeurIPS, 2019.   \n[31] Xia Xiao, Zigeng Wang, and Sanguthevar Rajasekaran. Autoprune: Automatic network pruning by regularizing auxiliary parameters. In NeurIPS, 2019.   \n[32] Saining Xie, Ross Girshick, Piotr Dollar, Zhuowen Tu, and Kaiming He. Aggregated residual transformations for deep neural networks. In CVPR, 2017.   \n[33] Jaehong Yoon and Sung Ju Hwang. Combined group and exclusive sparsity for deep neural networks. In ICML, 2017.   \n[34] Yang Zhou, Rong Jin, and Steven Chu–Hong Hoi. Exclusive lasso for multi-task feature selection. In AISTATS, 2010. ",
+        "bbox": [
+            151,
+            79,
+            828,
+            919
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            166,
+            90,
+            828,
+            553
+        ],
+        "page_idx": 11
+    }
+]

parse/train/ryetZ20ctX/ryetZ20ctX.md

@@ -0,0 +1,318 @@
+# DEFENSIVE QUANTIZATION: WHEN EFFICIENCY MEETS ROBUSTNESS
+
+Ji Lin   
+MIT   
+jilin@mit.edu
+
+Chuang Gan MIT-IBM Watson AI Lab ganchuang@csail.mit.edu
+
+Song Han   
+MIT   
+songhan@mit.edu
+
+# ABSTRACT
+
+Neural network quantization is becoming an industry standard to efficiently deploy deep learning models on hardware platforms, such as CPU, GPU, TPU, and FPGAs. However, we observe that the conventional quantization approaches are vulnerable to adversarial attacks. This paper aims to raise people’s awareness about the security of the quantized models, and we designed a novel quantization methodology to jointly optimize the efficiency and robustness of deep learning models. We first conduct an empirical study to show that vanilla quantization suffers more from adversarial attacks. We observe that the inferior robustness comes from the error amplification effect, where the quantization operation further enlarges the distance caused by amplified noise. Then we propose a novel Defensive Quantization (DQ) method by controlling the Lipschitz constant of the network during quantization, such that the magnitude of the adversarial noise remains non-expansive during inference. Extensive experiments on CIFAR-10 and SVHN datasets demonstrate that our new quantization method can defend neural networks against adversarial examples, and even achieves superior robustness than their fullprecision counterparts, while maintaining the same hardware efficiency as vanilla quantization approaches. As a by-product, DQ can also improve the accuracy of quantized models without adversarial attack.
+
+# 1 INTRODUCTION
+
+Neural network quantization (Han et al., 2015; Zhu et al., 2016; Jacob et al., 2017) is a widely used technique to reduce the computation and memory costs of neural networks, facilitating efficient deployment. It has become an industry standard for deep learning hardware. However, we find that the widely used vanilla quantization approaches suffer from unexpected issues — the quantized model is more vulnerable to adversarial attacks (Figure 1). Adversarial attack is consist of subtle perturbations on the input images that causes the deep learning models to give incorrect labels (Szegedy et al., 2013; Goodfellow et al.). Such perturbations are hardly detectable by human eyes but can easily fool neural networks. Since quantized neural networks are widely deployed in many safety-critical scenarios, e.g., autonomous driving (Amodei et al., 2016), the potential security risks cannot be neglected. The efficiency and latency in such applications are also important, so we need to jointly optimize them.
+
+The fact that quantization leads to inferior adversarial robustness is counter intuitive, as small perturbations should be denoised with low-bit representations. Recent work (Xu et al., 2017) also demonstrates that quantization on input image space , i.e. color bit depth reduction, is quite effective to defend adversarial examples. A natural question then rises, why the quantization operator is yet effective when applied to intermediate DNN layers? We analyze that such issue is caused by the error amplification effect of adversarial perturbation (Liao et al., 2018) — although the magnitude of perturbation on the image is small, it is amplified significantly when passing through deep neural network (see Figure 3b). The deeper the layers are, the more significant such side effect is. Such amplification pushes values into a different quantization bucket, which is undesirable. We conducted empirical experiments to analyze how quantization influences the activation error between clean and adversarial samples (Figure 3a): when the magnitude of the noise is small, activation quantization is capable of reducing the errors by eliminating small perturbations; However, when the magnitude of perturbation is larger than certain threshold, quantization instead amplify the errors, which causes
+
+![](images/3477ecd5b2c43d16b40e89da24dec3e171a08e472afb5ecf20c37178321efd79.jpg)
+
+(a) Quantization preserves the accuracy till 4-5 bits on clean image.
+
+![](images/dc57dfe77e70d9c157083068a6a5416fccbd3d6d2342eea03d00a27b807e59e5.jpg)  
+(b) Quantization no longer preserves the accuracy under adversarial attack (same legend as left).   
+Figure 1. Quantized neural network are more vulnerable to adversarial attack. Quantized models have no loss of accuracy on clean image ${ \geq } 5$ bits), but have significant loss of accuracy under adversarial attack compared to full precision models. Setup: VGG-16 and Wide ResNet on the test set of CIFAR-10 with FGSM attack.
+
+the quantized model to make mistakes. We argue that this is the main reason causing the inferior robustness of the quantized models.
+
+In this paper, we propose Defensive Quantization (DQ) that not only fixes the robustness issue of quantized models, but also turns activation quantization into a defense method that further boosts adversarial robustness. We are inspired by the success of image quantization in improving robustness. Intuitively, it will be possible to defend the attacks with quantization operations if we can keep the magnitude of the perturbation small. However, due to the error amplification effect of gradient based adversarial samples, it is non-trivial to keep the noise at a small scale during inference. Recent works (Cisse et al., 2017; Qian & Wegman, 2018) have attempted to make the network non-expansive by controlling the Lipschitz constant of the network to be smaller than 1, which has smaller variation change in its output than its input. In such case, the input noise will not propagate through the intermediate layers and impact the output, but attenuated. Our method is built on the theory. Defensive quantization not only quantizes feature maps into low-bit representations, but also controls the Lipschitz constant of the network, such that the noise is kept within a small magnitude for all hidden layers. In such case, we keep the noise small, as in the left zone of Figure 3a, quantization can reduce the perturbation error. The produced model with our method enjoys better security and efficiency at the same time.
+
+Experiments show that Defensive Quantization (DQ) offers three unique advantages. First, DQ provides an effective way to boost the robustness of deep learning models while maintains the efficiency. Second, DQ is a generic building block of adversarial defense, which can be combined with other adversarial defense techniques to advance state-of-the-art robustness. Third, our method makes quantization itself easier thanks to the constrained dynamic range.
+
+# 2 BACKGROUND AND RELATED WORK
+
+# 2.1 MODEL QUANTIZATION
+
+Neural network quantization (Han et al., 2015; Rastegari et al., 2016; Zhou et al., 2016; Courbariaux & Bengio, 2016; Zhu et al., 2016)) are widely adopted to enable efficient inference. By quantizing the network into low-bit representation, the inference of network requires less computation and less memory, while still achieves little accuracy degradation on clean images. However, we find that the quantized models suffer from severe security issues — they are more vulnerable against adversarial attacks compared to full-precision models, even when they have the same clean image accuracy. Adversarial perturbation is applied to the input image, thus it is most related to activation quantization (Dhillon et al., 2018). We carry out the rest of the paper using ReLU6 based activation quantization (Howard et al., 2017; Sandler et al., 2018), as it is computationally efficient and is widely adopted by modern frameworks like TensorFlow (Abadi et al., 2016). As illustrated in Figure 2, a quantized convolutional network is composed of several quantized convolution block, each containing a serial of $c o n \nu + B N + R e L U 6 +$ linear quantize operators. As the quantization operator has
+
+![](images/2e86d17f38d0c8264b4025ef957b06a76c9aef6e47037e726148ea0e6cd95bbd.jpg)  
+Figure 2. Defensive quantization with Lipschitz regularization.
+
+0 gradient almost everywhere, we followed common practice to use a STE (Bengio et al., 2013) function $y = x +$ stop gradient[Quantize $( x ) - x ]$ for gradient computation, which also eliminates the obfuscated gradient problem (Athalye et al., 2018).
+
+Our work bridges two domains: model quantization and adversarial defense. Previous work (Galloway et al., 2017) claims binary quantized networks can improve the robustness against some attacks. However, the improvement is not substantial and they used randomized quantization, which is not practical for real deployment (need extra random number generators in hardware). It also causes one of the obfuscated gradient situations (Athalye et al., 2018): stochastic gradients, leading to a false sense of security. Rakin et al. (2018) tries to use quantization as an effective defense method. However, they employed Tanh-based quantization, which is not hardware friendly on fixed-point units due to the large overhead accessing look-up table. Even worse, according to our re-implementation, their method actually leads to severe gradient masking problem (Papernot et al., 2016a) during adversarial training, due to the nature of Tanh function (see A.1 for detail). As a result, the actual robustness of this work under black-box attack has no improvement over full-precision model and is even worse. Therefore, there is no previous work that are conducted under real inference setting to study the quantized robustness for both black-box and white-box. Our work aim to raise people’s awareness about the security of the actual deployed models.
+
+# 2.2 ADVERSARIAL ATTACKS & DEFENSES
+
+Given an image $\mathbf { X }$ , an adversarial attack method tries to find a small perturbation $\pmb { \Delta }$ with constraint $| | \Delta | | \leq \epsilon$ , such that the neural network gives different outputs for $\mathbf { X }$ and $\mathbf { X } ^ { a d v } \triangleq \mathbf { X } + \pmb { \Delta }$ . Here $\epsilon$ is a scalar to constrain the norm of the noise (e.g., $\epsilon = 8$ is commonly used when we represent colors from 0-255), so that the perturbation is hardly visible to human. For this paper we choose to study attacks defined under $| | \cdot | | _ { \infty }$ , where each element of the image can vary at most $\epsilon$ to form an adversary. We introduce several attack and defense methods used in our work in the following sections.
+
+# 2.2.1 ATTACK METHODS
+
+Random Perturbation (Random) Random perturbation attack adds a uniform sampled noise within $[ - \epsilon , \epsilon ]$ to the image, The method has no prior knowledge of the data and the network, thus is considered as the weakest attack method.
+
+Fast Gradient Sign Method (FGSM) & R+FGSM Goodfellow et al. proposed a fast method to calculate the adversarial noise by following the direction of the loss gradient $\nabla _ { \mathbf { X } } L ( \mathbf { X } , y )$ , where $L ( \mathbf { X } , y )$ is the loss function for training (e.g. cross entropy loss). The adversarial samples are computed as:
+
+$$
+{ \bf X } ^ { a d v } = { \bf X } + \epsilon * \mathrm { s i g n } ( \nabla _ { \bf X } { L } ( { \bf X } , y ) )
+$$
+
+As FGSM is an one-step gradient-based method, it can suffer from sharp curvature near the data points, leading a false direction of ascent. Therefore, Tramer et al. (2017) proposes to prepend FGSM \` by a random step to escape the non-smooth vicinity. The new method is called $\mathbf { R } { + } \mathbf { F } \mathbf { G } \mathbf { S } \mathbf { M }$ , defined as follows, for parameters $\epsilon$ and $\epsilon _ { 1 }$ (where $\epsilon _ { 1 } < \epsilon$ ):
+
+$$
+{ \bf X } ^ { a d v } = { \bf X } ^ { \prime } + ( \epsilon - \epsilon _ { 1 } ) * \mathrm { s i g n } ( \nabla _ { \bf X } L ( { \bf X } , y ) ) , \mathrm { w h e r e } { \bf X } ^ { \prime } = { \bf X } + \epsilon _ { 1 } * \mathrm { s i g n } ( \mathcal { N } ( { \bf 0 } ^ { d } , { \bf I } ^ { d } ) ) .
+$$
+
+In our paper, we set $\epsilon _ { 1 } = \epsilon / 2$ following Tramer et al. (2017). \`
+
+Basic Iterative Method (BIM) & Projected Gradient Descend (PGD) Kurakin et al. (2016) suggests a simple yet much stronger variant of FGSM by applying it multiple times iteratively with a
+
+(a) Noise increases with perturbation strength. Quantization makes the slope deeper.
+
+![](images/19cea475a7e4e3a56bd367d0019961f8154bd7f1eb67f498c26a9e9523c87ff5.jpg)  
+(b) With conventional quantization, noise increases with layer index (the amplification effect).
+
+![](images/9493e4488590bc9fdd93d45255b35d302a1d3d742db0ef8a7ff73b17ab1709cb.jpg)
+
+Figure 3. (a) Comparison of the noise introduced by adversarial-attack, with and without quantization. For small perturbation, quantization reduces the noise; for large perturbation, quantization magnifies the noise. (b) The noise amplification effect: the noise is amplified with layer index. Setup: conventional activation quantization for VGG-16, normalized difference of full-precision and low-precision activation.
+
+small step size $\alpha$ . The method is called BIM, defined as:
+
+$$
+\mathbf { X } _ { 0 } ^ { a d v } = \mathbf { X } , \ \mathbf { X } _ { n + 1 } ^ { a d v } = \mathrm { c l i p } _ { \mathbf { X } } ^ { \epsilon } \{ \mathbf { X } _ { n } ^ { a d v } + \alpha \mathrm { s i g n } ( \nabla _ { \mathbf { X } } L ( \mathbf { X } _ { n } ^ { a d v } , y ) ) \} ,
+$$
+
+where $\mathrm { c l i p } _ { \mathbf { X } } ^ { \epsilon }$ means clipping the result image to be within the $\epsilon$ -ball of $\mathbf { X }$ . In (Madry et al., 2017), the BIM is prepended by a random start as in $\mathrm { R + F G S M }$ method. The resulting attack is called PGD, which proves to be a general first-order attack. In our experiments we used PGD for comprehensive experiments as it proves to be one of the strongest attack. Unlike Madry et al. (2017) that uses a fixed $\epsilon$ and $\alpha$ , we follow Kurakin et al. (2016); Song et al. (2017) to use $\alpha = 1$ and number of iterations of $\left\lfloor \operatorname* { m i n } ( \epsilon + 4 , 1 . 2 5 \epsilon ) \right\rfloor$ , so that we can test the model’s robustness under different strength of attacks.
+
+# 2.2.2 DEFENSE METHODS
+
+Current defense methods either preprocess the adversarial samples to denoise the perturbation (Xu et al., 2017; Song et al., 2017; Liao et al., 2018) or making the network itself robust (Warde-Farley & Goodfellow, 2016; Papernot et al., 2016b; Madry et al., 2017; Kurakin et al., 2016; Goodfellow et al.; Tramer et al., 2017). Here we introduced several defense methods related to our experiments. \`
+
+Feature Squeezing $\mathrm { X u }$ et al. (2017) proposes to detect adversarial images by squeezing the input image. Specifically, the image is processed with color depth bit reduction (5 bits for our experiments) and smoothed by a $2 \times 2$ median filter. If the low resolution image is classified differently as the original image, then this image is detected as adversarial.
+
+Adversarial Training Adversarial training (Madry et al., 2017; Kurakin et al., 2016; Goodfellow et al.; Tramer et al., 2017) is currently the strongest method for defense. By augmenting the training set \` with adversarial samples, the network learns to classify adversarial samples correctly. As adversarial Table 3Table 3FGSM can easily lead to gradient masking effect (Papernot et al., 2016a), we study adversarial $\mathrm { R + F G S M }$ 4-Bit Quantized 6-Bit Quantized 8-Bit Quantized Full Precision4-Bit Quantized 6-Bit Quantized 8-Bit Quantized Full Precision as in (Tramer et al., 2017). We also experimented with PGD training (Madry et al., 2017). \`
+
+00 0.46921857947162576 2.0000 0 2.0000 0.332712 2.0000 0 2.0000 0.28962.0000 0.46921857947162 2.0000 0 2.0000 0.332712 2.0000 0 2.0000 0.2896Experiments show that above defense methods can be combined with our DQ method to further   
+000 0.7550861999431432 3.0000 0.6733 3.0000 0.6304687265237110000 3.0000 0.6050 3.0000 0.57743.0000 0.75508619994314 3.0000 0.6733 3.0000 0.6304687265237110000 3.0000 0.6050 3.0000 0.5774improve the robustness. The robustness has been tested under the aforementioned attack methods.
+
+# 000 0.8435416802069752 5.0000 0.7445 5.0000 0.70679410870240300 5.0000 0.6733 5.0000 5.0000 0.8435416802069752 5.0000 0.7445 5.0000 0.70679410870240300 5.0000 0.6733 5.0000 3 C O N V E N T I O NA L N N Q UA N T I Z AT I O N I S N OT RO B U S T
+
+00 1.012114964143164 7.0000 1.005 7.0000 0.9032 7.0000 0.8307 7.0000 0.83257.0000 1.012114964143164 7.0000 1.005 7.0000 0.9032 7.0000 0.8307 7.0000 0.8325Conventional neural network quantization is more vulnerable to adversarial attacks. We experimented 000 0.9862844244360638 8.0000 0.9515 8.0000 0.86693617000095300 8.0000 0.80045166445080300 8.0000 0.7888.0000 0.9862844244360638 8.0000 0.9515 8.0000 0.86693617000095300 8.0000 0.80045166445080300 8.0000 0.788with VGG-16 (Simonyan & Zisserman, 2014) and a Wide ResNet (Zagoruyko & Komodakis, 2016) 00 1.0681920178474003 9.0000 1.0577 9.0000 0.977219 9.0000 0.8388344297226030 9.0000 0.81519.0000 1.0681920178474003 9.0000 1.0577 9.0000 0.977219 9.0000 0.8388344297226030 9.0000 0.8151of depth 28 and width 10 on CIFAR-10 (Krizhevsky & Hinton, 2009) dataset. We followed the 000 1.0993773912484481 10.000 1.1288 10.000 1.023 10.000 0.8246 10.000 0.758810.000 1.0993773912484481 10.000 1.1288 10.000 1.023 10.000 0.8246 10.000 0.7588training protocol as in (Zagoruyko & Komodakis, 2016). Adversarial samples are generated with a 000 1.1090918582426685 11.0000 1.1015 11.0000 11.0000 1.1090918582426685 11.0000 1.1015 11.0000 FGSM (Goodfellow et al.) attacker $\epsilon = 8$ 11.0000 0.8027 11.0000 0.71920199 11.0000 0.8027 11.0000 0.7192) on the entire test set. As in Figure 1, the clean image .00 1.207932074028837 12.00 1.1706 12.00 1.099673 12.00 0.827749 12.00 0.748612.00 1.207932074028837 12.00 1.1706 12.00 1.099673 12.00 0.827749 12.00 0.7486accuracy doesn’t significantly drop until the model is quantized to 4 bits (Figure 1a). However, under .00 1.2888898827224133 13.00 1.1754 13.00 1.097803 13.00 0.829665 13.00 0.7676 13.00 1.2888898827224133 13.00 1.1754 13.00 1.097803 13.00 0.829665 13.00 0.7676 adversarial attack, even with 5-bit quantization, the accuracy drastically decreased by $2 5 . 3 \%$ and $9 . 2 \%$ respectively. Although the full precision model’s accuracy has dropped, the quantized model’s accuracy dropped much harder, showing that the conventional quantization method is not robust. Clean image accuracy used to be the sole figure of merit to evaluate a quantized model. We show that even when the quantized model has no loss of performance on clean images, it can be much more easily fooled compared to full-precision ones, thus raising security concerns.
+
+![](images/a45d501e28e5bec0f019f31e9dc2930c1e74c4210393c9ed002f8d40c281ba44.jpg)  
+Figure 4. The error amplification effect prevents activation quantization from defending adversarial attacks.
+
+Input image quantization, i.e., color bit depth reduction is an effective defense method ( $\mathrm { { X u } }$ et al., 2017). Counter intuitively, it does not work when applied to hidden layers, and even make the robustness worse. To understand the reason, we studied the effect of quantization w.r.t. different perturbation strength. We first randomly sample 128 images $\mathbf { X }$ from the test set of CIFAR-10, and generate corresponding adversarial samples $\mathbf { X } ^ { a d v }$ . The samples are then fed to the trained Wide ResNet model. To mimic different strength of activation perturbation, we vary the $\epsilon$ from 1 to 8. We inspected the activation after the first convolutional layer $f _ { 1 }$ $\mathrm { C o n v } + \mathrm { B N } + \mathrm { R e L U } 6 )$ , denoted as $\mathbf { A } _ { 1 } \ { \overset { \mathbf { \Gamma } } { = } } \ f _ { 1 } ( \mathbf { X } )$ and ${ \bf A } _ { 1 } ^ { a d v } = f _ { 1 } ( { \bf A } ^ { a d v } )$ . To measure the influence of perturbation, we define a normalized distance between clean and perturbed activation as:
+
+$$
+D ( \mathbf { A } , \mathbf { A } ^ { a d v } ) = | | \mathbf { A } - \mathbf { A } ^ { a d v } | | _ { 2 } / | | \mathbf { A } | | _ { 2 }
+$$
+
+We compare $D ( \mathbf { A } , \mathbf { A } ^ { a d v } )$ and $D ( { \mathrm { Q u a n t i z e } } ( \mathbf { A } ) , { \mathrm { Q u a n t i z e } } ( \mathbf { A } ^ { a d v } ) )$ , where Quantize indicates uniform quantization with 3 bits. The results are shown in Figure 3a. We can see that only when $\epsilon$ is small, quantization helps to reduce the distance by removing small magnitude perturbations. The distance will be enlarged when $\epsilon$ is larger than 3.
+
+The above experiment explains the inferior robustness of the quantized model. We argue that such issue arises from the error amplification effect (Liao et al., 2018), where the relative perturbed distance will be amplified when the adversarial samples are fed through the network. As illustrated in Figure 4, the perturbation applied to the input image has very small magnitude compared to the image itself $\pm 8$ versus $0 - 2 5 5$ ), corresponding to the left zone of Figure 3a (desired), where quantization helps to denoise the perturbation. Nevertheless, the difference in activation is amplified as the inference carries on. If the perturbation after amplification is large enough, the situation corresponds to the right zone (actual) of Figure 3a, where quantization further increases the normalized distance. Such phenomenon is also observed in the quantized VGG-16. We plot the normalized distance of each convolutional layer’s input in Figure 3b. The fewer bits in the quantized model, the more severe the amplification effect.
+
+# 4 DEFENSIVE QUANTIZATION
+
+Given the robustness limitation of conventional quantization technique, we propose Defensive Quantization (DQ) to defend the adversarial examples for quantized models. DQ suppresses the noise amplification effect, keeping the magnitude of the noise small, so that we can arrive at the left zone (Figure 3a, desired) where quantization helps robustness instead of making it worse.
+
+We control the neural network’s Lipschitz constant (Szegedy et al., 2013; Bartlett et al., 2017; Cisse et al., 2017) to suppress network’s amplification effect. Lipschitz constant describes: when input changes, how much does the output change correspondingly. For a function $f : X \to Y$ , if it satisfies
+
+$$
+D _ { Y } ( f ( x _ { 1 } ) , f ( x _ { 2 } ) ) \leq k D _ { X } ( x _ { 1 } , x _ { 2 } ) , \ \forall x _ { 1 } , x _ { 2 } \in X
+$$
+
+for a real-valued $k \geq 0$ and some metrics $D _ { X }$ and $D _ { Y }$ , then we call $f$ Lipschitz continuous and $k$ is the known as the Lipschitz constant of $f$ . If we consider a network $f$ with clean inputs $x _ { 1 } = \mathbf { X }$ and corresponding adversarial inputs $x _ { 2 } = \mathbf { X } _ { a d v }$ , the error amplification effect can be controlled if we
+
+Table 1. The clean and adversarial accuracy of Wide ResNet on CIFAR-10 test set. We compare the accuracy of full-precision and quantized models. With our DQ method, we not only eliminate the robustness gap between full-precision and quantized models, but also improve the robustness over full-precision ones. The accuracy gain from quantization compared to the full-precision model (Quantize Gain) has gradually been improved as $\beta$ increases. Bold and underline numbers are the first and second highest accuracy at each row.   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Acc.</td><td rowspan="2">Full Prec.</td><td colspan="5">Quantize Bit</td><td rowspan="2">Quantize Gain</td><td rowspan="2">Best Acc.</td></tr><tr><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td></tr><tr><td rowspan="2">Vanilla</td><td>clean</td><td>94.8</td><td>42.0</td><td>84.9</td><td>92.8</td><td>93.9</td><td>94.7</td><td rowspan="2">-9.1</td><td rowspan="2">39.3</td></tr><tr><td>adv.</td><td>39.3</td><td>9.0</td><td>8.5</td><td>14.1</td><td>19.0</td><td>30.2</td></tr><tr><td rowspan="2">DQ (β =3e-4)</td><td>clean</td><td>95.3</td><td>95.2</td><td>95.3</td><td>95.1</td><td>95.1</td><td>95.1</td><td rowspan="2">+1.4</td><td rowspan="2">43.2</td></tr><tr><td>adv.</td><td>41.8</td><td>43.2</td><td>41.1</td><td>40.1</td><td>39.8</td><td>39.3</td></tr><tr><td rowspan="2">DQ (β =6e-4)</td><td>clean</td><td>95.6</td><td>95.7</td><td>95.2</td><td>95.4</td><td>95.6</td><td>95.5</td><td rowspan="2">+2.6</td><td rowspan="2">48.3</td></tr><tr><td>adv.</td><td>45.7</td><td>48.3</td><td>47.9</td><td>43.8</td><td>43.9</td><td>44.6</td></tr><tr><td rowspan="2">DQ (β =1e-3)</td><td>clean</td><td>95.9</td><td>95.8</td><td>95.6</td><td>95.6</td><td>95.8</td><td>95.8</td><td rowspan="2">+2.7</td><td rowspan="2">51.8</td></tr><tr><td>adv.</td><td>49.1</td><td>51.3</td><td>50.4</td><td>51.3</td><td>49.8</td><td>51.8</td></tr></table>
+
+have a small Lipschitz constant $k$ (in optimal situation we can have $k \leq 1$ ). In such case, the error introduced by adversarial perturbation will not be amplified, but reduced. Specifically, we consider a feed-forward network composed of a serial of functions:
+
+$$
+f ( x ) = ( \phi _ { l } \circ \phi _ { l - 1 } \circ \ldots \circ \phi _ { 1 } ) ( x )
+$$
+
+where $\phi _ { i }$ can be a linear layer, convolutional layer, pooling, activation functions, etc. Denote the Lipschitz constant of a function $f$ as $L i p ( f )$ , then for the above network we have
+
+$$
+L i p ( f ) \leq \prod _ { i = 1 } ^ { L } L i p ( \phi _ { i } )
+$$
+
+As the Lipschitz constant of the network is the product of its individual layers’ Lipschitz constants, $L i p ( f )$ can grow exponentially if $L i p ( \phi _ { i } ) > 1$ . This is the common case for normal network training (Cisse et al., 2017), and thus the perturbation will be amplified for such a network. Therefore, to keep the Lipschitz constant of the whole network small, we need to keep the Lipschitz constant of each layer $L i p ( \phi _ { i } ) \leq 1$ . We call a network with $L i p ( \phi _ { i } ) \le 1 , \forall i = 1 , . . . , L$ a non-expansive network.
+
+We describe a regularization term to keep the Lipschitz constant small. Let us first consider linear layers with weight $\mathbf { W } \in \mathbb { R } ^ { c _ { o u t } \times c _ { i n } }$ under $| | \cdot | | _ { 2 }$ norm. The Lipschitz constant is by definition the spectral norm of $W$ : $\rho ( \mathbf { W } )$ , i.e., the maximum singular value of W. Computing the singular values of each weight matrix is not computationally feasible during training. Luckily, if we can keep the weight matrix row orthogonal, the singular values are by nature equal to 1, which meets our non-expansive requirements. Therefore we transform the problem of keeping $\rho ( \mathbf { W } ) \leq 1$ into keeping $\mathbf { W } ^ { \hat { T } } \mathbf { W } \approx \mathbf { I }$ , where $\mathbf { I }$ is the identity matrix. Naturally, we introduce a regularization term $| | \mathbf { W } ^ { \hat { T } } \mathbf { \check { W } } - \mathbf { I } | |$ , where $I$ is the identity matrix. Following (Cisse et al., 2017), for convolutional layers with weight $\mathbf { W } \in \mathbb { R } ^ { c _ { o u t } \times c _ { i n } \times k \times k }$ , we can view it as a two-dimension matrix of shape $\dot { \mathbf { W } } \in \mathbb { R } ^ { c _ { o u t } \times ( c _ { i n } \bar { k } k ) }$ and apply the same regularization. The final optimization objective is:
+
+$$
+\mathcal { L } = \mathcal { L } _ { C E } + \frac { \beta } { 2 } \sum _ { \mathbf { W } _ { l } \in \mathbb { W } } | | \mathbf { W } _ { l } ^ { T } \mathbf { W } _ { l } - \mathbf { I } | | ^ { 2 }
+$$
+
+where $\mathcal { L } _ { C E }$ is the original cross entropy loss and $\mathbb { W }$ denotes all the weight matrices of the neural network. $\beta$ is the weighting to adjust the relative importance. The above discussion is based on simple feed forward networks. For ResNets in our experiments, we also follow Cisse et al. (2017) to modify the aggregation layer as a convex combination of their inputs, where the 2 coefficients are updated using specific projection algorithm (see (Cisse et al., 2017) for details).
+
+Our Defensive Quantization is illustrated in Figure 2. The key part is the regularization term, which suppress the noise amplification effect by regularizing the Lipschitz constant. As a result, the perturbation at each layer is kept within a certain range, the adversarial noise won’t propagate. Our method not only fixes the drop of robustness induced by quantization, but also takes quantization as a defense method to further increase the robustness. Therefore it’s named Defensive Quantization.
+
+![](images/7d1866fcf015dc1809459d67bc48aaa2fbaefc65c09b355642a345cc822367f9.jpg)  
+Figure 5. The white-box and black-box robustness are consistent: vanilla quantization leads to significant robustness drop, while DQ can bridge the gap and improve the robustness, especially with lower bits $( \mathrm { b i t } { = } 1 )$ ). Setup: white-box and black-box robustness of Wide ResNet with vanilla quantization and defensive quantization.
+
+# 5 EXPERIMENTS
+
+Our experiments demonstrate the following advantages of Defensive Quantization. First, DQ can retain the robustness of a model when quantized with low-bit. Second, DQ is a general and effective defense method under various scenarios, thus can be combined with other defensive techniques to further advance state-of-the-art robustness. Third, as a by-product, DQ can also improve the accuracy of training quantized models on clean images without attacks, since it limits the dynamic range.
+
+# 5.1 FIXING ROBUSTNESS DROP
+
+Setup: We conduct experiments with Wide ResNet (Zagoruyko & Komodakis, 2016) of $2 8 \times 1 0$ on the CIFAR-10 dataset (Krizhevsky & Hinton, 2009) using ReLU6 based activation quantization, with number of bits ranging from 1 to 5. All the models are trained following (Zagoruyko & Komodakis, 2016) with momentum SGD for 200 epochs. The adversarial samples are generated using FGSM attacker with $\epsilon = 8$ .
+
+Result: The results are presented in Table 1. For vanilla models, though the adversarial robustness increases with the number of bits, i.e., the models closer to full-precision one has better robustness, the best quantized model still has inferior robustness by $- 9 . 1 \%$ . While with our Defensive Quantization, the quantized models have better robustness than full-precision counterparts. The robustness is better when the number of bits are small, since it can de-noise larger adversarial perturbations. We also find that the robustness is generally increasing as $\beta$ gets larger, since the regularization of Lipschitz constant itself keeps the noise smaller at later layers. At the same time, the quantized models consistently achieve better robustness. The robustness of quantized model also increases with $\beta$ . We conduct a detailed analysis of the effect of $\beta$ in Section B. The conclusion is: (1) conventional quantized models are less robust. (2) Lipschitz regularization makes the model robust. (3) Lipschitz regularization $^ +$ quantization makes model even more robust.
+
+As shown in (Athalye et al., 2018), many of the defense methods actually lead to obfuscated gradient, providing a false sense of security. Therefore it is important to check the model’s robustness under black-box attack. We separately trained a substitute VGG-16 model on the same dataset to generate adversarial samples, as it was proved to have the best transferability (Su et al., 2018). The results are presented in Figure 5. Trends of white-box and black-box attack are consistent. Vanilla quantization leads to inferior black-box robustness, while with our method can further improve the models’ robustness. As the robustness gain is consistent for both white-box and black-box setting, our method does not suffer from gradient masking.
+
+# 5.2 DEFEND WITH DEFENSIVE QUANTIZATION
+
+In this section, we show that we can combine Defensive Quantization with other defense techniques to achieve state-of-the-art robustness.
+
+Table 2. SVHN experiments tested with $\epsilon = 2 / 8 / 1 6$ . (B) indicates black-box attack.   
+
+<table><tr><td>Training Technique</td><td>Clean</td><td>Random</td><td>FGSM</td><td>R+FGSM</td><td>PGD</td><td>FGSM(B)</td><td>PGD(B)</td></tr><tr><td>Normal</td><td>96.8</td><td>97/97/96</td><td>74/42/26</td><td>86/55/35</td><td>77/05/00</td><td>90/62/40</td><td>92/58/30</td></tr><tr><td>Normal + DQ</td><td>96.7</td><td>96/96/96</td><td>77/45/31</td><td>87/59/40</td><td>79/10/00</td><td>90/63/42</td><td>92/60/31</td></tr><tr><td>Feature Squeezing</td><td>96.3</td><td>96/96/95</td><td>69/34/20</td><td>84/48/28</td><td>72/03/00</td><td>89/61/38</td><td>91/56/27</td></tr><tr><td>Feature Squeezing + DQ</td><td>96.2</td><td>96/96/96</td><td>75/42/28</td><td>86/56/36</td><td>77/06/00</td><td>90/63/40</td><td>92/59/30</td></tr><tr><td>Adversarial R+FGSM</td><td>96.6</td><td>97/96/96</td><td>84/53/38</td><td>91/70/57</td><td>87/30/06</td><td>93/74/54</td><td>94/83/72</td></tr><tr><td>Adversarial R+FGSM+DQ</td><td>96.6</td><td>97/96/95</td><td>88/59/40</td><td>93/77/61</td><td>91/47/17</td><td>94/80/61</td><td>95/89/84</td></tr></table>
+
+Setup: We conducted experiments on the Street View House Number dataset (SVHN) (Netzer et al., 2011) and CIFAR-10 dataset (Krizhevsky & Hinton, 2009). Since adversarial training is time consuming, we only use the official training set for experiments. CIFAR-10 is another widely used dataset containing 50,000 training samples and 10,000 testing samples of size $3 2 \times 3 2$ . For both datasets, we divide the pixel values by 255 as a pre-processing step.
+
+Following (Athalye et al., 2018; Cisse et al., 2017; Madry et al., 2017), we used Wide ResNet (Zagoruyko & Komodakis, 2016) models in our experiments as it is considered as the standard model on the dataset. We used depth 28 and widening factor 10 for CIFAR-10, and depth 16 and widening factor 4 for SVHN. We followed the training protocol in (Zagoruyko & Komodakis, 2016) that uses a SGD optimizer with momentum $_ { 1 = 0 . 9 }$ . For CIFAR-10, the model is trained for 200 epochs with initial learning rate 0.1, decayed by a factor of 0.2 at 60, 120 and 160 epochs. For SVHN dataset, the model is trained for 160 epochs, with initial learning rate 0.01, decayed by 0.1 at 80 and 120 epochs. For DQ, we used bi $\mathrm { = } 1$ and $\beta = 2 \mathrm { e } { - 3 }$ as it offers the best robustness (see Section B).
+
+We combine DQ with other defense methods to further boost the robustness. For Feature Squeezing (Xu et al., 2017), we used 5 bit for image color reduction, followed by a $2 \times 2$ median filter. As adversarial FGSM training leads to gradient masking issue (Tramer et al., 2017) (see A.2 for our \` experiment), we used the variant adversarial $\mathrm { R + F G S M }$ training. To avoid over-fitting into certain $\epsilon$ , we randomly sample $\epsilon$ using $\epsilon ^ { \prime } \sim \mathcal { N } ( 0 , \delta ) , \epsilon = \mathrm { c l i p } ^ { [ 0 , 2 \delta ] } ( \mathrm { a b s } ( \epsilon ^ { \prime } ) )$ . Specifically we used $\delta = 8$ to cover $\epsilon$ from 0-16. During test time, the $\epsilon$ is set to a fixed value (2/8/16). We also conducted adversarial PGD training. Following (Kurakin et al., 2016; Song et al., 2017), during training we sample random $\epsilon$ as in $\mathrm { R + F G S M }$ setting, and generate adversarial samples using step size 1 and number of iterations $\left\lfloor \operatorname* { m i n } ( \epsilon + 4 , 1 . 2 5 \epsilon ) \right\rfloor$ .
+
+Result: The results are presented in Table 2 and Table 3, where $\mathbf { ( B ) }$ indicates black-box attack with a seperately trained VGG-16 model. The bold number indicates the best result in its column. We observe that for all normal training, feature squeezing and adversarial training settings, our DQ method can further improve the model’s robustness. Among all the defenses, adversarial training provides the best performance against various attacks, epecially adversarial $\mathrm { R + F G S M }$ training. While white box PGD attack is generally the strongest attack in our experiments. Our DQ method also consistently improves the black-box robustness and there is no sign of gradient masking. Thus DQ proves to be an effective defense for various white-box and black-box attacks.
+
+# 5.3 IMPROVE THE TRAINING OF QUANTIZED MODELS
+
+As a by-product of our method, Defensive Quantization can even improve the accuracy of quantized models on clean images without attack, making it a beneficial drop-in substitute for normal quantization procedures. Due to conventional quantization method’s amplification effect, the distribution of activation can step over the truncation boundary (0-6 for ReLU6, 0-1 for ReLU1), which makes the optimization difficult. DQ explicitly add a regularization to shrink the dynamic range of activation, so that it is fitted within the truncation range. To demonstrate our hypothesis, we experimented with ResNet and CIFAR-10. We quantized the activation with 4-bit (because NVIDIA recently introduced INT4 in Turing architecture) using ReLU6 and ReLU1 respectively. Vanilla quantization and DQ training are conducted for comparison. As shown in Table 4, with vanilla quantization, ReLU1 model has around $1 \%$ worse accuracy than ReLU6 model, although they are mathematically equal if we multiply the previous BN scaling by 1/6 and next convolution weight by 6. It demonstrates that improper truncation function and range will lead to training difficulty. While with DQ training, both model has improved accuracy compared to vanilla quantization, and the gap between ReLU1 model and ReLU6 model is filled, making quantization easier regardless of truncation range.
+
+Table 3. CIFAR-10 Experiments tested with $\epsilon = 2 / 8 / 1 6$ . (B) indicates black-box attack.   
+
+<table><tr><td>Training Technique</td><td>Clean</td><td>Random</td><td>FGSM</td><td>R+FGSM</td><td>PGD</td><td>FGSM(B)</td><td>PGD(B)</td></tr><tr><td>Normal</td><td>94.8</td><td>95/91/77</td><td>59/39/29</td><td>72/37/17</td><td>56/01/00</td><td>88/63/36</td><td>90/64/42</td></tr><tr><td>Normal + DQ</td><td>95.9</td><td>96/94/84</td><td>68/53/42</td><td>77/50/30</td><td>62/04/00</td><td>84/59/40</td><td>87/50/27</td></tr><tr><td>Feature Squeezing</td><td>94.1</td><td>94/92/81</td><td>61/35/27</td><td>76/40/21</td><td>64/02/00</td><td>87/62/30</td><td>89/70/42</td></tr><tr><td>Feature Squeezing + DQ</td><td>94.9</td><td>95/93/82</td><td>66/48/33</td><td>77/51/29</td><td>66/06/01</td><td>87/62/29</td><td>90/70/43</td></tr><tr><td>Adversarial R+FGSM</td><td>91.6</td><td>92/91/91</td><td>81/52/38</td><td>87/69/48</td><td>84/43/11</td><td>92/89/85</td><td>92/91/89</td></tr><tr><td>Adversarial R+FGSM+DQ</td><td>94.0</td><td>94/93/93</td><td>85/63/51</td><td>90/74/58</td><td>87/50/22</td><td>93/91/87</td><td>94/92/92</td></tr><tr><td>Adversarial PGD</td><td>86.6</td><td>86/86/86</td><td>74/46/31</td><td>79/63/46</td><td>76/44/20</td><td>84/83/81</td><td>84/83/83</td></tr><tr><td>Adversarial PGD + DQ</td><td>87.5</td><td>87/87/87</td><td>79/53/36</td><td>83/69/52</td><td>81/50/22</td><td>87786/82</td><td>87/86/86</td></tr></table>
+
+Table 4. DQ method improves the training of normal quantized models by limiting the dynamic range of activation. With conventional quantization, ReLU1 suffers from inferior performance than ReLU6. While with DQ, the gap is fixed, ReLU1 and ReLU6 quantized models achieve similar accuracy.   
+
+<table><tr><td></td><td>ReLU1</td><td>ReLU6</td><td>Difference</td></tr><tr><td>Vanilla Quantization</td><td>93.49%</td><td>94.41%</td><td>-0.92%</td></tr><tr><td>Defensive Quantization</td><td>95.14%</td><td>95.09%</td><td>0.05%</td></tr></table>
+
+# 6 CONCLUSION
+
+In this work, we aim to raise people’s awareness about the security of the quantized neural networks, which is widely deployed in GPU/TPU/FPGAs, and pave a possible direction to bridge two important areas in deep learning: efficiency and robustness. We connect these two domains by designing a novel Defensive Quantization (DQ) module to defend adversarial attacks while maintain the efficiency. Experimental results on two datasets validate that the new quantization method can make the deep learning models be safely deployed on mobile devices.
+
+# ACKNOWLEDGMENTS
+
+We acknowledge Google and Amazon providing us the cloud computing resources.
+
+REFERENCES
+
+Mart´ın Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. Tensorflow: a system for large-scale machine learning. In OSDI, volume 16, pp. 265–283, 2016.
+
+Dario Amodei, Chris Olah, Jacob Steinhardt, Paul Christiano, John Schulman, and Dan Mane.´ Concrete problems in ai safety. arXiv preprint arXiv:1606.06565, 2016.
+
+Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. arXiv preprint arXiv:1802.00420, 2018.
+
+Peter L Bartlett, Dylan J Foster, and Matus J Telgarsky. Spectrally-normalized margin bounds for neural networks. In Advances in Neural Information Processing Systems, pp. 6240–6249, 2017.
+
+Yoshua Bengio, Nicholas Leonard, and Aaron Courville. Estimating or propagating gradients through ´ stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432, 2013.
+
+Moustapha Cisse, Piotr Bojanowski, Edouard Grave, Yann Dauphin, and Nicolas Usunier. Parseval networks: Improving robustness to adversarial examples. arXiv preprint arXiv:1704.08847, 2017.
+
+Matthieu Courbariaux and Yoshua Bengio. Binarynet: Training deep neural networks with weights and activations constrained to+ 1 or-1. arXiv preprint arXiv:1602.02830, 2016.
+
+Guneet S Dhillon, Kamyar Azizzadenesheli, Zachary C Lipton, Jeremy Bernstein, Jean Kossaifi, Aran Khanna, and Anima Anandkumar. Stochastic activation pruning for robust adversarial defense. arXiv preprint arXiv:1803.01442, 2018.
+
+Angus Galloway, Graham W Taylor, and Medhat Moussa. Attacking binarized neural networks. arXiv preprint arXiv:1711.00449, 2017.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples (2014). arXiv preprint arXiv:1412.6572.
+
+Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015.
+
+Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017.
+
+Benoit Jacob, Skirmantas Kligys, Bo Chen, Menglong Zhu, Matthew Tang, Andrew Howard, Hartwig Adam, and Dmitry Kalenichenko. Quantization and training of neural networks for efficient integer-arithmetic-only inference. arXiv preprint arXiv:1712.05877, 2017.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016.
+
+Fangzhou Liao, Ming Liang, Yinpeng Dong, Tianyu Pang, Jun Zhu, and Xiaolin Hu. Defense against adversarial attacks using high-level representation guided denoiser. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1778–1787, 2018.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. In NIPS workshop on deep learning and unsupervised feature learning, volume 2011, pp. 5, 2011.
+
+NVIDIA. Nvidia turing architecture whitepaper. URL https://www.nvidia.com/ content/dam/en-zz/Solutions/design-visualization/technologies/ turing-architecture/NVIDIA-Turing-Architecture-Whitepaper.pdf.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. arXiv preprint, 2016a.
+
+Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In 2016 IEEE Symposium on Security and Privacy (SP), pp. 582–597. IEEE, 2016b.
+
+Haifeng Qian and Mark N Wegman. L2-nonexpansive neural networks. arXiv preprint arXiv:1802.07896, 2018.
+
+Adnan Siraj Rakin, Jinfeng Yi, Boqing Gong, and Deliang Fan. Defend deep neural networks against adversarial examples via fixed anddynamic quantized activation functions. arXiv preprint arXiv:1807.06714, 2018.
+
+Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In European Conference on Computer Vision, pp. 525–542. Springer, 2016.
+
+Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Inverted residuals and linear bottlenecks: Mobile networks for classification, detection and segmentation. arXiv preprint arXiv:1801.04381, 2018.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Yang Song, Taesup Kim, Sebastian Nowozin, Stefano Ermon, and Nate Kushman. Pixeldefend: Leveraging generative models to understand and defend against adversarial examples. arXiv preprint arXiv:1710.10766, 2017.
+
+Dong Su, Huan Zhang, Hongge Chen, Jinfeng Yi, Pin-Yu Chen, and Yupeng Gao. Is robustness the cost of accuracy?–a comprehensive study on the robustness of 18 deep image classification models. arXiv preprint arXiv:1808.01688, 2018.
+
+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.
+
+Florian Tramer, Alexey Kurakin, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick Mc- \` Daniel. Ensemble adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017.
+
+David Warde-Farley and Ian Goodfellow. 11 adversarial perturbations of deep neural networks. Perturbations, Optimization, and Statistics, pp. 311, 2016.
+
+Weilin Xu, David Evans, and Yanjun Qi. Feature squeezing: Detecting adversarial examples in deep neural networks. arXiv preprint arXiv:1704.01155, 2017.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.
+
+Shuchang Zhou, Yuxin Wu, Zekun Ni, Xinyu Zhou, He Wen, and Yuheng Zou. Dorefa-net: Training low bitwidth convolutional neural networks with low bitwidth gradients. arXiv preprint arXiv:1606.06160, 2016.
+
+Chenzhuo Zhu, Song Han, Huizi Mao, and William J Dally. Trained ternary quantization. arXiv preprint arXiv:1612.01064, 2016.
+
+# A GRADIENT MASKING OF OTHER METHODS
+
+# A.1 TANH-BASED ACTIVATION QUANTIZATION LEADS TO FAKE SECURITY
+
+Rakin et al. (2018) tried to use activation quantization as a defense method against adversarial samples. According to their experiments, simply Tanh based activation quantization can greatly improve the model’s robustness under PGD adversarial training setting. We reproduced their experiments by training a ResNet-18 model with PGD adversarial training on CIFAR-10 following Madry et al. (2017). To make a comparison, we also trained a full precision model and a ReLU6 quantized model following same setting. All the quantized models use bi $^ { = 2 }$ . We tested the trained model using PGD attack by Madry et al. (2017) under both white-box and black-box setting. We use a VGG-16 model separately trained with PGD adversarial training as the black-box attacker. The results are provided in Table 5.
+
+Table 5. Tanh-based quantization improves white-box robustness, while suffers from inferior black-box robustness compared to full-precision model. The white-box accuracy is even higher than black-box, suggesting gradient masking. Setup: white-box and black-box robustness of PGD adversarially trained ResNet-18 on CIFAR-10. Quantization uses 2 bits.   
+
+<table><tr><td></td><td>Clean Acc.</td><td>White-Box Acc.</td><td>Black-Box Acc.</td></tr><tr><td>Full-Precision</td><td>83.47%</td><td>50.51%</td><td>65.58%</td></tr><tr><td>Tanh Quantized</td><td>81.60%</td><td>71.03%</td><td>61.57%</td></tr><tr><td>ReLU6 Quantized</td><td>78.97%</td><td>48.90%</td><td>59.44%</td></tr></table>
+
+Our white-box result is consistent with (Rakin et al., 2018), where Tanh based quantizaion with PGD training gives much higher white-box accuracy compared to the full precision model. However, we can see that the black-box robustness decreases. Worse still, the black-box attack successful rate is even lower than white-box, which is abnormal since black-box attack is generally weaker than white-box. This phenomenon indicates severe gradient masking problem (Papernot et al., 2016a; Athalye et al., 2018), which gives a false sense of security. As a comparison, we also trained a ReLU6 quantized model. With ReLU6 quantization, there is no sign of gradient masking, nor improvement in robustness, indicating that gradient masking problem majorly comes from Tanh activation function. Actually, ReLU6 quantized model has slightly worse robustness.
+
+Therefore we conclude that simple quantization cannot help to improve robustness. Instead, it leads to inferior robustness.
+
+# A.2 ADVERSARIAL FGSM TRAINING CAUSES GRADIENT MASKING
+
+Here we demonstrate that FGSM adversarial training leads to significant gradient masking problem, while $\mathrm { R + F G S M }$ fixes such issues. We trained a Wide ResNet using adversarial FGSM and adversarial $\mathrm { R + F G S M }$ respectively. Then the model is tested using FGSM with $\epsilon = 8$ under white-box and black-box setting (VGG-16 as substitute). The results are shown in Table
+
+Table 6. White-box and black-box robustness of FGSM/R $+$ FGSM adversarially trained Wide ResNet on CIFAR-10.   
+
+<table><tr><td></td><td>Clean Acc.</td><td>White-Box Acc.</td><td>Black-Box Acc.</td></tr><tr><td>Adversarial FGSM</td><td>94.55%</td><td>94.18%</td><td>51.65%</td></tr><tr><td>Adversarial R+FGSM</td><td>91.61%</td><td>51.65%</td><td>87.39%</td></tr></table>
+
+We can clearly see the same gradient masking effect. For adversarial FGSM training, it gives much higher white box robustness than $\mathrm { R + F G S M }$ adversarial training, while the black-box robustness is much worse. To avoid gradient masking, we thus use $\mathrm { R + F G S M }$ adversarial training instead.
+
+# B HYPER-PARAMETERS: $\beta$ STUDY
+
+![](images/24334ee8c75cd66a51ecbe9b9fd106ccbe2d6b0b31ef07fd3ca2ab77d2e2b576.jpg)  
+Figure 6. Clean and adversarial accuracy of 4-bit quantized Wide ResNet w.r.t. different $\beta$
+
+As observed in Section 5.1, the adversarial robustness of the model generally increases as $\beta$ gets larger. Here we aim to find what is the optimal $\beta$ for our experiment. We took 4-bit quantized Wide ResNet for example. As shown in Figure 6, the adversarial accuracy first gets larger as $\beta$ increases, and slowly goes down afterwards, reaching peak performance at $\beta = 0 . 0 0 2$ . The clean accuracy is more stable. At the first stage, as regularization gets stronger, the effect of noise amplify is suppressed more. While for the second stage, the training suffers from a too strong regularization. Therefore, we used a $\beta = 0 . 0 0 2$ for our experiments unless specified.
+
+# C VISUALIZE SAMPLES AND PREDICTIONS
+
+We visualize some of the clean and adversarial samples from CIFAR-10 test set, and the corresponding prediction for full precision model (FP), vanilla 4-bit quantized model (VQ) and our 4-bit Defensive Quantization model (DQ), as 4-bit quantization is now now supported by Tensor Cores with NVIDIA’s Turing Architecture (NVIDIA). Predicted class and probability is provided. Compared to FP and DQ, VQ has worse robustness by misclassifying more adversarial samples (sample 1, 2, 4, 6). Our DQ model enjoys better robustness than FP model in two aspects: 1. our DQ model succeeds to defend some of the attacks when FP failed (sample 5, 7); 2. our DQ model has a better confidence for true label compared to FP model when both succeeds to defend (sample 1, 4, 6). Even when all models fail to defend, our DQ model has the lowest confidence for the misclassified class (sample 3, 8).
+
+![](images/2156801777e07b0beb707dcc469d27461342850f85114ac60ee0e622f52c6f90.jpg)  
+Figure 7. Visualization of adversarial samples and the corresponding predictions (label and probability). FP: full-precision model; VQ: vanilla 4-bit quantized model; DQ: our 4-bit Defensive Quantization model

parse/train/ryetZ20ctX/ryetZ20ctX_content_list.json

@@ -0,0 +1,1664 @@
+[
+    {
+        "type": "text",
+        "text": "DEFENSIVE QUANTIZATION: WHEN EFFICIENCY MEETS ROBUSTNESS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            99,
+            665,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ji Lin   \nMIT   \njilin@mit.edu ",
+        "bbox": [
+            184,
+            170,
+            313,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chuang Gan MIT-IBM Watson AI Lab ganchuang@csail.mit.edu ",
+        "bbox": [
+            361,
+            170,
+            588,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Song Han   \nMIT   \nsonghan@mit.edu ",
+        "bbox": [
+            633,
+            171,
+            782,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            452,
+            250,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural network quantization is becoming an industry standard to efficiently deploy deep learning models on hardware platforms, such as CPU, GPU, TPU, and FPGAs. However, we observe that the conventional quantization approaches are vulnerable to adversarial attacks. This paper aims to raise people’s awareness about the security of the quantized models, and we designed a novel quantization methodology to jointly optimize the efficiency and robustness of deep learning models. We first conduct an empirical study to show that vanilla quantization suffers more from adversarial attacks. We observe that the inferior robustness comes from the error amplification effect, where the quantization operation further enlarges the distance caused by amplified noise. Then we propose a novel Defensive Quantization (DQ) method by controlling the Lipschitz constant of the network during quantization, such that the magnitude of the adversarial noise remains non-expansive during inference. Extensive experiments on CIFAR-10 and SVHN datasets demonstrate that our new quantization method can defend neural networks against adversarial examples, and even achieves superior robustness than their fullprecision counterparts, while maintaining the same hardware efficiency as vanilla quantization approaches. As a by-product, DQ can also improve the accuracy of quantized models without adversarial attack. ",
+        "bbox": [
+            233,
+            286,
+            766,
+            536
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            565,
+            336,
+            582
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural network quantization (Han et al., 2015; Zhu et al., 2016; Jacob et al., 2017) is a widely used technique to reduce the computation and memory costs of neural networks, facilitating efficient deployment. It has become an industry standard for deep learning hardware. However, we find that the widely used vanilla quantization approaches suffer from unexpected issues — the quantized model is more vulnerable to adversarial attacks (Figure 1). Adversarial attack is consist of subtle perturbations on the input images that causes the deep learning models to give incorrect labels (Szegedy et al., 2013; Goodfellow et al.). Such perturbations are hardly detectable by human eyes but can easily fool neural networks. Since quantized neural networks are widely deployed in many safety-critical scenarios, e.g., autonomous driving (Amodei et al., 2016), the potential security risks cannot be neglected. The efficiency and latency in such applications are also important, so we need to jointly optimize them. ",
+        "bbox": [
+            174,
+            597,
+            825,
+            736
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The fact that quantization leads to inferior adversarial robustness is counter intuitive, as small perturbations should be denoised with low-bit representations. Recent work (Xu et al., 2017) also demonstrates that quantization on input image space , i.e. color bit depth reduction, is quite effective to defend adversarial examples. A natural question then rises, why the quantization operator is yet effective when applied to intermediate DNN layers? We analyze that such issue is caused by the error amplification effect of adversarial perturbation (Liao et al., 2018) — although the magnitude of perturbation on the image is small, it is amplified significantly when passing through deep neural network (see Figure 3b). The deeper the layers are, the more significant such side effect is. Such amplification pushes values into a different quantization bucket, which is undesirable. We conducted empirical experiments to analyze how quantization influences the activation error between clean and adversarial samples (Figure 3a): when the magnitude of the noise is small, activation quantization is capable of reducing the errors by eliminating small perturbations; However, when the magnitude of perturbation is larger than certain threshold, quantization instead amplify the errors, which causes ",
+        "bbox": [
+            174,
+            743,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/3477ecd5b2c43d16b40e89da24dec3e171a08e472afb5ecf20c37178321efd79.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            102,
+            480,
+            250
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(a) Quantization preserves the accuracy till 4-5 bits on clean image. ",
+        "bbox": [
+            192,
+            256,
+            488,
+            281
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/dc57dfe77e70d9c157083068a6a5416fccbd3d6d2342eea03d00a27b807e59e5.jpg",
+        "image_caption": [
+            "(b) Quantization no longer preserves the accuracy under adversarial attack (same legend as left). ",
+            "Figure 1. Quantized neural network are more vulnerable to adversarial attack. Quantized models have no loss of accuracy on clean image ${ \\geq } 5$ bits), but have significant loss of accuracy under adversarial attack compared to full precision models. Setup: VGG-16 and Wide ResNet on the test set of CIFAR-10 with FGSM attack. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            509,
+            102,
+            797,
+            250
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "the quantized model to make mistakes. We argue that this is the main reason causing the inferior robustness of the quantized models. ",
+        "bbox": [
+            174,
+            361,
+            823,
+            390
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose Defensive Quantization (DQ) that not only fixes the robustness issue of quantized models, but also turns activation quantization into a defense method that further boosts adversarial robustness. We are inspired by the success of image quantization in improving robustness. Intuitively, it will be possible to defend the attacks with quantization operations if we can keep the magnitude of the perturbation small. However, due to the error amplification effect of gradient based adversarial samples, it is non-trivial to keep the noise at a small scale during inference. Recent works (Cisse et al., 2017; Qian & Wegman, 2018) have attempted to make the network non-expansive by controlling the Lipschitz constant of the network to be smaller than 1, which has smaller variation change in its output than its input. In such case, the input noise will not propagate through the intermediate layers and impact the output, but attenuated. Our method is built on the theory. Defensive quantization not only quantizes feature maps into low-bit representations, but also controls the Lipschitz constant of the network, such that the noise is kept within a small magnitude for all hidden layers. In such case, we keep the noise small, as in the left zone of Figure 3a, quantization can reduce the perturbation error. The produced model with our method enjoys better security and efficiency at the same time. ",
+        "bbox": [
+            174,
+            397,
+            825,
+            604
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Experiments show that Defensive Quantization (DQ) offers three unique advantages. First, DQ provides an effective way to boost the robustness of deep learning models while maintains the efficiency. Second, DQ is a generic building block of adversarial defense, which can be combined with other adversarial defense techniques to advance state-of-the-art robustness. Third, our method makes quantization itself easier thanks to the constrained dynamic range. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            681
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND AND RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            698,
+            511,
+            713
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 MODEL QUANTIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            729,
+            380,
+            744
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Neural network quantization (Han et al., 2015; Rastegari et al., 2016; Zhou et al., 2016; Courbariaux & Bengio, 2016; Zhu et al., 2016)) are widely adopted to enable efficient inference. By quantizing the network into low-bit representation, the inference of network requires less computation and less memory, while still achieves little accuracy degradation on clean images. However, we find that the quantized models suffer from severe security issues — they are more vulnerable against adversarial attacks compared to full-precision models, even when they have the same clean image accuracy. Adversarial perturbation is applied to the input image, thus it is most related to activation quantization (Dhillon et al., 2018). We carry out the rest of the paper using ReLU6 based activation quantization (Howard et al., 2017; Sandler et al., 2018), as it is computationally efficient and is widely adopted by modern frameworks like TensorFlow (Abadi et al., 2016). As illustrated in Figure 2, a quantized convolutional network is composed of several quantized convolution block, each containing a serial of $c o n \\nu + B N + R e L U 6 +$ linear quantize operators. As the quantization operator has ",
+        "bbox": [
+            174,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/2e86d17f38d0c8264b4025ef957b06a76c9aef6e47037e726148ea0e6cd95bbd.jpg",
+        "image_caption": [
+            "Figure 2. Defensive quantization with Lipschitz regularization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            98,
+            807,
+            179
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "0 gradient almost everywhere, we followed common practice to use a STE (Bengio et al., 2013) function $y = x +$ stop gradient[Quantize $( x ) - x ]$ for gradient computation, which also eliminates the obfuscated gradient problem (Athalye et al., 2018). ",
+        "bbox": [
+            174,
+            231,
+            825,
+            273
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our work bridges two domains: model quantization and adversarial defense. Previous work (Galloway et al., 2017) claims binary quantized networks can improve the robustness against some attacks. However, the improvement is not substantial and they used randomized quantization, which is not practical for real deployment (need extra random number generators in hardware). It also causes one of the obfuscated gradient situations (Athalye et al., 2018): stochastic gradients, leading to a false sense of security. Rakin et al. (2018) tries to use quantization as an effective defense method. However, they employed Tanh-based quantization, which is not hardware friendly on fixed-point units due to the large overhead accessing look-up table. Even worse, according to our re-implementation, their method actually leads to severe gradient masking problem (Papernot et al., 2016a) during adversarial training, due to the nature of Tanh function (see A.1 for detail). As a result, the actual robustness of this work under black-box attack has no improvement over full-precision model and is even worse. Therefore, there is no previous work that are conducted under real inference setting to study the quantized robustness for both black-box and white-box. Our work aim to raise people’s awareness about the security of the actual deployed models. ",
+        "bbox": [
+            174,
+            280,
+            825,
+            474
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 ADVERSARIAL ATTACKS & DEFENSES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            487,
+            480,
+            501
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given an image $\\mathbf { X }$ , an adversarial attack method tries to find a small perturbation $\\pmb { \\Delta }$ with constraint $| | \\Delta | | \\leq \\epsilon$ , such that the neural network gives different outputs for $\\mathbf { X }$ and $\\mathbf { X } ^ { a d v } \\triangleq \\mathbf { X } + \\pmb { \\Delta }$ . Here $\\epsilon$ is a scalar to constrain the norm of the noise (e.g., $\\epsilon = 8$ is commonly used when we represent colors from 0-255), so that the perturbation is hardly visible to human. For this paper we choose to study attacks defined under $| | \\cdot | | _ { \\infty }$ , where each element of the image can vary at most $\\epsilon$ to form an adversary. We introduce several attack and defense methods used in our work in the following sections. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            613
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2.1 ATTACK METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            627,
+            357,
+            641
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Random Perturbation (Random) Random perturbation attack adds a uniform sampled noise within $[ - \\epsilon , \\epsilon ]$ to the image, The method has no prior knowledge of the data and the network, thus is considered as the weakest attack method. ",
+        "bbox": [
+            173,
+            654,
+            823,
+            696
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Fast Gradient Sign Method (FGSM) & R+FGSM Goodfellow et al. proposed a fast method to calculate the adversarial noise by following the direction of the loss gradient $\\nabla _ { \\mathbf { X } } L ( \\mathbf { X } , y )$ , where $L ( \\mathbf { X } , y )$ is the loss function for training (e.g. cross entropy loss). The adversarial samples are computed as: ",
+        "bbox": [
+            173,
+            702,
+            825,
+            758
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/99eefde9e20f5cef957ea6e17f6930cd257ae093c10e865b0afa4596b22046f8.jpg",
+        "text": "$$\n{ \\bf X } ^ { a d v } = { \\bf X } + \\epsilon * \\mathrm { s i g n } ( \\nabla _ { \\bf X } { L } ( { \\bf X } , y ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            758,
+            617,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As FGSM is an one-step gradient-based method, it can suffer from sharp curvature near the data points, leading a false direction of ascent. Therefore, Tramer et al. (2017) proposes to prepend FGSM \\` by a random step to escape the non-smooth vicinity. The new method is called $\\mathbf { R } { + } \\mathbf { F } \\mathbf { G } \\mathbf { S } \\mathbf { M }$ , defined as follows, for parameters $\\epsilon$ and $\\epsilon _ { 1 }$ (where $\\epsilon _ { 1 } < \\epsilon$ ): ",
+        "bbox": [
+            174,
+            782,
+            825,
+            839
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/11489fe653179574f718f579e2e8f46d0cfebbf3f53584f0a33fb8126da457fc.jpg",
+        "text": "$$\n{ \\bf X } ^ { a d v } = { \\bf X } ^ { \\prime } + ( \\epsilon - \\epsilon _ { 1 } ) * \\mathrm { s i g n } ( \\nabla _ { \\bf X } L ( { \\bf X } , y ) ) , \\mathrm { w h e r e } { \\bf X } ^ { \\prime } = { \\bf X } + \\epsilon _ { 1 } * \\mathrm { s i g n } ( \\mathcal { N } ( { \\bf 0 } ^ { d } , { \\bf I } ^ { d } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            222,
+            848,
+            776,
+            866
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In our paper, we set $\\epsilon _ { 1 } = \\epsilon / 2$ following Tramer et al. (2017). \\` ",
+        "bbox": [
+            174,
+            873,
+            575,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Basic Iterative Method (BIM) & Projected Gradient Descend (PGD) Kurakin et al. (2016) suggests a simple yet much stronger variant of FGSM by applying it multiple times iteratively with a ",
+        "bbox": [
+            173,
+            895,
+            826,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(a) Noise increases with perturbation strength. Quantization makes the slope deeper. ",
+        "bbox": [
+            176,
+            253,
+            491,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/19cea475a7e4e3a56bd367d0019961f8154bd7f1eb67f498c26a9e9523c87ff5.jpg",
+        "image_caption": [
+            "(b) With conventional quantization, noise increases with layer index (the amplification effect). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            102,
+            486,
+            244
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/9493e4488590bc9fdd93d45255b35d302a1d3d742db0ef8a7ff73b17ab1709cb.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            508,
+            102,
+            816,
+            246
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 3. (a) Comparison of the noise introduced by adversarial-attack, with and without quantization. For small perturbation, quantization reduces the noise; for large perturbation, quantization magnifies the noise. (b) The noise amplification effect: the noise is amplified with layer index. Setup: conventional activation quantization for VGG-16, normalized difference of full-precision and low-precision activation. ",
+        "bbox": [
+            173,
+            290,
+            825,
+            342
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "small step size $\\alpha$ . The method is called BIM, defined as: ",
+        "bbox": [
+            176,
+            368,
+            544,
+            383
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/52431606422f6178f530d95c758ebffc8d618d0a81141a33b31155188920730a.jpg",
+        "text": "$$\n\\mathbf { X } _ { 0 } ^ { a d v } = \\mathbf { X } , \\ \\mathbf { X } _ { n + 1 } ^ { a d v } = \\mathrm { c l i p } _ { \\mathbf { X } } ^ { \\epsilon } \\{ \\mathbf { X } _ { n } ^ { a d v } + \\alpha \\mathrm { s i g n } ( \\nabla _ { \\mathbf { X } } L ( \\mathbf { X } _ { n } ^ { a d v } , y ) ) \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            388,
+            702,
+            410
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathrm { c l i p } _ { \\mathbf { X } } ^ { \\epsilon }$ means clipping the result image to be within the $\\epsilon$ -ball of $\\mathbf { X }$ . In (Madry et al., 2017), the BIM is prepended by a random start as in $\\mathrm { R + F G S M }$ method. The resulting attack is called PGD, which proves to be a general first-order attack. In our experiments we used PGD for comprehensive experiments as it proves to be one of the strongest attack. Unlike Madry et al. (2017) that uses a fixed $\\epsilon$ and $\\alpha$ , we follow Kurakin et al. (2016); Song et al. (2017) to use $\\alpha = 1$ and number of iterations of $\\left\\lfloor \\operatorname* { m i n } ( \\epsilon + 4 , 1 . 2 5 \\epsilon ) \\right\\rfloor$ , so that we can test the model’s robustness under different strength of attacks. ",
+        "bbox": [
+            174,
+            414,
+            826,
+            498
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2.2 DEFENSE METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            511,
+            366,
+            525
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Current defense methods either preprocess the adversarial samples to denoise the perturbation (Xu et al., 2017; Song et al., 2017; Liao et al., 2018) or making the network itself robust (Warde-Farley & Goodfellow, 2016; Papernot et al., 2016b; Madry et al., 2017; Kurakin et al., 2016; Goodfellow et al.; Tramer et al., 2017). Here we introduced several defense methods related to our experiments. \\` ",
+        "bbox": [
+            174,
+            537,
+            825,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Feature Squeezing $\\mathrm { X u }$ et al. (2017) proposes to detect adversarial images by squeezing the input image. Specifically, the image is processed with color depth bit reduction (5 bits for our experiments) and smoothed by a $2 \\times 2$ median filter. If the low resolution image is classified differently as the original image, then this image is detected as adversarial. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            656
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Training Adversarial training (Madry et al., 2017; Kurakin et al., 2016; Goodfellow et al.; Tramer et al., 2017) is currently the strongest method for defense. By augmenting the training set \\` with adversarial samples, the network learns to classify adversarial samples correctly. As adversarial Table 3Table 3FGSM can easily lead to gradient masking effect (Papernot et al., 2016a), we study adversarial $\\mathrm { R + F G S M }$ 4-Bit Quantized 6-Bit Quantized 8-Bit Quantized Full Precision4-Bit Quantized 6-Bit Quantized 8-Bit Quantized Full Precision as in (Tramer et al., 2017). We also experimented with PGD training (Madry et al., 2017). \\` ",
+        "bbox": [
+            174,
+            662,
+            825,
+            733
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "00 0.46921857947162576 2.0000 0 2.0000 0.332712 2.0000 0 2.0000 0.28962.0000 0.46921857947162 2.0000 0 2.0000 0.332712 2.0000 0 2.0000 0.2896Experiments show that above defense methods can be combined with our DQ method to further   \n000 0.7550861999431432 3.0000 0.6733 3.0000 0.6304687265237110000 3.0000 0.6050 3.0000 0.57743.0000 0.75508619994314 3.0000 0.6733 3.0000 0.6304687265237110000 3.0000 0.6050 3.0000 0.5774improve the robustness. The robustness has been tested under the aforementioned attack methods. ",
+        "bbox": [
+            173,
+            739,
+            823,
+            767
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "000 0.8435416802069752 5.0000 0.7445 5.0000 0.70679410870240300 5.0000 0.6733 5.0000 5.0000 0.8435416802069752 5.0000 0.7445 5.0000 0.70679410870240300 5.0000 0.6733 5.0000 3 C O N V E N T I O NA L N N Q UA N T I Z AT I O N I S N OT RO B U S T ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            782,
+            650,
+            799
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "00 1.012114964143164 7.0000 1.005 7.0000 0.9032 7.0000 0.8307 7.0000 0.83257.0000 1.012114964143164 7.0000 1.005 7.0000 0.9032 7.0000 0.8307 7.0000 0.8325Conventional neural network quantization is more vulnerable to adversarial attacks. We experimented 000 0.9862844244360638 8.0000 0.9515 8.0000 0.86693617000095300 8.0000 0.80045166445080300 8.0000 0.7888.0000 0.9862844244360638 8.0000 0.9515 8.0000 0.86693617000095300 8.0000 0.80045166445080300 8.0000 0.788with VGG-16 (Simonyan & Zisserman, 2014) and a Wide ResNet (Zagoruyko & Komodakis, 2016) 00 1.0681920178474003 9.0000 1.0577 9.0000 0.977219 9.0000 0.8388344297226030 9.0000 0.81519.0000 1.0681920178474003 9.0000 1.0577 9.0000 0.977219 9.0000 0.8388344297226030 9.0000 0.8151of depth 28 and width 10 on CIFAR-10 (Krizhevsky & Hinton, 2009) dataset. We followed the 000 1.0993773912484481 10.000 1.1288 10.000 1.023 10.000 0.8246 10.000 0.758810.000 1.0993773912484481 10.000 1.1288 10.000 1.023 10.000 0.8246 10.000 0.7588training protocol as in (Zagoruyko & Komodakis, 2016). Adversarial samples are generated with a 000 1.1090918582426685 11.0000 1.1015 11.0000 11.0000 1.1090918582426685 11.0000 1.1015 11.0000 FGSM (Goodfellow et al.) attacker $\\epsilon = 8$ 11.0000 0.8027 11.0000 0.71920199 11.0000 0.8027 11.0000 0.7192) on the entire test set. As in Figure 1, the clean image .00 1.207932074028837 12.00 1.1706 12.00 1.099673 12.00 0.827749 12.00 0.748612.00 1.207932074028837 12.00 1.1706 12.00 1.099673 12.00 0.827749 12.00 0.7486accuracy doesn’t significantly drop until the model is quantized to 4 bits (Figure 1a). However, under .00 1.2888898827224133 13.00 1.1754 13.00 1.097803 13.00 0.829665 13.00 0.7676 13.00 1.2888898827224133 13.00 1.1754 13.00 1.097803 13.00 0.829665 13.00 0.7676 adversarial attack, even with 5-bit quantization, the accuracy drastically decreased by $2 5 . 3 \\%$ and $9 . 2 \\%$ respectively. Although the full precision model’s accuracy has dropped, the quantized model’s accuracy dropped much harder, showing that the conventional quantization method is not robust. Clean image accuracy used to be the sole figure of merit to evaluate a quantized model. We show that even when the quantized model has no loss of performance on clean images, it can be much more easily fooled compared to full-precision ones, thus raising security concerns. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/a45d501e28e5bec0f019f31e9dc2930c1e74c4210393c9ed002f8d40c281ba44.jpg",
+        "image_caption": [
+            "Figure 4. The error amplification effect prevents activation quantization from defending adversarial attacks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            98,
+            808,
+            219
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            270,
+            825,
+            327
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Input image quantization, i.e., color bit depth reduction is an effective defense method ( $\\mathrm { { X u } }$ et al., 2017). Counter intuitively, it does not work when applied to hidden layers, and even make the robustness worse. To understand the reason, we studied the effect of quantization w.r.t. different perturbation strength. We first randomly sample 128 images $\\mathbf { X }$ from the test set of CIFAR-10, and generate corresponding adversarial samples $\\mathbf { X } ^ { a d v }$ . The samples are then fed to the trained Wide ResNet model. To mimic different strength of activation perturbation, we vary the $\\epsilon$ from 1 to 8. We inspected the activation after the first convolutional layer $f _ { 1 }$ $\\mathrm { C o n v } + \\mathrm { B N } + \\mathrm { R e L U } 6 )$ , denoted as $\\mathbf { A } _ { 1 } \\ { \\overset { \\mathbf { \\Gamma } } { = } } \\ f _ { 1 } ( \\mathbf { X } )$ and ${ \\bf A } _ { 1 } ^ { a d v } = f _ { 1 } ( { \\bf A } ^ { a d v } )$ . To measure the influence of perturbation, we define a normalized distance between clean and perturbed activation as: ",
+        "bbox": [
+            173,
+            332,
+            825,
+            458
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/96dff84bb2d0721b61e181f80d9f8e27258be710a5732dac42d5135b827f4da8.jpg",
+        "text": "$$\nD ( \\mathbf { A } , \\mathbf { A } ^ { a d v } ) = | | \\mathbf { A } - \\mathbf { A } ^ { a d v } | | _ { 2 } / | | \\mathbf { A } | | _ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            463,
+            625,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We compare $D ( \\mathbf { A } , \\mathbf { A } ^ { a d v } )$ and $D ( { \\mathrm { Q u a n t i z e } } ( \\mathbf { A } ) , { \\mathrm { Q u a n t i z e } } ( \\mathbf { A } ^ { a d v } ) )$ , where Quantize indicates uniform quantization with 3 bits. The results are shown in Figure 3a. We can see that only when $\\epsilon$ is small, quantization helps to reduce the distance by removing small magnitude perturbations. The distance will be enlarged when $\\epsilon$ is larger than 3. ",
+        "bbox": [
+            174,
+            487,
+            825,
+            544
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The above experiment explains the inferior robustness of the quantized model. We argue that such issue arises from the error amplification effect (Liao et al., 2018), where the relative perturbed distance will be amplified when the adversarial samples are fed through the network. As illustrated in Figure 4, the perturbation applied to the input image has very small magnitude compared to the image itself $\\pm 8$ versus $0 - 2 5 5$ ), corresponding to the left zone of Figure 3a (desired), where quantization helps to denoise the perturbation. Nevertheless, the difference in activation is amplified as the inference carries on. If the perturbation after amplification is large enough, the situation corresponds to the right zone (actual) of Figure 3a, where quantization further increases the normalized distance. Such phenomenon is also observed in the quantized VGG-16. We plot the normalized distance of each convolutional layer’s input in Figure 3b. The fewer bits in the quantized model, the more severe the amplification effect. ",
+        "bbox": [
+            173,
+            550,
+            825,
+            704
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 DEFENSIVE QUANTIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            718,
+            437,
+            734
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given the robustness limitation of conventional quantization technique, we propose Defensive Quantization (DQ) to defend the adversarial examples for quantized models. DQ suppresses the noise amplification effect, keeping the magnitude of the noise small, so that we can arrive at the left zone (Figure 3a, desired) where quantization helps robustness instead of making it worse. ",
+        "bbox": [
+            173,
+            747,
+            825,
+            804
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We control the neural network’s Lipschitz constant (Szegedy et al., 2013; Bartlett et al., 2017; Cisse et al., 2017) to suppress network’s amplification effect. Lipschitz constant describes: when input changes, how much does the output change correspondingly. For a function $f : X \\to Y$ , if it satisfies ",
+        "bbox": [
+            173,
+            810,
+            825,
+            853
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3394ec58221c9f7706e95ce026592456c967f1d6cc48c24a83b67ceae37de2fa.jpg",
+        "text": "$$\nD _ { Y } ( f ( x _ { 1 } ) , f ( x _ { 2 } ) ) \\leq k D _ { X } ( x _ { 1 } , x _ { 2 } ) , \\ \\forall x _ { 1 } , x _ { 2 } \\in X\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            859,
+            666,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "for a real-valued $k \\geq 0$ and some metrics $D _ { X }$ and $D _ { Y }$ , then we call $f$ Lipschitz continuous and $k$ is the known as the Lipschitz constant of $f$ . If we consider a network $f$ with clean inputs $x _ { 1 } = \\mathbf { X }$ and corresponding adversarial inputs $x _ { 2 } = \\mathbf { X } _ { a d v }$ , the error amplification effect can be controlled if we ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/931b175820461bc8a2f80e80e4061fabcce98cd50a33f0f7f37357b9c337496f.jpg",
+        "table_caption": [
+            "Table 1. The clean and adversarial accuracy of Wide ResNet on CIFAR-10 test set. We compare the accuracy of full-precision and quantized models. With our DQ method, we not only eliminate the robustness gap between full-precision and quantized models, but also improve the robustness over full-precision ones. The accuracy gain from quantization compared to the full-precision model (Quantize Gain) has gradually been improved as $\\beta$ increases. Bold and underline numbers are the first and second highest accuracy at each row. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td rowspan=\"2\">Acc.</td><td rowspan=\"2\">Full Prec.</td><td colspan=\"5\">Quantize Bit</td><td rowspan=\"2\">Quantize Gain</td><td rowspan=\"2\">Best Acc.</td></tr><tr><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td></tr><tr><td rowspan=\"2\">Vanilla</td><td>clean</td><td>94.8</td><td>42.0</td><td>84.9</td><td>92.8</td><td>93.9</td><td>94.7</td><td rowspan=\"2\">-9.1</td><td rowspan=\"2\">39.3</td></tr><tr><td>adv.</td><td>39.3</td><td>9.0</td><td>8.5</td><td>14.1</td><td>19.0</td><td>30.2</td></tr><tr><td rowspan=\"2\">DQ (β =3e-4)</td><td>clean</td><td>95.3</td><td>95.2</td><td>95.3</td><td>95.1</td><td>95.1</td><td>95.1</td><td rowspan=\"2\">+1.4</td><td rowspan=\"2\">43.2</td></tr><tr><td>adv.</td><td>41.8</td><td>43.2</td><td>41.1</td><td>40.1</td><td>39.8</td><td>39.3</td></tr><tr><td rowspan=\"2\">DQ (β =6e-4)</td><td>clean</td><td>95.6</td><td>95.7</td><td>95.2</td><td>95.4</td><td>95.6</td><td>95.5</td><td rowspan=\"2\">+2.6</td><td rowspan=\"2\">48.3</td></tr><tr><td>adv.</td><td>45.7</td><td>48.3</td><td>47.9</td><td>43.8</td><td>43.9</td><td>44.6</td></tr><tr><td rowspan=\"2\">DQ (β =1e-3)</td><td>clean</td><td>95.9</td><td>95.8</td><td>95.6</td><td>95.6</td><td>95.8</td><td>95.8</td><td rowspan=\"2\">+2.7</td><td rowspan=\"2\">51.8</td></tr><tr><td>adv.</td><td>49.1</td><td>51.3</td><td>50.4</td><td>51.3</td><td>49.8</td><td>51.8</td></tr></table>",
+        "bbox": [
+            218,
+            183,
+            781,
+            352
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "have a small Lipschitz constant $k$ (in optimal situation we can have $k \\leq 1$ ). In such case, the error introduced by adversarial perturbation will not be amplified, but reduced. Specifically, we consider a feed-forward network composed of a serial of functions: ",
+        "bbox": [
+            174,
+            381,
+            825,
+            424
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e9cf1feb3f9b1722a648960044c20cf1028b5598a83e94abdd2852fb9a20695c.jpg",
+        "text": "$$\nf ( x ) = ( \\phi _ { l } \\circ \\phi _ { l - 1 } \\circ \\ldots \\circ \\phi _ { 1 } ) ( x )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            428,
+            607,
+            445
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\phi _ { i }$ can be a linear layer, convolutional layer, pooling, activation functions, etc. Denote the Lipschitz constant of a function $f$ as $L i p ( f )$ , then for the above network we have ",
+        "bbox": [
+            173,
+            449,
+            828,
+            477
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9883e7648ef328bb8d60466e2647fa68926735efa92e7ec0d5f210fa14a7d43e.jpg",
+        "text": "$$\nL i p ( f ) \\leq \\prod _ { i = 1 } ^ { L } L i p ( \\phi _ { i } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            481,
+            575,
+            525
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As the Lipschitz constant of the network is the product of its individual layers’ Lipschitz constants, $L i p ( f )$ can grow exponentially if $L i p ( \\phi _ { i } ) > 1$ . This is the common case for normal network training (Cisse et al., 2017), and thus the perturbation will be amplified for such a network. Therefore, to keep the Lipschitz constant of the whole network small, we need to keep the Lipschitz constant of each layer $L i p ( \\phi _ { i } ) \\leq 1$ . We call a network with $L i p ( \\phi _ { i } ) \\le 1 , \\forall i = 1 , . . . , L$ a non-expansive network. ",
+        "bbox": [
+            173,
+            534,
+            825,
+            618
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We describe a regularization term to keep the Lipschitz constant small. Let us first consider linear layers with weight $\\mathbf { W } \\in \\mathbb { R } ^ { c _ { o u t } \\times c _ { i n } }$ under $| | \\cdot | | _ { 2 }$ norm. The Lipschitz constant is by definition the spectral norm of $W$ : $\\rho ( \\mathbf { W } )$ , i.e., the maximum singular value of W. Computing the singular values of each weight matrix is not computationally feasible during training. Luckily, if we can keep the weight matrix row orthogonal, the singular values are by nature equal to 1, which meets our non-expansive requirements. Therefore we transform the problem of keeping $\\rho ( \\mathbf { W } ) \\leq 1$ into keeping $\\mathbf { W } ^ { \\hat { T } } \\mathbf { W } \\approx \\mathbf { I }$ , where $\\mathbf { I }$ is the identity matrix. Naturally, we introduce a regularization term $| | \\mathbf { W } ^ { \\hat { T } } \\mathbf { \\check { W } } - \\mathbf { I } | |$ , where $I$ is the identity matrix. Following (Cisse et al., 2017), for convolutional layers with weight $\\mathbf { W } \\in \\mathbb { R } ^ { c _ { o u t } \\times c _ { i n } \\times k \\times k }$ , we can view it as a two-dimension matrix of shape $\\dot { \\mathbf { W } } \\in \\mathbb { R } ^ { c _ { o u t } \\times ( c _ { i n } \\bar { k } k ) }$ and apply the same regularization. The final optimization objective is: ",
+        "bbox": [
+            173,
+            625,
+            825,
+            766
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d32fab94775912ad2d4d7a52fa5e9e9262b6a1f83752f98b7ac42912ba63f5c2.jpg",
+        "text": "$$\n\\mathcal { L } = \\mathcal { L } _ { C E } + \\frac { \\beta } { 2 } \\sum _ { \\mathbf { W } _ { l } \\in \\mathbb { W } } | | \\mathbf { W } _ { l } ^ { T } \\mathbf { W } _ { l } - \\mathbf { I } | | ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            768,
+            627,
+            809
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { L } _ { C E }$ is the original cross entropy loss and $\\mathbb { W }$ denotes all the weight matrices of the neural network. $\\beta$ is the weighting to adjust the relative importance. The above discussion is based on simple feed forward networks. For ResNets in our experiments, we also follow Cisse et al. (2017) to modify the aggregation layer as a convex combination of their inputs, where the 2 coefficients are updated using specific projection algorithm (see (Cisse et al., 2017) for details). ",
+        "bbox": [
+            174,
+            818,
+            825,
+            890
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our Defensive Quantization is illustrated in Figure 2. The key part is the regularization term, which suppress the noise amplification effect by regularizing the Lipschitz constant. As a result, the perturbation at each layer is kept within a certain range, the adversarial noise won’t propagate. Our method not only fixes the drop of robustness induced by quantization, but also takes quantization as a defense method to further increase the robustness. Therefore it’s named Defensive Quantization. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/7d1866fcf015dc1809459d67bc48aaa2fbaefc65c09b355642a345cc822367f9.jpg",
+        "image_caption": [
+            "Figure 5. The white-box and black-box robustness are consistent: vanilla quantization leads to significant robustness drop, while DQ can bridge the gap and improve the robustness, especially with lower bits $( \\mathrm { b i t } { = } 1 )$ ). Setup: white-box and black-box robustness of Wide ResNet with vanilla quantization and defensive quantization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            99,
+            818,
+            218
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            300,
+            825,
+            342
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            359,
+            326,
+            376
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our experiments demonstrate the following advantages of Defensive Quantization. First, DQ can retain the robustness of a model when quantized with low-bit. Second, DQ is a general and effective defense method under various scenarios, thus can be combined with other defensive techniques to further advance state-of-the-art robustness. Third, as a by-product, DQ can also improve the accuracy of training quantized models on clean images without attacks, since it limits the dynamic range. ",
+        "bbox": [
+            174,
+            391,
+            825,
+            460
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 FIXING ROBUSTNESS DROP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            477,
+            406,
+            491
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Setup: We conduct experiments with Wide ResNet (Zagoruyko & Komodakis, 2016) of $2 8 \\times 1 0$ on the CIFAR-10 dataset (Krizhevsky & Hinton, 2009) using ReLU6 based activation quantization, with number of bits ranging from 1 to 5. All the models are trained following (Zagoruyko & Komodakis, 2016) with momentum SGD for 200 epochs. The adversarial samples are generated using FGSM attacker with $\\epsilon = 8$ . ",
+        "bbox": [
+            174,
+            503,
+            825,
+            574
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Result: The results are presented in Table 1. For vanilla models, though the adversarial robustness increases with the number of bits, i.e., the models closer to full-precision one has better robustness, the best quantized model still has inferior robustness by $- 9 . 1 \\%$ . While with our Defensive Quantization, the quantized models have better robustness than full-precision counterparts. The robustness is better when the number of bits are small, since it can de-noise larger adversarial perturbations. We also find that the robustness is generally increasing as $\\beta$ gets larger, since the regularization of Lipschitz constant itself keeps the noise smaller at later layers. At the same time, the quantized models consistently achieve better robustness. The robustness of quantized model also increases with $\\beta$ . We conduct a detailed analysis of the effect of $\\beta$ in Section B. The conclusion is: (1) conventional quantized models are less robust. (2) Lipschitz regularization makes the model robust. (3) Lipschitz regularization $^ +$ quantization makes model even more robust. ",
+        "bbox": [
+            173,
+            580,
+            825,
+            733
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As shown in (Athalye et al., 2018), many of the defense methods actually lead to obfuscated gradient, providing a false sense of security. Therefore it is important to check the model’s robustness under black-box attack. We separately trained a substitute VGG-16 model on the same dataset to generate adversarial samples, as it was proved to have the best transferability (Su et al., 2018). The results are presented in Figure 5. Trends of white-box and black-box attack are consistent. Vanilla quantization leads to inferior black-box robustness, while with our method can further improve the models’ robustness. As the robustness gain is consistent for both white-box and black-box setting, our method does not suffer from gradient masking. ",
+        "bbox": [
+            174,
+            741,
+            825,
+            853
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 DEFEND WITH DEFENSIVE QUANTIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            867,
+            511,
+            882
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we show that we can combine Defensive Quantization with other defense techniques to achieve state-of-the-art robustness. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/ab1e9de4206de18569081e2f73c20ca7cb65da05d4cd96ca81037ef35814cd1d.jpg",
+        "table_caption": [
+            "Table 2. SVHN experiments tested with $\\epsilon = 2 / 8 / 1 6$ . (B) indicates black-box attack. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Training Technique</td><td>Clean</td><td>Random</td><td>FGSM</td><td>R+FGSM</td><td>PGD</td><td>FGSM(B)</td><td>PGD(B)</td></tr><tr><td>Normal</td><td>96.8</td><td>97/97/96</td><td>74/42/26</td><td>86/55/35</td><td>77/05/00</td><td>90/62/40</td><td>92/58/30</td></tr><tr><td>Normal + DQ</td><td>96.7</td><td>96/96/96</td><td>77/45/31</td><td>87/59/40</td><td>79/10/00</td><td>90/63/42</td><td>92/60/31</td></tr><tr><td>Feature Squeezing</td><td>96.3</td><td>96/96/95</td><td>69/34/20</td><td>84/48/28</td><td>72/03/00</td><td>89/61/38</td><td>91/56/27</td></tr><tr><td>Feature Squeezing + DQ</td><td>96.2</td><td>96/96/96</td><td>75/42/28</td><td>86/56/36</td><td>77/06/00</td><td>90/63/40</td><td>92/59/30</td></tr><tr><td>Adversarial R+FGSM</td><td>96.6</td><td>97/96/96</td><td>84/53/38</td><td>91/70/57</td><td>87/30/06</td><td>93/74/54</td><td>94/83/72</td></tr><tr><td>Adversarial R+FGSM+DQ</td><td>96.6</td><td>97/96/95</td><td>88/59/40</td><td>93/77/61</td><td>91/47/17</td><td>94/80/61</td><td>95/89/84</td></tr></table>",
+        "bbox": [
+            189,
+            131,
+            808,
+            265
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Setup: We conducted experiments on the Street View House Number dataset (SVHN) (Netzer et al., 2011) and CIFAR-10 dataset (Krizhevsky & Hinton, 2009). Since adversarial training is time consuming, we only use the official training set for experiments. CIFAR-10 is another widely used dataset containing 50,000 training samples and 10,000 testing samples of size $3 2 \\times 3 2$ . For both datasets, we divide the pixel values by 255 as a pre-processing step. ",
+        "bbox": [
+            173,
+            301,
+            825,
+            371
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Following (Athalye et al., 2018; Cisse et al., 2017; Madry et al., 2017), we used Wide ResNet (Zagoruyko & Komodakis, 2016) models in our experiments as it is considered as the standard model on the dataset. We used depth 28 and widening factor 10 for CIFAR-10, and depth 16 and widening factor 4 for SVHN. We followed the training protocol in (Zagoruyko & Komodakis, 2016) that uses a SGD optimizer with momentum $_ { 1 = 0 . 9 }$ . For CIFAR-10, the model is trained for 200 epochs with initial learning rate 0.1, decayed by a factor of 0.2 at 60, 120 and 160 epochs. For SVHN dataset, the model is trained for 160 epochs, with initial learning rate 0.01, decayed by 0.1 at 80 and 120 epochs. For DQ, we used bi $\\mathrm { = } 1$ and $\\beta = 2 \\mathrm { e } { - 3 }$ as it offers the best robustness (see Section B). ",
+        "bbox": [
+            174,
+            377,
+            825,
+            489
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We combine DQ with other defense methods to further boost the robustness. For Feature Squeezing (Xu et al., 2017), we used 5 bit for image color reduction, followed by a $2 \\times 2$ median filter. As adversarial FGSM training leads to gradient masking issue (Tramer et al., 2017) (see A.2 for our \\` experiment), we used the variant adversarial $\\mathrm { R + F G S M }$ training. To avoid over-fitting into certain $\\epsilon$ , we randomly sample $\\epsilon$ using $\\epsilon ^ { \\prime } \\sim \\mathcal { N } ( 0 , \\delta ) , \\epsilon = \\mathrm { c l i p } ^ { [ 0 , 2 \\delta ] } ( \\mathrm { a b s } ( \\epsilon ^ { \\prime } ) )$ . Specifically we used $\\delta = 8$ to cover $\\epsilon$ from 0-16. During test time, the $\\epsilon$ is set to a fixed value (2/8/16). We also conducted adversarial PGD training. Following (Kurakin et al., 2016; Song et al., 2017), during training we sample random $\\epsilon$ as in $\\mathrm { R + F G S M }$ setting, and generate adversarial samples using step size 1 and number of iterations $\\left\\lfloor \\operatorname* { m i n } ( \\epsilon + 4 , 1 . 2 5 \\epsilon ) \\right\\rfloor$ . ",
+        "bbox": [
+            173,
+            496,
+            825,
+            625
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Result: The results are presented in Table 2 and Table 3, where $\\mathbf { ( B ) }$ indicates black-box attack with a seperately trained VGG-16 model. The bold number indicates the best result in its column. We observe that for all normal training, feature squeezing and adversarial training settings, our DQ method can further improve the model’s robustness. Among all the defenses, adversarial training provides the best performance against various attacks, epecially adversarial $\\mathrm { R + F G S M }$ training. While white box PGD attack is generally the strongest attack in our experiments. Our DQ method also consistently improves the black-box robustness and there is no sign of gradient masking. Thus DQ proves to be an effective defense for various white-box and black-box attacks. ",
+        "bbox": [
+            174,
+            630,
+            825,
+            741
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 IMPROVE THE TRAINING OF QUANTIZED MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            757,
+            562,
+            771
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As a by-product of our method, Defensive Quantization can even improve the accuracy of quantized models on clean images without attack, making it a beneficial drop-in substitute for normal quantization procedures. Due to conventional quantization method’s amplification effect, the distribution of activation can step over the truncation boundary (0-6 for ReLU6, 0-1 for ReLU1), which makes the optimization difficult. DQ explicitly add a regularization to shrink the dynamic range of activation, so that it is fitted within the truncation range. To demonstrate our hypothesis, we experimented with ResNet and CIFAR-10. We quantized the activation with 4-bit (because NVIDIA recently introduced INT4 in Turing architecture) using ReLU6 and ReLU1 respectively. Vanilla quantization and DQ training are conducted for comparison. As shown in Table 4, with vanilla quantization, ReLU1 model has around $1 \\%$ worse accuracy than ReLU6 model, although they are mathematically equal if we multiply the previous BN scaling by 1/6 and next convolution weight by 6. It demonstrates that improper truncation function and range will lead to training difficulty. While with DQ training, both model has improved accuracy compared to vanilla quantization, and the gap between ReLU1 model and ReLU6 model is filled, making quantization easier regardless of truncation range. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/12cbe391e91badd0c41d5f78e4fca63cf458a83157db0d49d934f555664757ae.jpg",
+        "table_caption": [
+            "Table 3. CIFAR-10 Experiments tested with $\\epsilon = 2 / 8 / 1 6$ . (B) indicates black-box attack. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Training Technique</td><td>Clean</td><td>Random</td><td>FGSM</td><td>R+FGSM</td><td>PGD</td><td>FGSM(B)</td><td>PGD(B)</td></tr><tr><td>Normal</td><td>94.8</td><td>95/91/77</td><td>59/39/29</td><td>72/37/17</td><td>56/01/00</td><td>88/63/36</td><td>90/64/42</td></tr><tr><td>Normal + DQ</td><td>95.9</td><td>96/94/84</td><td>68/53/42</td><td>77/50/30</td><td>62/04/00</td><td>84/59/40</td><td>87/50/27</td></tr><tr><td>Feature Squeezing</td><td>94.1</td><td>94/92/81</td><td>61/35/27</td><td>76/40/21</td><td>64/02/00</td><td>87/62/30</td><td>89/70/42</td></tr><tr><td>Feature Squeezing + DQ</td><td>94.9</td><td>95/93/82</td><td>66/48/33</td><td>77/51/29</td><td>66/06/01</td><td>87/62/29</td><td>90/70/43</td></tr><tr><td>Adversarial R+FGSM</td><td>91.6</td><td>92/91/91</td><td>81/52/38</td><td>87/69/48</td><td>84/43/11</td><td>92/89/85</td><td>92/91/89</td></tr><tr><td>Adversarial R+FGSM+DQ</td><td>94.0</td><td>94/93/93</td><td>85/63/51</td><td>90/74/58</td><td>87/50/22</td><td>93/91/87</td><td>94/92/92</td></tr><tr><td>Adversarial PGD</td><td>86.6</td><td>86/86/86</td><td>74/46/31</td><td>79/63/46</td><td>76/44/20</td><td>84/83/81</td><td>84/83/83</td></tr><tr><td>Adversarial PGD + DQ</td><td>87.5</td><td>87/87/87</td><td>79/53/36</td><td>83/69/52</td><td>81/50/22</td><td>87786/82</td><td>87/86/86</td></tr></table>",
+        "bbox": [
+            189,
+            131,
+            808,
+            299
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/2daa2326baf725928163557ff32c242ac1bd58f44349f64003af7c24992fe994.jpg",
+        "table_caption": [
+            "Table 4. DQ method improves the training of normal quantized models by limiting the dynamic range of activation. With conventional quantization, ReLU1 suffers from inferior performance than ReLU6. While with DQ, the gap is fixed, ReLU1 and ReLU6 quantized models achieve similar accuracy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>ReLU1</td><td>ReLU6</td><td>Difference</td></tr><tr><td>Vanilla Quantization</td><td>93.49%</td><td>94.41%</td><td>-0.92%</td></tr><tr><td>Defensive Quantization</td><td>95.14%</td><td>95.09%</td><td>0.05%</td></tr></table>",
+        "bbox": [
+            303,
+            376,
+            692,
+            434
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            467,
+            825,
+            523
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            540,
+            318,
+            555
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we aim to raise people’s awareness about the security of the quantized neural networks, which is widely deployed in GPU/TPU/FPGAs, and pave a possible direction to bridge two important areas in deep learning: efficiency and robustness. We connect these two domains by designing a novel Defensive Quantization (DQ) module to defend adversarial attacks while maintain the efficiency. Experimental results on two datasets validate that the new quantization method can make the deep learning models be safely deployed on mobile devices. ",
+        "bbox": [
+            174,
+            570,
+            826,
+            654
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            667,
+            326,
+            681
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We acknowledge Google and Amazon providing us the cloud computing resources. ",
+        "bbox": [
+            174,
+            694,
+            715,
+            709
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "bbox": [
+            176,
+            724,
+            285,
+            741
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. Tensorflow: a system for large-scale machine learning. In OSDI, volume 16, pp. 265–283, 2016. ",
+        "bbox": [
+            174,
+            755,
+            825,
+            797
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dario Amodei, Chris Olah, Jacob Steinhardt, Paul Christiano, John Schulman, and Dan Mane.´ Concrete problems in ai safety. arXiv preprint arXiv:1606.06565, 2016. ",
+        "bbox": [
+            174,
+            810,
+            825,
+            839
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. arXiv preprint arXiv:1802.00420, 2018. ",
+        "bbox": [
+            171,
+            852,
+            825,
+            882
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Peter L Bartlett, Dylan J Foster, and Matus J Telgarsky. Spectrally-normalized margin bounds for neural networks. In Advances in Neural Information Processing Systems, pp. 6240–6249, 2017. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Nicholas Leonard, and Aaron Courville. Estimating or propagating gradients through ´ stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432, 2013. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Moustapha Cisse, Piotr Bojanowski, Edouard Grave, Yann Dauphin, and Nicolas Usunier. Parseval networks: Improving robustness to adversarial examples. arXiv preprint arXiv:1704.08847, 2017. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Courbariaux and Yoshua Bengio. Binarynet: Training deep neural networks with weights and activations constrained to+ 1 or-1. arXiv preprint arXiv:1602.02830, 2016. ",
+        "bbox": [
+            171,
+            176,
+            823,
+            207
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guneet S Dhillon, Kamyar Azizzadenesheli, Zachary C Lipton, Jeremy Bernstein, Jean Kossaifi, Aran Khanna, and Anima Anandkumar. Stochastic activation pruning for robust adversarial defense. arXiv preprint arXiv:1803.01442, 2018. ",
+        "bbox": [
+            176,
+            214,
+            825,
+            257
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Angus Galloway, Graham W Taylor, and Medhat Moussa. Attacking binarized neural networks. arXiv preprint arXiv:1711.00449, 2017. ",
+        "bbox": [
+            169,
+            265,
+            825,
+            295
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples (2014). arXiv preprint arXiv:1412.6572. ",
+        "bbox": [
+            171,
+            301,
+            825,
+            332
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015. ",
+        "bbox": [
+            171,
+            339,
+            823,
+            369
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017. ",
+        "bbox": [
+            176,
+            376,
+            825,
+            420
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Benoit Jacob, Skirmantas Kligys, Bo Chen, Menglong Zhu, Matthew Tang, Andrew Howard, Hartwig Adam, and Dmitry Kalenichenko. Quantization and training of neural networks for efficient integer-arithmetic-only inference. arXiv preprint arXiv:1712.05877, 2017. ",
+        "bbox": [
+            178,
+            426,
+            825,
+            470
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            171,
+            478,
+            826,
+            494
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016. ",
+        "bbox": [
+            171,
+            501,
+            823,
+            531
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Fangzhou Liao, Ming Liang, Yinpeng Dong, Tianyu Pang, Jun Zhu, and Xiaolin Hu. Defense against adversarial attacks using high-level representation guided denoiser. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1778–1787, 2018. ",
+        "bbox": [
+            173,
+            537,
+            823,
+            582
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017. ",
+        "bbox": [
+            174,
+            589,
+            823,
+            632
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. In NIPS workshop on deep learning and unsupervised feature learning, volume 2011, pp. 5, 2011. ",
+        "bbox": [
+            176,
+            640,
+            825,
+            684
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "NVIDIA. Nvidia turing architecture whitepaper. URL https://www.nvidia.com/ content/dam/en-zz/Solutions/design-visualization/technologies/ turing-architecture/NVIDIA-Turing-Architecture-Whitepaper.pdf. ",
+        "bbox": [
+            173,
+            691,
+            825,
+            734
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. arXiv preprint, 2016a. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            785
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In 2016 IEEE Symposium on Security and Privacy (SP), pp. 582–597. IEEE, 2016b. ",
+        "bbox": [
+            173,
+            792,
+            823,
+            837
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Haifeng Qian and Mark N Wegman. L2-nonexpansive neural networks. arXiv preprint arXiv:1802.07896, 2018. ",
+        "bbox": [
+            171,
+            844,
+            825,
+            873
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adnan Siraj Rakin, Jinfeng Yi, Boqing Gong, and Deliang Fan. Defend deep neural networks against adversarial examples via fixed anddynamic quantized activation functions. arXiv preprint arXiv:1807.06714, 2018. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In European Conference on Computer Vision, pp. 525–542. Springer, 2016. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Inverted residuals and linear bottlenecks: Mobile networks for classification, detection and segmentation. arXiv preprint arXiv:1801.04381, 2018. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. ",
+        "bbox": [
+            171,
+            207,
+            825,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yang Song, Taesup Kim, Sebastian Nowozin, Stefano Ermon, and Nate Kushman. Pixeldefend: Leveraging generative models to understand and defend against adversarial examples. arXiv preprint arXiv:1710.10766, 2017. ",
+        "bbox": [
+            176,
+            244,
+            825,
+            286
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dong Su, Huan Zhang, Hongge Chen, Jinfeng Yi, Pin-Yu Chen, and Yupeng Gao. Is robustness the cost of accuracy?–a comprehensive study on the robustness of 18 deep image classification models. arXiv preprint arXiv:1808.01688, 2018. ",
+        "bbox": [
+            173,
+            295,
+            825,
+            338
+        ],
+        "page_idx": 10
+    },
+    {
+        "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,
+            347,
+            825,
+            376
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramer, Alexey Kurakin, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick Mc- \\` Daniel. Ensemble adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017. ",
+        "bbox": [
+            174,
+            385,
+            826,
+            428
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Warde-Farley and Ian Goodfellow. 11 adversarial perturbations of deep neural networks. Perturbations, Optimization, and Statistics, pp. 311, 2016. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            467
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Weilin Xu, David Evans, and Yanjun Qi. Feature squeezing: Detecting adversarial examples in deep neural networks. arXiv preprint arXiv:1704.01155, 2017. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            503
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016. ",
+        "bbox": [
+            173,
+            511,
+            825,
+            540
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shuchang Zhou, Yuxin Wu, Zekun Ni, Xinyu Zhou, He Wen, and Yuheng Zou. Dorefa-net: Training low bitwidth convolutional neural networks with low bitwidth gradients. arXiv preprint arXiv:1606.06160, 2016. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            592
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chenzhuo Zhu, Song Han, Huizi Mao, and William J Dally. Trained ternary quantization. arXiv preprint arXiv:1612.01064, 2016. ",
+        "bbox": [
+            171,
+            602,
+            825,
+            631
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A GRADIENT MASKING OF OTHER METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            570,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 TANH-BASED ACTIVATION QUANTIZATION LEADS TO FAKE SECURITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            705,
+            148
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rakin et al. (2018) tried to use activation quantization as a defense method against adversarial samples. According to their experiments, simply Tanh based activation quantization can greatly improve the model’s robustness under PGD adversarial training setting. We reproduced their experiments by training a ResNet-18 model with PGD adversarial training on CIFAR-10 following Madry et al. (2017). To make a comparison, we also trained a full precision model and a ReLU6 quantized model following same setting. All the quantized models use bi $^ { = 2 }$ . We tested the trained model using PGD attack by Madry et al. (2017) under both white-box and black-box setting. We use a VGG-16 model separately trained with PGD adversarial training as the black-box attacker. The results are provided in Table 5. ",
+        "bbox": [
+            174,
+            160,
+            825,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/eb62c450ccbfe8886cc43b7fb43b9f542b1db88a31c55696a41bd8d968f82e06.jpg",
+        "table_caption": [
+            "Table 5. Tanh-based quantization improves white-box robustness, while suffers from inferior black-box robustness compared to full-precision model. The white-box accuracy is even higher than black-box, suggesting gradient masking. Setup: white-box and black-box robustness of PGD adversarially trained ResNet-18 on CIFAR-10. Quantization uses 2 bits. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Clean Acc.</td><td>White-Box Acc.</td><td>Black-Box Acc.</td></tr><tr><td>Full-Precision</td><td>83.47%</td><td>50.51%</td><td>65.58%</td></tr><tr><td>Tanh Quantized</td><td>81.60%</td><td>71.03%</td><td>61.57%</td></tr><tr><td>ReLU6 Quantized</td><td>78.97%</td><td>48.90%</td><td>59.44%</td></tr></table>",
+        "bbox": [
+            266,
+            368,
+            732,
+            449
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Our white-box result is consistent with (Rakin et al., 2018), where Tanh based quantizaion with PGD training gives much higher white-box accuracy compared to the full precision model. However, we can see that the black-box robustness decreases. Worse still, the black-box attack successful rate is even lower than white-box, which is abnormal since black-box attack is generally weaker than white-box. This phenomenon indicates severe gradient masking problem (Papernot et al., 2016a; Athalye et al., 2018), which gives a false sense of security. As a comparison, we also trained a ReLU6 quantized model. With ReLU6 quantization, there is no sign of gradient masking, nor improvement in robustness, indicating that gradient masking problem majorly comes from Tanh activation function. Actually, ReLU6 quantized model has slightly worse robustness. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            599
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Therefore we conclude that simple quantization cannot help to improve robustness. Instead, it leads to inferior robustness. ",
+        "bbox": [
+            176,
+            606,
+            823,
+            635
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 ADVERSARIAL FGSM TRAINING CAUSES GRADIENT MASKING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            648,
+            663,
+            664
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Here we demonstrate that FGSM adversarial training leads to significant gradient masking problem, while $\\mathrm { R + F G S M }$ fixes such issues. We trained a Wide ResNet using adversarial FGSM and adversarial $\\mathrm { R + F G S M }$ respectively. Then the model is tested using FGSM with $\\epsilon = 8$ under white-box and black-box setting (VGG-16 as substitute). The results are shown in Table ",
+        "bbox": [
+            174,
+            676,
+            825,
+            733
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/d9125ec4325699a005f243bf2bec557a35ac05c336099c9608da0ece1f633930.jpg",
+        "table_caption": [
+            "Table 6. White-box and black-box robustness of FGSM/R $+$ FGSM adversarially trained Wide ResNet on CIFAR-10. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Clean Acc.</td><td>White-Box Acc.</td><td>Black-Box Acc.</td></tr><tr><td>Adversarial FGSM</td><td>94.55%</td><td>94.18%</td><td>51.65%</td></tr><tr><td>Adversarial R+FGSM</td><td>91.61%</td><td>51.65%</td><td>87.39%</td></tr></table>",
+        "bbox": [
+            253,
+            794,
+            743,
+            859
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We can clearly see the same gradient masking effect. For adversarial FGSM training, it gives much higher white box robustness than $\\mathrm { R + F G S M }$ adversarial training, while the black-box robustness is much worse. To avoid gradient masking, we thus use $\\mathrm { R + F G S M }$ adversarial training instead. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B HYPER-PARAMETERS: $\\beta$ STUDY ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            475,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/24334ee8c75cd66a51ecbe9b9fd106ccbe2d6b0b31ef07fd3ca2ab77d2e2b576.jpg",
+        "image_caption": [
+            "Figure 6. Clean and adversarial accuracy of 4-bit quantized Wide ResNet w.r.t. different $\\beta$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            137,
+            728,
+            292
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "As observed in Section 5.1, the adversarial robustness of the model generally increases as $\\beta$ gets larger. Here we aim to find what is the optimal $\\beta$ for our experiment. We took 4-bit quantized Wide ResNet for example. As shown in Figure 6, the adversarial accuracy first gets larger as $\\beta$ increases, and slowly goes down afterwards, reaching peak performance at $\\beta = 0 . 0 0 2$ . The clean accuracy is more stable. At the first stage, as regularization gets stronger, the effect of noise amplify is suppressed more. While for the second stage, the training suffers from a too strong regularization. Therefore, we used a $\\beta = 0 . 0 0 2$ for our experiments unless specified. ",
+        "bbox": [
+            173,
+            332,
+            826,
+            430
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C VISUALIZE SAMPLES AND PREDICTIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            547,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We visualize some of the clean and adversarial samples from CIFAR-10 test set, and the corresponding prediction for full precision model (FP), vanilla 4-bit quantized model (VQ) and our 4-bit Defensive Quantization model (DQ), as 4-bit quantization is now now supported by Tensor Cores with NVIDIA’s Turing Architecture (NVIDIA). Predicted class and probability is provided. Compared to FP and DQ, VQ has worse robustness by misclassifying more adversarial samples (sample 1, 2, 4, 6). Our DQ model enjoys better robustness than FP model in two aspects: 1. our DQ model succeeds to defend some of the attacks when FP failed (sample 5, 7); 2. our DQ model has a better confidence for true label compared to FP model when both succeeds to defend (sample 1, 4, 6). Even when all models fail to defend, our DQ model has the lowest confidence for the misclassified class (sample 3, 8). ",
+        "bbox": [
+            173,
+            131,
+            826,
+            257
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/2156801777e07b0beb707dcc469d27461342850f85114ac60ee0e622f52c6f90.jpg",
+        "image_caption": [
+            "Figure 7. Visualization of adversarial samples and the corresponding predictions (label and probability). FP: full-precision model; VQ: vanilla 4-bit quantized model; DQ: our 4-bit Defensive Quantization model "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            270,
+            777,
+            880
+        ],
+        "page_idx": 13
+    }
+]