Add files using upload-large-folder tool

parse/train/BJgqQ6NYvB/BJgqQ6NYvB.md

@@ -0,0 +1,390 @@
+# FASTERSEG: SEARCHING FOR FASTER REAL-TIME SEMANTIC SEGMENTATION
+
+Wuyang Chen1∗, Xinyu Gong1∗, Xianming Liu2, Qian Zhang2, Yuan $\mathbf { L i } ^ { 2 }$ , Zhangyang Wang1
+
+1Department of Computer Science and Engineering, Texas A&M University 2Horizon Robotics Inc. {wuyang.chen,xy gong,atlaswang}@tamu.edu {xianming.liu,qian01.zhang,yuan.li}@horizon.ai https://github.com/TAMU-VITA/FasterSeg
+
+# ABSTRACT
+
+We present FasterSeg, an automatically designed semantic segmentation network with not only state-of-the-art performance but also faster speed than current methods. Utilizing neural architecture search (NAS), FasterSeg is discovered from a novel and broader search space integrating multi-resolution branches, that has been recently found to be vital in manually designed segmentation models. To better calibrate the balance between the goals of high accuracy and low latency, we propose a decoupled and fine-grained latency regularization, that effectively overcomes our observed phenomenons that the searched networks are prone to “collapsing” to low-latency yet poor-accuracy models. Moreover, we seamlessly extend FasterSeg to a new collaborative search (co-searching) framework, simultaneously searching for a teacher and a student network in the same single run. The teacher-student distillation further boosts the student model’s accuracy. Experiments on popular segmentation benchmarks demonstrate the competency of FasterSeg. For example, FasterSeg can run over $30 \%$ faster than the closest manually designed competitor on Cityscapes, while maintaining comparable accuracy.
+
+# 1 INTRODUCTION
+
+Semantic segmentation predicts pixel-level annotations of different semantic categories for an image. Despite its performance breakthrough thanks to the prosperity of convolutional neural networks (CNNs) (Long et al., 2015), as a dense structured prediction task, segmentation models commonly suffer from heavy memory costs and latency, often due to stacking convolutions and aggregating multiple-scale features, as well as the increasing input image resolutions. However, recent years witness the fast-growing demand for real-time usage of semantic segmentation, e.g., autonomous driving. Such has motivated the enthusiasm on designing low-latency, more efficient segmentation networks, without sacrificing accuracy notably (Zhao et al., 2018; Yu et al., 2018a).
+
+The recent success of neural architecture search (NAS) algorithms has shed light on the new horizon in designing better semantic segmentation models, especially under latency of other resource constraints. Auto-DeepLab (Liu et al., 2019a) first introduced network-level search space to optimize resolutions (in addition to cell structure) for segmentation tasks. Zhang et al. (2019) and Li et al. (2019) adopted pre-defined network-level patterns of spatial resolution, and searched for operators and decoders with latency constraint. Despite a handful of preliminary successes, we observe that the successful human domain expertise in designing segmentation models appears to be not fully integrated into NAS frameworks yet. For example, human-designed architectures for real-time segmentation (Zhao et al., 2018; Yu et al., 2018a) commonly exploit multi-resolution branches with proper depth, width, operators, and downsample rates, and find them contributing vitally to the success: such flexibility has not been unleashed by existing NAS segmentation efforts. Furthermore, the trade-off between two (somewhat conflicting) goals, i.e., high accuracy and low latency, also makes the search process unstable and prone to “bad local minima” architecture options.
+
+As the well-said quote goes: “those who do not learn history are doomed to repeat it”. Inheriting and inspired by the successful practice in hand-crafted efficient segmentation, we propose a novel NAS framework dubbed FasterSeg, aiming to achieve extremely fast inference speed and competitive accuracy. We designed a special search space capable of supporting optimization over multiple branches of different resolutions, instead of a single backbone. These searched branches are adaptively aggregated for the final prediction. To further balance between accuracy versus latency and avoiding collapsing towards either metric (e.g., good latency yet poor accuracy), we design a decoupled and fine-grained latency regularization, that facilitates a more flexible and effective calibration between latency and accuracy. Moreover, our NAS framework can be easily extended to a collaborative search (co-searching), i.e., jointly searching for a complex teacher network and a light-weight student network in a single run, whereas the two models are coupled by feature distillation in order to boost the student’s accuracy. We summarize our main contributions as follows:
+
+• A novel NAS search space tailored for real-time segmentation, where multi-resolution branches can be flexibility searched and aggregated.   
+• A novel decoupled and fine-grained latency regularization, that successfully alleviates the “architecture collapse” problem in the latency-constrained search.   
+• A novel extension to teacher-student co-searching for the first time, where we distill the teacher to the student for further accuracy boost of the latter.   
+• Extensive experiments demonstrating that FasterSeg achieves extremely fast speed (over $30 \%$ faster than the closest manually designed competitor on CityScapes) and maintains competitive accuracy.
+
+# 2 RELATED WORK
+
+Human-designed CNN architectures achieve good accuracy performance nowadays (He et al., 2016; Chen et al., 2018b; Wang et al., 2019; Sun et al., 2019). However, designing architectures to balance between accuracy and other resource constraints (latency, memory, FLOPs, etc.) requires more human efforts. To free human experts from this challenging trade-off, neural architecture search (NAS) has been recently introduced and drawn a booming interest (Zoph & Le, 2016; Brock et al., 2017; Pham et al., 2018; Liu et al., 2018a; Chen et al., 2018a; Bender et al., 2018; Chen et al., 2018c; Gong et al., 2019). These works optimize both accuracy and resource utilization, via a combined loss function (Wu et al., 2019), or a hybrid reward signal for policy learning (Tan et al., 2019; Cheng et al., 2018), or a constrained optimization formulation (Dai et al., 2019).
+
+Most existing resource-aware NAS efforts focus on classification tasks, while semantic segmentation has higher requirements for preserving details and rich contexts, therefore posing more dilemmas for efficient network design. Fortunately, previous handcrafted architectures for real-time segmentation have identified several consistent and successful design patterns. ENet (Paszke et al., 2016) adopted early downsampling, and ICNet (Zhao et al., 2018) further incorporated feature maps from multiresolution branches under label guidance. BiSeNet (Yu et al., 2018a) fused a context path with fast downsampling and a spatial path with smaller filter strides. More works target on segmentation efficiency in terms of computation cost (He et al., 2019; Marin et al., 2019) and memory usage (Chen et al., 2019). Their multi-resolution branching and aggregation designs ensure sufficiently large receptive fields (contexts) while preserving high-resolution fine details, providing important clues on how to further optimize the architecture.
+
+There have been recent studies that start pointing NAS algorithms to segmentation tasks. AutoDeepLab (Liu et al., 2019a) pioneered in this direction by searching the cells and the networklevel downsample rates, to flexibly control the spatial resolution changes throughout the network. Zhang et al. (2019) and Li et al. (2019) introduced resource constraints into NAS segmentation. A multi-scale decoder was also automatically searched (Zhang et al., 2019). However, compared with manually designed architectures, those search models still follow a single-backbone design and did not fully utilize the prior wisdom (e.g., multi-resolution branches) in designing their search spaces.
+
+Lastly, we briefly review knowledge distillation (Hinton et al., 2015), that aims to transfer learned knowledge from a sophisticated teacher network to a light-weight student, to improve the (more efficient) student’s accuracy. For segmentation, Liu et al. (2019b) and Nekrasov et al. (2019) proposed to leverage knowledge distillation to improve the accuracy of the compact model and speed-up convergence. There was no prior work in linking distillation with NAS yet, and we will introduce the extension of FasterSeg by integrating teacher-student model collaborative search for the first time.
+
+# 3 FASTERSEG: FASTER REAL-TIME SEGMENTATION
+
+Our FasterSeg is discovered from an efficient and multi-resolution search space inspired by previous manual design successes. A fine-grained latency regularization is proposed to overcome the challenge of “architecture collapse” (Cheng et al., 2018). We then extend our FasterSeg to a teacherstudent co-searching framework, further resulting in a lighter yet more accurate student network.
+
+# 3.1 EFFICIENT SEARCH SPACE WITH MULTI-RESOLUTION BRANCHING
+
+The core motivation behind our search space is to search multi-resolution branches with overall low latency, which has shown effective in previous manual design works (Zhao et al., 2018; Yu et al., 2018a). Our NAS framework automatically selects and aggregates branches of different resolutions, based on efficient cells with searchable superkernels.
+
+![](images/b3bd260199aaf4b654b0928e1011226f6d503e7862066948ccfc768299dce006.jpg)  
+Figure 1: The multi-resolution branching search space for FasterSeg, where we aim to optimize multiple branches with different output resolutions. These outputs are progressively aggregated together in the head module. Each cell is individually searchable and may have two inputs and two outputs, both of different downsampling rates (s). Inside each cell, we enable searching for expansion ratios within a single superkernel.
+
+# 3.1.1 SEARCHABLE MULTI-RESOLUTION BRANCHES
+
+Inspired by (Liu et al., 2019a), we enable searching for spatial resolutions within the $L$ -layer cells (Figure 1), where each cell takes inputs from two connected predecessors and outputs two feature maps of different resolutions. Hand-crafted networks for real-time segmentation found multi-branches of different resolutions to be effective (Zhao et al., 2018; Yu et al., 2018a). However, architectures explored by current NAS algorithms are restricted to a single backbone.
+
+Our goal is to select $b$ $\left( b > 1 \right)$ ) branches of different resolutions in this $L$ -layer framework. Specifically, we could choose $b$ different final output resolutions for the last layer of cells, and decode each branch via backtrace (section 3.4). This enables our NAS framework to explore $b$ individual branches with different resolutions, which are progressively “learned to be aggregated” by the head module (Figure 1).
+
+![](images/b8d95424018b93142e9e9a55ba89868a865648c466bedd6320035f5894d75743.jpg)  
+Figure 2: Our multi-resolution search space covers existing manual designs for real-time segmentation (unused cells omitted). Top: ICNet (Zhao et al., 2018). Bottom: BiSeNet (Yu et al., 2018a)
+
+We follow the convention to increase the number of channels at each time of resolution downsampling. To enlarge the model capacity without incurring much latency, we first downsample the input image to $\frac { 1 } { 8 }$ original scale with our stem module, and then set our searchable downsample rates $s \in \{ 8 , 1 \breve { 6 } , 3 2 \}$ . Figure 2 shows that our multi-resolution search space is able to cover existing human-designed networks for real-time segmentation. See Appendix B for branch selection details.
+
+# 3.1.2 CHOOSING EFFICIENT OPERATORS WITH LARGE RECEPTIVE FIELDS
+
+As we aim to boost the inference latency, the speed of executing an operator is a direct metric (rather than indirect metrics like FLOPs) for selecting operator candidates $\mathcal { O }$ . Meanwhile, as we previously discussed, it is also important to ensure sufficiently large receptive field for spatial contexts. We analyze typical operators, including their common surrogate latency measures (FLOPs, parameter numbers), and their real-measured latency on an NVIDIA 1080Ti GPU with TensorRT library, and their receptive fields, as summarized in Table 1.
+
+Compared with standard convolution, group convolution is often used for reducing FLOPs and number of parameters (Sandler et al., 2018; Ma et al., 2018). Convolving with two groups has the same receptive field with a standard convolution but is $13 \%$ faster, while halving the parameter amount (which might not be preferable as it reduces the model learning capacity). Dilated convolution has an enlarged receptive field and is popular in dense predictions (Chen et al., 2018b; Dai et al., 2017). However, as shown in Table 1 (and as widely acknowledged in engineering practice), dilated convolution (with dilation rate 2) suffers from dramatically higher latency, although that was not directly reflected in FLOPs nor parameter numbers. In view of that, we design a new variant called “zoomed convolution”, where the input feature map is sequentially processed with bilinear downsampling, standard convolution, and bilinear upsampling. This special design enjoys $40 \%$ lower latency and 2 times larger receptive field compared to standard convolution. Our search space hence consists of the following operators:
+
+• $3 \times 3$ conv. $\times 2$
+
+• “zoomed conv.”: bilinear downsampling $+ \ 3 \times 3$ conv. $^ +$ bilinear upsampling • “zoomed conv. $\times 2 ^ { , , }$ : bilinear downsampling $+ \ 3 \times 3$ conv. $\times 2 +$ bilinear upsampling
+
+As mentioned by Ma et al. (2018), network fragmentation can significantly hamper the degree of parallelism, and therefore practical efficiency. Therefore, we choose a sequential search space (rather than a directed acyclic graph of nodes (Liu et al., 2018b)), i.e., convolutional layers are sequentially
+
+Table 1: Specifications of different convolutions. Latency is measured using an input of size $1 \times 2 5 6 \times 3 2 \times 6 4$ on $1 0 8 0 \mathrm { T i }$ with TensorRT library. Each operator only contains one convolutional layer. The receptive field (RF) is relatively compared with the standard convolution (first row).   
+
+<table><tr><td>Layer Type</td><td>Latency (ms)</td><td>FLOPs (G)</td><td>Params (M)</td><td>RF*</td></tr><tr><td>conv.</td><td>0.15</td><td>1.21</td><td>0.59</td><td>1</td></tr><tr><td>conv. group2</td><td>0.13(-13%)</td><td>0.60(-50%)</td><td>0.29 (-51%)</td><td>1</td></tr><tr><td>conv. dilation2</td><td>0.25(+67%)</td><td>1.10(-9%)</td><td>0.59</td><td>2</td></tr><tr><td>zoomed conv.</td><td>0.09 (-40%)</td><td>0.30(-75%)</td><td>0.59</td><td>2</td></tr></table>
+
+stacked in our network. In Figure 1, each cell is differentiable (Liu et al., 2018b; 2019a) and will contain only one operator, once the discrete architecture is derived (section 3.4). It is worth noting that we allow each cell to be individually searchable across the whole search space.
+
+# 3.1.3 SEARCHABLE SUPERKERNEL FOR EXPANSION RATIOS
+
+We further give each cell the flexibility to choose different channel expansion ratios. In our work, we search for the width of the connection between successive cells. That is however non-trivial due to the exponentially possible combinations of operators and widths. To tackle this problem, we propose a differentiably searchable superkernel, i.e., directly searching for the expansion ratio $\chi$ within a single convolutional kernel which supports a set of ratios $ { \mathcal { X } } \subseteq N ^ { + }$ . Inspired by (Yu et al., 2018c) and (Stamoulis et al., 2019), from slim to wide our connections incrementally take larger subsets of input/output dimensions from the superkernel. During the architecture search, for each superkernel, only one expansion ratio is sampled, activated, and back-propagated in each step of stochastic gradient descent. This design contributes to a simplified and memory-efficient super network and is implemented via the renowned “Gumbel-Softmax” trick (see Appendix C for details).
+
+To follow the convention to increase the number of channels as resolution downsampling, in our search space we consider the width $= \chi \times s$ , where $s \in \{ 8 , 1 6 , 3 2 \}$ . We allow connections between each pair of successive cells flexibly choose its own expansion ratio, instead of using a unified single expansion ratio across the whole search space.
+
+# 3.1.4 CONTINUOUS RELAXATION OF SEARCH SPACE
+
+Denote the downsample rate as $s$ and layer index as $l$ . To facilitate the search of spatial resolutions, we connect each cell with two possible predecessors’ outputs with different downsample rates:
+
+$$
+\overline { { I } } _ { s , l } = \beta _ { s , l } ^ { 0 } \overline { { O } } _ { \frac { s } { 2 }  s , l - 1 } + \beta _ { s , l } ^ { 1 } \overline { { O } } _ { s  s , l - 1 }
+$$
+
+Each cell could have at most two outputs with different downsample rates into its successors:
+
+$$
+\begin{array} { r l r } {  { \overline { { O } } _ { s \to s , l } = \sum _ { k = 1 } ^ { | \mathcal { O } | } \alpha _ { s , l } ^ { k } O _ { s \to s , l } ^ { k } ( \overline { { I } } _ { s , l } , \chi _ { s , l } ^ { j } , \mathrm { s t r i d e = 1 } ) } } \\ & { } & { \overline { { O } } _ { s \to 2 s , l } = \sum _ { k = 1 } ^ { | \mathcal { O } | } \alpha _ { s , l } ^ { k } O _ { s \to 2 s , l } ^ { k } ( \overline { { I } } _ { s , l } , \chi _ { s , l } ^ { j } , \mathrm { s t r i d e = 2 } ) . } \end{array}
+$$
+
+The expansion ratio $\chi _ { s , l } ^ { j }$ is sampled via “Gumbel-Softmax” trick according to $p ( \chi = \chi _ { s , l } ^ { j } ) = \gamma _ { s , l } ^ { j }$ . Here, $\alpha , \beta$ , and $\gamma$ are all normalized scalars, associated with each operator $O ^ { k } \in \mathcal { O }$ , each predecessor’s output $\overline { { O } } _ { l - 1 }$ , and each expansion ratio $\chi \in \mathcal X$ , respectively (Appendix D). They encode the architectures to be optimized and derived.
+
+# 3.2 REGULARIZED LATENCY OPTIMIZATION WITH FINER GRANULARITY
+
+Low latency is desirable yet challenging to optimize. Previous works (Cheng et al., 2018; Zhang et al., 2019) observed that during the search procedure, the supernet or search policy often fall into bad “local minimums” where the generated architectures are of extremely low latency but with poor accuracy, especially in the early stage of exploration. In addition, the searched networked tend to use more skip connections instead of choosing low expansion ratios (Shaw et al., 2019). This problem is termed as “architecture collapse” in our paper. The potential reason is that, finding architectures with extremely low latency (e.g. trivially selecting the most light-weight operators) is significantly easier than discovering meaningful compact architectures of high accuracy.
+
+![](images/d70f3138595d7ee2a1719b713d86d53da07cd9c555245e286159689880f1dc4a.jpg)  
+Figure 3: Correlation between network latency and its estimation via our latency lookup table (linear coefficient: 0.993). Red line indicates $ { { } ^ { * } } y = x ^ { * }$ .
+
+To address this “architecture collapse” problem, we for the first time propose to leverage a fine-grained, decoupled latency regularization. We first achieve the continuous relaxation of latency similar to the cell operations in section 3.1.4, via replacing the operator $O$ in Eqn. 1 and 2 with the corresponding latency. We build a latency lookup table that covers all possible operators to support the estimation of the relaxed latency. Figure 3 demonstrates the high correlation of 0.993 between the real and estimated latencies (see details in appendix E).
+
+We argue that the core reason behind the “architecture collapse” problem is the different sensitivities of supernet to operator $O$ , downsample rate $s$ , and expansion ratio $\chi$ . Operators like ${ ^ { 6 6 } 3 } \times 3$ conv. $\times 2 ^ { , , }$ and “zoomed conv.” have a huge gap in latency. Similar latency gap (though more moderate) exists between slim and wide expansion ratios. However, downsample rates like “8” and $\mathbf { \vec { 3 } } \mathbf { 2 } ^ { , }$ do not differ much, since resolution downsampling also brings doubling of the number of both input and output channels.
+
+Table 2: Supernet’s sensitivity to latency under different granularities. Input size: (1, 3, 1024, 2048).   
+
+<table><tr><td>Granularity</td><td>△Latency (ms)</td></tr><tr><td>O (operator)</td><td>10.42</td></tr><tr><td>s (downsample rate)</td><td>0.01</td></tr><tr><td>X(expansion ratio)</td><td>5.54</td></tr></table>
+
+We quantitatively compared the influence of $O$ , $s$ , and $\chi$ towards the supernet latency, by adjusting one of the three aspects and fixing the other two. Taking $O$ as the example, we first uniformly initialize $\beta$ and $\gamma$ , and calculate ∆Latency $( O )$ as the gap between the supernet which dominantly takes the slowest operators and the one adopts the fastest. Similar calculations were performed for $s$ and $\chi$ . Values of $\Delta$ Latency in Table 2 indicate the high sensitivity of the supernet’s latency to operators and expansion ratios, while not to resolutions. Figure 4(a) shows that the unregularized latency optimization will bias the supernet towards light-weight operators and slim expansion ratios to quickly minimize the latency, ending up with problematic architectures with low accuracy.
+
+Based on this observation, we propose a regularized latency optimization leveraging different granularities of our search space. We decouple the calculation of supernet’s latency into three granularities of our search space $( O , s , \chi )$ , and regularize each aspect with a different factor:
+
+$$
+\mathrm { L a t e n c y } ( O , s , \chi ) = w _ { 1 } \mathrm { L a t e n c y } ( O | s , \chi ) + w _ { 2 } \mathrm { L a t e n c y } ( s | O , \chi ) + w _ { 3 } \mathrm { L a t e n c y } ( \chi | O , s )
+$$
+
+where we by default set $w _ { 1 } = 0 . 0 0 1$ , $w _ { 2 } = 0 . 9 9 7$ , $w _ { 3 } = 0 . 0 0 2 ^ { 1 }$ . This decoupled and fine-grained regularization successfully addresses this “architecture collapse” problem, as shown in Figure 4(b).
+
+![](images/d493b2bc1a8149f129a23284547e3f39631109578c18432df6c493308a349bb8.jpg)  
+Figure 4: Comparing mIoU $( \% )$ and latency (ms) between supernets. The search is conducted on the Cityscapes training set and mIoU is measured on the validation set.
+
+# 3.3 TEACHER/STUDENT CO-SEARCHING FOR KNOWLEDGE DISTILLATION
+
+Knowledge Distillation is an effective approach to transfer the knowledge learned by a large and complex network (teacher $\tau$ ) into a much smaller network (student $s$ ). In our NAS framework, we can seamlessly extend to teacher-student cosearching, i.e., collaboratively searching for two networks in a single run (Figure 5). Specifically, we search a complex teacher and light-weight student simultaneously via adopting two sets of architectures in one supernet: $( \alpha \tau , \beta \tau )$ and $( \alpha _ { S } , \beta _ { S } , \gamma _ { S } )$ . Note that the teacher does not search the expansion ratios and always select the widest one.
+
+![](images/ac3dc9a0c3ce5df37ce9b18c5231ccec19510c7c0e37f8ebf1d10e913fe97c3a.jpg)  
+Figure 5: Our co-searching framework, which optimizes two architectures during search (left orange) and distills from a complex teacher to a light student during training from scratch (right green).
+
+This extension does not bring any overhead in memory usage or size of supernet since the teacher and student share the same supernet weights $W$ during the search process. Two sets of architectures are iteratively optimized during search (please see details in Appendix F), and we apply the latency constraint only on the student, not on the teacher. Therefore, our searched teacher is a sophisticated network based on the same search space and supernet weights $W$ used by the student . During training from scratch, we apply a distillation loss from teacher $\tau$ to student $s$ :
+
+KL denotes the KL divergence. $\mathbf { q } _ { i } ^ { s }$ and $\mathbf { q } _ { i } ^ { t }$ are predicted logit for pixel $i$ from $s$ and $\tau$ , respectively.   
+Equal weights (1.0) are assigned to the segmentation loss and this distillation loss.
+
+# 3.4 DERIVING DISCRETE ARCHITECTURES
+
+Once the search is completed, we derive our discrete architecture from $\alpha , \beta$ , and $\gamma$ :
+
+• $\alpha , \gamma$ : We select the optimum operators and expansion ratios by taking the argmax of $\alpha$ and $\gamma$ . We shrink the operator “skip connection” to obtain a shallower architecture with less cells. • $\beta$ : Different from (Liu et al., 2019a), for each $\mathrm { c e l l } _ { s , l }$ we consider $\beta ^ { 0 }$ and $\beta ^ { 1 }$ as probabilities of two outputs from $\mathrm { c e l l } _ { \frac { s } { 2 } , l - 1 }$ and $\mathrm { c e l l } _ { s , l - 1 }$ into $\mathrm { c e l l } _ { s , l }$ . Therefore, by taking the $l ^ { * } = \mathrm { a r g m a x } _ { l } ( \beta _ { s , l } ^ { 0 } )$ , we find the optimum position $\begin{array} { r } { ( \mathrm { c e l l } _ { s , l ^ { * } } . } \end{array}$ ) where to downsample the current resolution $( \frac { s } { 2 }  s )$ ). 2
+
+It is worth noting that, the multi-resolution branches will share both cell weights and feature maps if their cells are of the same operator type, spatial resolution, and expansion ratio. This design contributes to a faster network. Once cells in branches diverge, the sharing between the branches will be stopped and they become individual branches (See Figure 6).
+
+# 4 EXPERIMENTS
+
+# 4.1 DATASETS AND IMPLEMENTATIONS
+
+We use the Cityscapes (Cordts et al., 2016) as a testbed for both our architecture search and ablation studies. After that, we report our final accuracy and latency on Cityscapes, CamVid (Brostow et al., 2008), and BDD (Yu et al., 2018b). In all experiments, the class mIoU (mean Intersection over Union per class) and FPS (frame per second) are used as the metrics for accuracy and speed, respectively. Please see Appendix G for dataset details.
+
+In all experiments, we use Nvidia Geforce GTX 1080Ti for benchmarking the computing power. We employ the high-performance inference framework TensorRT v5.1.5 and report the inference speed. During this inference measurement, an image of a batch size of 1 is first loaded into the graphics memory, then the model is warmed up to reach a steady speed, and finally, the inference time is measured by running the model for six seconds. All experiments are performed under CUDA 10.0 and CUDNN V7. Our framework is implemented with PyTorch. The search, training, and latency measurement codes are available at https://github.com/TAMU-VITA/FasterSeg.
+
+# 4.2 ARCHITECTURE SEARCH
+
+We consider a total of $L = 1 6$ layers in the supernet and our downsample rate $s \in \{ 8 , 1 6 , 3 2 \}$ . In our work we use number of branches $b = 2$ by default, since more branches will suffer from high latency. We consider expansion ratio $\chi _ { s , l } \in \mathcal { X } = \{ 4 , 6 , 8 , 1 0 , 1 2 \}$ for any “downsample rate” $s$ and layer $l$ . The multi-resolution branches have 1695 unique paths. For cells and expansion ratios, we have $( 1 + 4 \times 5 ) ^ { ( 1 5 + 1 4 + 1 3 ) } + 5 ^ { 3 } \approx 3 . 4 \times 1 0 ^ { 5 5 }$ unique combinations. This results in a search space in the order of $1 0 ^ { 5 8 }$ , which is much larger and challenging, compared with preliminary studies.
+
+Architecture search is conducted on Cityscapes training dataset. Figure 6 visualizes the best spatial resolution discovered (FasterSeg). Our FasterSeg achieved mutli-resolutions with proper depths. The two branches share the first three operators then diverge, and choose to aggregate outputs with downsample rates of 16 and 32. Oper
+
+![](images/2ea0df57d1234a967a9286eb823fa866e296ad9cf00d801d2013c89579c5c5bc.jpg)  
+Figure 6: FasterSeg network discovered by our NAS framework.
+
+ators and expansion ratios are listed in Table 7 in Appendix I, where the zoomed convolution is heavily used, suggesting the importance of low latency and large receptive field.
+
+4.3 EVALUATION OF MULTI-RESOLUTION SEARCH SPACE AND CO-SEARCHING
+
+We conduct ablation studies on Cityscapes to evaluate the effectiveness of our NAS framework. More specifically, we examine the impact of operators $( O )$ , downsample rate (s), expansion ratios $( \chi )$ , and also distillation on the accuracy and latency. When we expand from a single backbone $b = 1 ,$ ) to multi-branches $( b \ = \ 2 )$ , our FPS drops but we gain a much improvement on mIoU, indicating the multiresolution design is beneficial for
+
+Table 3: Ablation studies of different search and training strategies. mIoU is measured on Cityscapes validation set. The input resolution is $1 0 2 4 \times 2 0 4 8$ . $O$ : operator; $s$ : downsample rate; $\chi$ : expansion ratios; $^ { b }$ : number of branches; $\stackrel { 6 6 } {  } \bar { \cdot }$ : knowledge distillation.   
+
+<table><tr><td>Settings</td><td>mIoU (%)</td><td>FPS</td><td>FLOPs</td><td>#Params</td></tr><tr><td>O,s|x=8,b=1</td><td>66.9</td><td>177.8</td><td>27.0G</td><td>6.3M</td></tr><tr><td>O,sx=8,b=2</td><td>69.5</td><td>119.9</td><td>42.8 G</td><td>10.8M</td></tr><tr><td colspan="5">Teacher(T) )Student (S) Co-searching</td></tr><tr><td>S: O,s,x|b= 2</td><td>70.5</td><td>163.9</td><td>28.2G</td><td>4.4 M</td></tr><tr><td>T → pruned T</td><td>66.1</td><td>146.7</td><td>29.5 G</td><td>4.7 M</td></tr><tr><td>T → S(FasterSeg)</td><td>73.1</td><td>163.9</td><td>28.2G</td><td>4.4 M</td></tr></table>
+
+segmentation task. By enabling the search for expansion ratios $( \chi )$ , we discover a faster network with FPS 163.9 without sacrificing accuracy $( 7 0 . 5 \% )$ , which proves that the searchable superkernel gets the benefit from eliminating redundant channels while maintaining high accuracy. This is our student network $( S )$ discovered in our co-searching framework (see below).
+
+We further evaluate the efficacy of our teacher-student co-searching framework. After the collaboratively searching, we obtain a teacher architecture $( \mathcal { T } )$ and a student architecture $( S )$ . As mentioned above, $s$ is searched with searchable expansion ratios $( \chi )$ , achieving an FPS of 163.9 and an mIoU of $70 . 5 \%$ . In contrast, when we directly compress the teacher (channel pruning via selecting the slimmest expansion ratio) and train with distillation from the well-trained original cumbersome teacher, it only achieved mIo $U = 6 6 . 1 \%$ with only $\mathrm { F P S } = 1 4 6 . 7$ , indicating that our architecture cosearching surpass the pruning based compression. Finally, when we adopt the knowledge distillation from the well-trained cumbersome teacher to our searched student, we boost the student’s accuracy to $7 3 . 1 \%$ , which is our final network FasterSeg. This demonstrates that both a student discovered by co-searching and training with knowledge distillation from the teacher are vital for obtaining an accurate faster real-time segmentation model.
+
+# 4.4 REAL-TIME SEMANTIC SEGMENTATION
+
+In this section, we compare our FasterSeg with other works for real-time semantic segmentation on three popular scene segmentation datasets. Note that since we target on real-time segmentation, we measure the mIoU without any evaluation tricks like flipping, multi-scale, etc.
+
+Cityscapes: We evaluate FasterSeg on Cityscapes validation and test sets. We use original image resolution of $1 0 2 4 \times 2 0 4 8$ to measure both mIoU and speed inference. In Table 4, we see the superior FPS (163.9) of our FasterSeg, even under the maximum image resolution. This high FPS is over $1 . 3 \times$ faster than human-designed
+
+Table 4: mIoU and inference FPS on Ciytscapes validation and test sets.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">mIoU (%)</td><td rowspan="2">FPS</td><td rowspan="2">Resolution</td></tr><tr><td>val</td><td>test</td></tr><tr><td>ENet (Paszke et al.,2016)</td><td>=</td><td>58.3</td><td>76.9</td><td>512×1024</td></tr><tr><td>ICNet (Zhao et al., 2018)</td><td>67.7</td><td>69.5</td><td>37.7</td><td>1024×2048</td></tr><tr><td>BiSeNet (Yu et al.,2018a)</td><td>69.0</td><td>68.4</td><td>105.8</td><td>768×1536</td></tr><tr><td>CAS (Zhang et al., 2019)</td><td>71.6</td><td>70.5</td><td>108.0</td><td>768×1536</td></tr><tr><td>Fast-SCNN (Poudel et al., 2019)</td><td>68.6</td><td>68.0</td><td>123.5</td><td>1024×2048</td></tr><tr><td>DF1-Seg-d8 (Li et al.,2019)</td><td>72.4</td><td>71.4</td><td>136.9</td><td>1024×2048</td></tr><tr><td>FasterSeg (ours)</td><td>73.1</td><td>71.5</td><td>163.9</td><td>1024×2048</td></tr></table>
+
+networks. Meanwhile, our FasterSeg still maintains competitive accuracy, which is $7 3 . 1 \%$ on the validation set and $7 1 . 5 \%$ on the test set. This accuracy is achieved with only Cityscapes fine-annotated images, without using any extra data (coarse-annotated images, ImageNet, etc.).
+
+CamVid: We directly transfer the searched architecture on Cityscapes to train on CamVid. Table 5 reveals that without sacrificing much accuracy, our FasterSeg achieved an FPS of 398.1. This extremely high speed is over $47 \%$ faster than the closest competitor in FPS (Yu et al., 2018a), and is over two times faster than the work with the best mIoU (Zhang et al., 2019). This impressive result verifies both the high performance of FasterSeg and also the transferability of our NAS framework.
+
+BDD: In addition, we also directly transfer the learned architecture to the BDD dataset. In Table 6 we compare our FasterSeg with the baseline provided by Yu et al. (2018b). Since no previous work has considered real-time segmentation on the BDD dataset, we get 15 times faster than the DRN-D22 with slightly higher mIoU. Our FasterSeg still preserve the extremely fast speed and competitive accuracy on BDD.
+
+Table 5: mIoU and inference FPS on CamVid test set. The input resolution is $7 2 0 \times 9 6 0$ .   
+
+<table><tr><td>Method</td><td>mIoU (%)</td><td>FPS</td></tr><tr><td>ENet (Paszke et al., 2016)</td><td>68.3</td><td>61.2</td></tr><tr><td>ICNet (Zhao et al., 2018)</td><td>67.1</td><td>27.8</td></tr><tr><td>BiSeNet (Yu et al., 2018a)</td><td>65.6</td><td>269.1</td></tr><tr><td>CAS (Zhang et al., 2019)</td><td>71.2</td><td>169.0</td></tr><tr><td>FasterSeg (ours)</td><td>71.1</td><td>398.1</td></tr></table>
+
+Table 6: mIoU and inference FPS on BDD validation set. The input resolution is $7 2 0 \times 1 2 8 0$ .   
+
+<table><tr><td>Method</td><td>mIoU (%)</td><td>FPS</td></tr><tr><td>DRN-D-22 (Yu et al., 2017)</td><td>53.2</td><td>21.0</td></tr><tr><td>DRN-D-38 (Yu et al., 2017)</td><td>55.2</td><td>12.9</td></tr><tr><td>FasterSeg (ours)</td><td>55.1</td><td>318.0</td></tr></table>
+
+# 5 CONCLUSION
+
+We introduced a novel multi-resolution NAS framework, leveraging successful design patterns in handcrafted networks for real-time segmentation. Our NAS framework can automatically discover FasterSeg, which achieved both extremely fast inference speed and competitive accuracy. Our search space is intrinsically of low-latency and is much larger and challenging due to flexible searchable expansion ratios. More importantly, we successfully addressed the “architecture collapse” problem, by proposing the novel regularized latency optimization of fine-granularity. We also demonstrate that by seamlessly extending to teacher-student co-searching, our NAS framework can boost the student’s accuracy via effective distillation.
+
+# REFERENCES
+
+Gabriel Bender, Pieter-Jan Kindermans, Barret Zoph, Vijay Vasudevan, and Quoc Le. Understanding and simplifying one-shot architecture search. In International Conference on Machine Learning, pp. 549–558, 2018.
+
+Andrew Brock, Theodore Lim, James M Ritchie, and Nick Weston. Smash: one-shot model architecture search through hypernetworks. arXiv preprint arXiv:1708.05344, 2017.
+
+Gabriel J Brostow, Jamie Shotton, Julien Fauqueur, and Roberto Cipolla. Segmentation and recognition using structure from motion point clouds. In European conference on computer vision, pp. 44–57. Springer, 2008.
+
+Liang-Chieh Chen, Maxwell Collins, Yukun Zhu, George Papandreou, Barret Zoph, Florian Schroff, Hartwig Adam, and Jon Shlens. Searching for efficient multi-scale architectures for dense image prediction. In Advances in Neural Information Processing Systems, pp. 8699–8710, 2018a.
+
+Liang-Chieh Chen, Yukun Zhu, George Papandreou, Florian Schroff, and Hartwig Adam. Encoderdecoder with atrous separable convolution for semantic image segmentation. In Proceedings of the European conference on computer vision (ECCV), pp. 801–818, 2018b.
+
+Wuyang Chen, Ziyu Jiang, Zhangyang Wang, Kexin Cui, and Xiaoning Qian. Collaborative globallocal networks for memory-efficient segmentation of ultra-high resolution images. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 8924–8933, 2019.
+
+Yukang Chen, Gaofeng Meng, Qian Zhang, Xinbang Zhang, Liangchen Song, Shiming Xiang, and Chunhong Pan. Joint neural architecture search and quantization. arXiv preprint arXiv:1811.09426, 2018c.
+
+An-Chieh Cheng, Chieh Hubert Lin, Da-Cheng Juan, Wei Wei, and Min Sun. Instanas: Instanceaware neural architecture search. arXiv preprint arXiv:1811.10201, 2018.
+
+Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The cityscapes dataset for semantic urban scene understanding. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3213–3223, 2016.
+
+Jifeng Dai, Haozhi Qi, Yuwen Xiong, Yi Li, Guodong Zhang, Han Hu, and Yichen Wei. Deformable convolutional networks. In Proceedings of the IEEE international conference on computer vision, pp. 764–773, 2017.
+
+Xiaoliang Dai, Peizhao Zhang, Bichen Wu, Hongxu Yin, Fei Sun, Yanghan Wang, Marat Dukhan, Yunqing Hu, Yiming Wu, Yangqing Jia, et al. Chamnet: Towards efficient network design through platform-aware model adaptation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 11398–11407, 2019.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009.
+
+Xinyu Gong, Shiyu Chang, Yifan Jiang, and Zhangyang Wang. Autogan: Neural architecture search for generative adversarial networks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3224–3234, 2019.
+
+Emil Julius Gumbel. Statistical theory of extreme values and some practical applications. NBS Applied Mathematics Series, 33, 1954.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Tong He, Chunhua Shen, Zhi Tian, Dong Gong, Changming Sun, and Youliang Yan. Knowledge adaptation for efficient semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 578–587, 2019.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Xin Li, Yiming Zhou, Zheng Pan, and Jiashi Feng. Partial order pruning: for best speed/accuracy trade-off in neural architecture search. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9145–9153, 2019.
+
+Chenxi Liu, Barret Zoph, Maxim Neumann, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan Yuille, Jonathan Huang, and Kevin Murphy. Progressive neural architecture search. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 19–34, 2018a.
+
+Chenxi Liu, Liang-Chieh Chen, Florian Schroff, Hartwig Adam, Wei Hua, Alan L Yuille, and Li FeiFei. Auto-deeplab: Hierarchical neural architecture search for semantic image segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 82–92, 2019a.
+
+Hanxiao Liu, Karen Simonyan, and Yiming Yang. Darts: Differentiable architecture search. arXiv preprint arXiv:1806.09055, 2018b.
+
+Yifan Liu, Ke Chen, Chris Liu, Zengchang Qin, Zhenbo Luo, and Jingdong Wang. Structured knowledge distillation for semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2604–2613, 2019b.
+
+Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3431–3440, 2015.
+
+Ningning Ma, Xiangyu Zhang, Hai-Tao Zheng, and Jian Sun. Shufflenet v2: Practical guidelines for efficient cnn architecture design. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 116–131, 2018.
+
+Chris J Maddison, Daniel Tarlow, and Tom Minka. $\mathbf { A } ^ { * }$ sampling. In Advances in Neural Information Processing Systems, pp. 3086–3094, 2014.
+
+Dmitrii Marin, Zijian He, Peter Vajda, Priyam Chatterjee, Sam Tsai, Fei Yang, and Yuri Boykov. Efficient segmentation: Learning downsampling near semantic boundaries. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2131–2141, 2019.
+
+Vladimir Nekrasov, Hao Chen, Chunhua Shen, and Ian Reid. Fast neural architecture search of compact semantic segmentation models via auxiliary cells. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9126–9135, 2019.
+
+Adam Paszke, Abhishek Chaurasia, Sangpil Kim, and Eugenio Culurciello. Enet: A deep neural network architecture for real-time semantic segmentation. arXiv preprint arXiv:1606.02147, 2016.
+
+Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. arXiv preprint arXiv:1802.03268, 2018.
+
+Rudra PK Poudel, Stephan Liwicki, and Roberto Cipolla. Fast-scnn: fast semantic segmentation network. arXiv preprint arXiv:1902.04502, 2019.
+
+Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4510–4520, 2018.
+
+Albert Shaw, Daniel Hunter, Forrest Iandola, and Sammy Sidhu. Squeezenas: Fast neural architecture search for faster semantic segmentation. arXiv preprint arXiv:1908.01748, 2019.
+
+Dimitrios Stamoulis, Ruizhou Ding, Di Wang, Dimitrios Lymberopoulos, Bodhi Priyantha, Jie Liu, and Diana Marculescu. Single-path nas: Designing hardware-efficient convnets in less than 4 hours. arXiv preprint arXiv:1904.02877, 2019.
+
+Ke Sun, Bin Xiao, Dong Liu, and Jingdong Wang. Deep high-resolution representation learning for human pose estimation. arXiv preprint arXiv:1902.09212, 2019.
+
+Mingxing Tan, Bo Chen, Ruoming Pang, Vijay Vasudevan, Mark Sandler, Andrew Howard, and Quoc V Le. Mnasnet: Platform-aware neural architecture search for mobile. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2820–2828, 2019.
+
+Jingdong Wang, Ke Sun, Tianheng Cheng, Borui Jiang, Chaorui Deng, Yang Zhao, Dong Liu, Yadong Mu, Mingkui Tan, Xinggang Wang, et al. Deep high-resolution representation learning for visual recognition. arXiv preprint arXiv:1908.07919, 2019.
+
+Bichen Wu, Xiaoliang Dai, Peizhao Zhang, Yanghan Wang, Fei Sun, Yiming Wu, Yuandong Tian, Peter Vajda, Yangqing Jia, and Kurt Keutzer. Fbnet: Hardware-aware efficient convnet design via differentiable neural architecture search. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 10734–10742, 2019.
+
+Changqian Yu, Jingbo Wang, Chao Peng, Changxin Gao, Gang Yu, and Nong Sang. Bisenet: Bilateral segmentation network for real-time semantic segmentation. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 325–341, 2018a.
+
+Fisher Yu, Vladlen Koltun, and Thomas Funkhouser. Dilated residual networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 472–480, 2017.
+
+Fisher Yu, Wenqi Xian, Yingying Chen, Fangchen Liu, Mike Liao, Vashisht Madhavan, and Trevor Darrell. Bdd100k: A diverse driving video database with scalable annotation tooling. arXiv preprint arXiv:1805.04687, 2018b.
+
+Jiahui Yu, Linjie Yang, Ning Xu, Jianchao Yang, and Thomas Huang. Slimmable neural networks. arXiv preprint arXiv:1812.08928, 2018c.
+
+Yiheng Zhang, Zhaofan Qiu, Jingen Liu, Ting Yao, Dong Liu, and Tao Mei. Customizable architecture search for semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 11641–11650, 2019.
+
+Hengshuang Zhao, Xiaojuan Qi, Xiaoyong Shen, Jianping Shi, and Jiaya Jia. Icnet for real-time semantic segmentation on high-resolution images. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 405–420, 2018.
+
+Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016.
+
+# A STEM AND HEAD MODULE
+
+Stem: Our stem module aims to quickly downsample the input image to $\frac { 1 } { 8 }$ resolution while increasing the number of channels. The stem module consists of five $3 \times 3$ convolution layers, where the first, second, and fourth layer are of stride two and double the number of channels.
+
+Head: As shown in Figure 1, feature map of shape $( C _ { 2 s } \times H \times W )$ is first reduced in channels by a $1 \times 1$ convolution layer and bilinearly upsampled to match the shape of the other feature map $( C _ { s } \times 2 H \times 2 W )$ . Then, two feature maps are concatenated and fused together with a $3 \times 3$ convolution layer. Note that we not necessarily have $C _ { 2 s } = 2 C _ { s }$ because of the searchable expansion ratios.
+
+# B BRANCH SELECTION CRITERION
+
+Since our searchable downsample rates $s \in \{ 8 , 1 6 , 3 2 \}$ and the number of selected branches $b = 2$ , our supernet needs to select branches of three possible combinations of resolutions: $\{ 8 , 1 6 \}$ , $\{ 8 ,$ , $3 2 \}$ , and $\{ 1 6 , 3 2 \}$ . For each combination, branches of two resolutions will be aggregated by our head module.
+
+Our supernet selects the best $b$ branches based on the criterion used in (Tan et al., 2019):
+
+$$
+T a r g e t ( m ) = A C C ( m ) \times [ \frac { L A T ( m ) } { T } ] ^ { w } ,
+$$
+
+where $m$ is a searched model aggregating $b$ branches, with accuracy $A C C ( m )$ and latency $L A T ( m )$ $w$ is the weight factor defined as:
+
+$$
+w = { \left\{ \begin{array} { l l } { \alpha , } & { { \mathrm { i f } } L A T ( m ) \leq T } \\ { \beta , } & { { \mathrm { o t h e r w i s e } } . } \end{array} \right. }
+$$
+
+We empirically set $\alpha = \beta = - 0 . 0 7$ and the target latency $T = 8 . 3$ ms in our work.
+
+# C “GUMBEL-SOFTMAX” TRICK FOR SEARCHING EXPANSION RATIOS
+
+Formally, suppose we have our set of expansion ratios $\mathcal { X } \subseteq N ^ { + }$ , and we want to sample one ratio $\chi$ from $\mathcal { X }$ . For each $\chi ^ { i }$ we have an associated probability $\gamma ^ { i }$ , where $\begin{array} { r } { \sum _ { i = 1 } ^ { | \mathcal { X } | } \gamma ^ { i } = 1 } \end{array}$ . “Gumbel-Softmax” trick (Gumbel, 1954; Maddison et al., 2014) helps us approximate differentiable sampling. We first sample a “Gumbel-Noise” $o ^ { i } = - \mathrm { l o g } ( - \mathrm { l o g } ( u ) ) \bar { }$ with $u \sim \mathrm { U n i f } [ 0 , 1 ]$ . Instead of selecting $\chi ^ { j }$ such that $j = \mathrm { a r g m a x } _ { i } ( \gamma ^ { i } )$ , we choose $\begin{array} { r } { j = \operatorname { a r g m a x } _ { i } \big ( \frac { \exp ( \frac { \log ( \gamma ^ { i } ) + o ^ { i } } { \tau } ) } { \sum _ { m = 1 } ^ { | \mathcal { X } | } \exp ( \frac { \log ( \gamma ^ { m } ) + o ^ { m } } { \tau } ) } \big ) } \end{array}$ τ )log(γm)+om ). We set the temperature parameter $\tau = 1$ in our work.
+
+# D NORMALIZED SCALARS $\alpha , \beta , \gamma$
+
+$\alpha , \beta$ , and $\gamma$ are all normalized scalars and implemented as softmax. They act as probabilities associating with each operator $O ^ { k } \in \mathcal { O }$ , each predecessor’s output $\overline { { O } } _ { l - 1 }$ , and each expansion ratio $\chi \in \mathcal X$ , respectively:
+
+$$
+\begin{array} { r c l } { \displaystyle \sum _ { k = 1 } ^ { | \mathcal { O } | } \alpha _ { s , l } ^ { k } = 1 , \forall s , l } & { \mathrm { ~ a n d ~ } } & { \displaystyle \alpha _ { s , l } ^ { k } \geq 0 , \forall k , s , l } \\ { \displaystyle \beta _ { s , l } ^ { 0 } + \beta _ { s , l } ^ { 1 } = 1 , \forall s , l } & { \mathrm { ~ a n d ~ } } & { \displaystyle \beta _ { s , l } ^ { 0 } , \beta _ { s , l } ^ { 1 } \geq 0 , \forall s , l } \\ { \displaystyle \sum _ { j = 1 } ^ { | \mathcal { X } | } \gamma _ { s , l } ^ { j } = 1 , \forall s , l } & { \mathrm { ~ a n d ~ } } & { \displaystyle \gamma _ { s , l } ^ { j } \geq 0 , \forall j , s , l , } \end{array}
+$$
+
+where $s$ is downsample rate and $l$ is index of the layer in our supernet.
+
+# E LATENCY ESTIMATION
+
+We build a latency lookup table that covers all possible situations and use this lookup table as building blocks to estimate the relaxed latency. To verify the continuous relaxation of latency, we randomly sample networks of different operators/downsample rates/expansion ratios out of the supernet $\mathcal { M }$ , and measured both the real and estimated latency. We estimate the network latency by accumulating all latencies of operators consisted in the network. In Figure 3, we can see the high correlation between the two measurements, with a correlation coefficient of 0.993. This accurate estimation of network latency benefits from the sequential design of our search space.
+
+# F TRAINING
+
+Given our supernet $\mathcal { M }$ , the overall optimization target (loss) during architecture search is:
+
+$$
+L = L _ { \mathrm { s e g } } ( \mathcal { M } ) + \lambda \cdot L a t ( \mathcal { M } )
+$$
+
+We adopt cross-entropy with “online-hard-element-mining” as our segmentation loss $L _ { \mathrm { s e g } }$ . $L a t ( \mathcal { M } )$ is the continuously relaxed latency of supernet, and $\lambda$ is the balancing factor. We set $\bar { \lambda ( \mathrm { = } 0 . 0 1 }$ in our work.
+
+As the architecture $\alpha , \beta$ , and $\gamma$ are now involved in the differentiable computation graph, they can be optimized using gradient descent. Similar in (Liu et al., 2019a), we adopt the first-order approximation ((Liu et al., 2018b)), randomly split our training dataset into two disjoint sets trainA and trainB, and alternates the optimization between:
+
+1. Update network weights $W$ by $\nabla _ { W } L _ { \mathrm { s e g } } ( \mathcal { M } | W , \alpha , \beta , \gamma )$ on trainA, 2. Update architecture $\alpha , \beta , \gamma$ by $\nabla _ { \alpha , \beta , \gamma } { \cal L } _ { \mathrm { s e g } } ( \mathcal { M } | W , \alpha , \beta , \gamma ) + \lambda \cdot \nabla _ { \alpha , \beta , \gamma } L A T ( \mathcal { M } | W , \alpha , \beta , \gamma )$ on trainB.
+
+When we extend to our teacher-student co-searching where we have two sets of architectures $( \alpha \tau , \beta \tau )$ and $( \alpha _ { S } , \beta _ { S } , \gamma _ { S } )$ , our alternative optimization becomes:
+
+1. Update network weights $W$ by $\nabla _ { W } L _ { \mathrm { s e g } } ( \mathcal { M } | W , \alpha _ { T } , \beta _ { T } )$ on trainA,   
+2. Update network weights $W$ by $\nabla _ { W } L _ { \mathrm { s e g } } ( \mathcal { M } | W , \alpha _ { S } , \beta _ { S } , \gamma _ { S } )$ on trainA,   
+3. Update architecture $\alpha \tau , \beta \tau$ by $\nabla _ { \alpha \tau , \beta \tau , \gamma \tau } L _ { \mathrm { s e g } } ( \mathcal { M } | W , \alpha \tau , \beta \tau )$ on trainB.   
+4. Update architecture $\alpha _ { S } , \beta _ { S } , \gamma _ { S }$ by $\nabla _ { \alpha _ { S } , \beta _ { S } , \gamma _ { S } } L _ { \mathrm { s e g } } ( { \mathcal M } | W , \alpha _ { S } , \beta _ { S } , \gamma _ { S } ) ~ + ~ \lambda ~ .$   
+$\nabla _ { \alpha \boldsymbol { s } , \beta \boldsymbol { s } , \gamma \boldsymbol { s } } L A T ( \mathcal { M } | W , \alpha \boldsymbol { s } , \beta \boldsymbol { s } , \gamma \boldsymbol { s } )$ on trainB.
+
+In all search experiments, we first pretrain the supernet without updating the architecture parameter for 20 epochs, then start architecture searching for 30 epochs.
+
+Optimizing Multiple Widths: To train multiple widths within a superkernel, it is unrealistic to accumulate losses from all different width options in the super network. Therefore, we approximate the multi-widths optimization by training the maximum and minimum expansion ratios. During pretraining the super network, we train each operator with the smallest width, largest width, and 2 random widths. When we are searching for architecture parameters, we train each operator with the smallest width, largest width, and the width that is sampled from the current $\gamma$ by Gumbel Softmax.
+
+# G BENCHMARK DATASETS
+
+Cityscapes (Cordts et al., 2016) is a popular urban street scene dataset for semantic segmentation. It contains high-quality pixel-level annotations, 2,975 images for training and 500 images for validation. In our experiments, we only use the fine annotated images without any coarse annotated image or extra data like ImageNet (Deng et al., 2009). For testing, it offers 1,525 images without ground-truth for a fair comparison. These images all have a resolution of $1 0 2 4 \times 2 0 4 8$ $( \mathrm { H } \times \mathrm { W } )$ , where each pixel is annotated to pre-defined 19 classes.
+
+CamVid (Brostow et al., 2008) is another street scene dataset, extracted from five video sequences taken from a driving automobile. It contains 701 images in total, where 367 for training, 101 for validation and 233 for testing. The images have a resolution of $7 2 0 \times 9 6 0$ $( \mathrm { H } \times \mathrm { W } )$ and 11 semantic categories.
+
+BDD: The BDD (Yu et al., 2018b) is a recently released urban scene dataset. For the segmentation task, it contains 7,000 images for training and 1,000 for validation. The images have a resolution of $7 2 0 \times 1 2 8 0$ $( \mathrm { H } \times \mathrm { W } )$ and shared the same 19 semantic categories as used in the Cityscapes.
+
+# H ARCHITECTURE SEARCH IMPLEMENTATIONS
+
+As stated in the second line of Eqn. 2, a stride 2 convolution is used for all $\mathsf { s } \to 2 \mathsf { s }$ connections, both to reduce spatial size and double the number of filters. Bilinear upsampling is used for all upsampling operations.
+
+We conduct architecture search on the Cityscapes dataset. We use $1 6 0 \times 3 2 0$ random image crops from half-resolution $( 5 1 2 \times 1 0 2 4 )$ images in the training set. Note that the original validation set or test set is never used for our architecture search. When learning network weights $W$ , we use SGD optimizer with momentum 0.9 and weight decay of $5 \times 1 0 ^ { - 4 }$ . We used the exponential learning rate decay of power 0.99. When learning the architecture parameters $\alpha , \beta , a n d \gamma$ , we use Adam optimizer with learning rate $3 \times 1 0 ^ { - 4 }$ . The entire architecture search optimization takes about 2 days on one 1080Ti GPU.
+
+# I FASTERSEG STRUCTURE
+
+In Table 7 we list the operators $( O )$ and expansion ratios $( \chi )$ selected by our FasterSeg. The downsample rates $s$ in Table 7 and Figure 6 match. We have the number of output channels $\mathrm { c _ { o u t } } = s \times \chi$ We observed that the zoomed convolution is heavily used, suggesting the importance of low latency and large receptive field.
+
+<table><tr><td>Cell</td><td>Operator</td><td>S</td><td>X</td><td>c_out</td></tr><tr><td>1</td><td>conv. ×2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>2</td><td>conv. ×2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>3</td><td>zoomed conv.×2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>4</td><td>zoomed conv. × 2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>5</td><td>conv. ×2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>6</td><td>conv. ×2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>7</td><td>zoomed conv. × 2</td><td>16</td><td>4</td><td>64</td></tr><tr><td>8</td><td>zoomed conv. × 2</td><td>16</td><td>12</td><td>192</td></tr><tr><td>9</td><td>zoomed conv. × 2</td><td>16</td><td>8</td><td>128</td></tr></table>
+
+Table 7: Cells used in FasterSeg. Left: cells for branch with final downsample rate of 16. Right: cells for branch with final downsample rate of 32. s: downsample rate. $\chi$ : expansion ratio. c out: number of output channels.   
+
+<table><tr><td>Cell</td><td>Operator</td><td>S</td><td>X</td><td>c_out</td></tr><tr><td>1</td><td>conv. ×2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>2</td><td>conv. ×2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>3</td><td>zoomed conv. ×2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>4</td><td>zoomed conv.</td><td>8</td><td>8</td><td>64</td></tr><tr><td>5</td><td>zoomed conv. ×2</td><td>16</td><td>4</td><td>64</td></tr><tr><td>6</td><td>zoomed conv. ×2</td><td>16</td><td>4</td><td>64</td></tr><tr><td>7</td><td>zoomed conv. ×2</td><td>16</td><td>4</td><td>64</td></tr><tr><td>8</td><td>zoomed conv. ×2</td><td>16</td><td>4</td><td>64</td></tr><tr><td>9</td><td>zoomed conv. ×2</td><td>32</td><td>4</td><td>128</td></tr><tr><td>10</td><td>zoomed conv. ×2</td><td>32</td><td>8</td><td>256</td></tr></table>
+
+# J VISUALIZATION
+
+We show some visualized segmentation results in Figure 7. From the third to the forth column $( ^ { * } O , s | \chi = 8 , b = 1 ^ { , }$ to ${ } ^ { * * } O , s | \chi = 8 , b = 2 ^ { * * } )$ , adding the extra branch of different scales provides more consistent segmentations (in the building and sidewalk area). From the fifth to the sixth column $^ { 6 6 } T $ pruned $\vec { \tau } ^ { , , }$ to FasterSeg), our FasterSeg surpasses the prunned teacher network, where the 
segmentation is smoother and more accurate.
+
+![](images/d149591a0f165100c2db59c9ef8124fbe2b723ab6d8be32564187f226f473c08.jpg)  
+Figure 7: Visualization on Cityscapes validation set. Columns from left to right correspond to original images, ground truths, and results of ${ } ^ { \imath \cdot } { \cal O } , \bar { s } | \chi = 8 , b = 1 ^ { \prime }$ , $\ ^ { \cdot \cdot } { \cal O } , s | \chi = 8 , b = 2 ^ { , }$ , $^ { \mathrm { 6 6 } } T $ pruned $\gamma "$ , FasterSeg (see Table 3 for annotation details). Best viewed in color.

parse/train/BJgqQ6NYvB/BJgqQ6NYvB_content_list.json

@@ -0,0 +1,2069 @@
+[
+    {
+        "type": "text",
+        "text": "FASTERSEG: SEARCHING FOR FASTER REAL-TIME SEMANTIC SEGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wuyang Chen1∗, Xinyu Gong1∗, Xianming Liu2, Qian Zhang2, Yuan $\\mathbf { L i } ^ { 2 }$ , Zhangyang Wang1 ",
+        "bbox": [
+            179,
+            174,
+            812,
+            191
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Department of Computer Science and Engineering, Texas A&M University 2Horizon Robotics Inc. {wuyang.chen,xy gong,atlaswang}@tamu.edu {xianming.liu,qian01.zhang,yuan.li}@horizon.ai https://github.com/TAMU-VITA/FasterSeg ",
+        "bbox": [
+            251,
+            193,
+            751,
+            262
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            303,
+            544,
+            318
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present FasterSeg, an automatically designed semantic segmentation network with not only state-of-the-art performance but also faster speed than current methods. Utilizing neural architecture search (NAS), FasterSeg is discovered from a novel and broader search space integrating multi-resolution branches, that has been recently found to be vital in manually designed segmentation models. To better calibrate the balance between the goals of high accuracy and low latency, we propose a decoupled and fine-grained latency regularization, that effectively overcomes our observed phenomenons that the searched networks are prone to “collapsing” to low-latency yet poor-accuracy models. Moreover, we seamlessly extend FasterSeg to a new collaborative search (co-searching) framework, simultaneously searching for a teacher and a student network in the same single run. The teacher-student distillation further boosts the student model’s accuracy. Experiments on popular segmentation benchmarks demonstrate the competency of FasterSeg. For example, FasterSeg can run over $30 \\%$ faster than the closest manually designed competitor on Cityscapes, while maintaining comparable accuracy. ",
+        "bbox": [
+            233,
+            335,
+            764,
+            542
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            571,
+            336,
+            588
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Semantic segmentation predicts pixel-level annotations of different semantic categories for an image. Despite its performance breakthrough thanks to the prosperity of convolutional neural networks (CNNs) (Long et al., 2015), as a dense structured prediction task, segmentation models commonly suffer from heavy memory costs and latency, often due to stacking convolutions and aggregating multiple-scale features, as well as the increasing input image resolutions. However, recent years witness the fast-growing demand for real-time usage of semantic segmentation, e.g., autonomous driving. Such has motivated the enthusiasm on designing low-latency, more efficient segmentation networks, without sacrificing accuracy notably (Zhao et al., 2018; Yu et al., 2018a). ",
+        "bbox": [
+            174,
+            599,
+            825,
+            712
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The recent success of neural architecture search (NAS) algorithms has shed light on the new horizon in designing better semantic segmentation models, especially under latency of other resource constraints. Auto-DeepLab (Liu et al., 2019a) first introduced network-level search space to optimize resolutions (in addition to cell structure) for segmentation tasks. Zhang et al. (2019) and Li et al. (2019) adopted pre-defined network-level patterns of spatial resolution, and searched for operators and decoders with latency constraint. Despite a handful of preliminary successes, we observe that the successful human domain expertise in designing segmentation models appears to be not fully integrated into NAS frameworks yet. For example, human-designed architectures for real-time segmentation (Zhao et al., 2018; Yu et al., 2018a) commonly exploit multi-resolution branches with proper depth, width, operators, and downsample rates, and find them contributing vitally to the success: such flexibility has not been unleashed by existing NAS segmentation efforts. Furthermore, the trade-off between two (somewhat conflicting) goals, i.e., high accuracy and low latency, also makes the search process unstable and prone to “bad local minima” architecture options. ",
+        "bbox": [
+            174,
+            718,
+            825,
+            898
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As the well-said quote goes: “those who do not learn history are doomed to repeat it”. Inheriting and inspired by the successful practice in hand-crafted efficient segmentation, we propose a novel NAS framework dubbed FasterSeg, aiming to achieve extremely fast inference speed and competitive accuracy. We designed a special search space capable of supporting optimization over multiple branches of different resolutions, instead of a single backbone. These searched branches are adaptively aggregated for the final prediction. To further balance between accuracy versus latency and avoiding collapsing towards either metric (e.g., good latency yet poor accuracy), we design a decoupled and fine-grained latency regularization, that facilitates a more flexible and effective calibration between latency and accuracy. Moreover, our NAS framework can be easily extended to a collaborative search (co-searching), i.e., jointly searching for a complex teacher network and a light-weight student network in a single run, whereas the two models are coupled by feature distillation in order to boost the student’s accuracy. We summarize our main contributions as follows: ",
+        "bbox": [
+            174,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• A novel NAS search space tailored for real-time segmentation, where multi-resolution branches can be flexibility searched and aggregated.   \n• A novel decoupled and fine-grained latency regularization, that successfully alleviates the “architecture collapse” problem in the latency-constrained search.   \n• A novel extension to teacher-student co-searching for the first time, where we distill the teacher to the student for further accuracy boost of the latter.   \n• Extensive experiments demonstrating that FasterSeg achieves extremely fast speed (over $30 \\%$ faster than the closest manually designed competitor on CityScapes) and maintains competitive accuracy. ",
+        "bbox": [
+            215,
+            275,
+            825,
+            410
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            422,
+            346,
+            439
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Human-designed CNN architectures achieve good accuracy performance nowadays (He et al., 2016; Chen et al., 2018b; Wang et al., 2019; Sun et al., 2019). However, designing architectures to balance between accuracy and other resource constraints (latency, memory, FLOPs, etc.) requires more human efforts. To free human experts from this challenging trade-off, neural architecture search (NAS) has been recently introduced and drawn a booming interest (Zoph & Le, 2016; Brock et al., 2017; Pham et al., 2018; Liu et al., 2018a; Chen et al., 2018a; Bender et al., 2018; Chen et al., 2018c; Gong et al., 2019). These works optimize both accuracy and resource utilization, via a combined loss function (Wu et al., 2019), or a hybrid reward signal for policy learning (Tan et al., 2019; Cheng et al., 2018), or a constrained optimization formulation (Dai et al., 2019). ",
+        "bbox": [
+            173,
+            446,
+            825,
+            573
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Most existing resource-aware NAS efforts focus on classification tasks, while semantic segmentation has higher requirements for preserving details and rich contexts, therefore posing more dilemmas for efficient network design. Fortunately, previous handcrafted architectures for real-time segmentation have identified several consistent and successful design patterns. ENet (Paszke et al., 2016) adopted early downsampling, and ICNet (Zhao et al., 2018) further incorporated feature maps from multiresolution branches under label guidance. BiSeNet (Yu et al., 2018a) fused a context path with fast downsampling and a spatial path with smaller filter strides. More works target on segmentation efficiency in terms of computation cost (He et al., 2019; Marin et al., 2019) and memory usage (Chen et al., 2019). Their multi-resolution branching and aggregation designs ensure sufficiently large receptive fields (contexts) while preserving high-resolution fine details, providing important clues on how to further optimize the architecture. ",
+        "bbox": [
+            173,
+            579,
+            825,
+            732
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There have been recent studies that start pointing NAS algorithms to segmentation tasks. AutoDeepLab (Liu et al., 2019a) pioneered in this direction by searching the cells and the networklevel downsample rates, to flexibly control the spatial resolution changes throughout the network. Zhang et al. (2019) and Li et al. (2019) introduced resource constraints into NAS segmentation. A multi-scale decoder was also automatically searched (Zhang et al., 2019). However, compared with manually designed architectures, those search models still follow a single-backbone design and did not fully utilize the prior wisdom (e.g., multi-resolution branches) in designing their search spaces. ",
+        "bbox": [
+            174,
+            739,
+            823,
+            837
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Lastly, we briefly review knowledge distillation (Hinton et al., 2015), that aims to transfer learned knowledge from a sophisticated teacher network to a light-weight student, to improve the (more efficient) student’s accuracy. For segmentation, Liu et al. (2019b) and Nekrasov et al. (2019) proposed to leverage knowledge distillation to improve the accuracy of the compact model and speed-up convergence. There was no prior work in linking distillation with NAS yet, and we will introduce the extension of FasterSeg by integrating teacher-student model collaborative search for the first time. ",
+        "bbox": [
+            174,
+            843,
+            825,
+            928
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 FASTERSEG: FASTER REAL-TIME SEGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            622,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our FasterSeg is discovered from an efficient and multi-resolution search space inspired by previous manual design successes. A fine-grained latency regularization is proposed to overcome the challenge of “architecture collapse” (Cheng et al., 2018). We then extend our FasterSeg to a teacherstudent co-searching framework, further resulting in a lighter yet more accurate student network. ",
+        "bbox": [
+            173,
+            121,
+            825,
+            178
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 EFFICIENT SEARCH SPACE WITH MULTI-RESOLUTION BRANCHING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            183,
+            681,
+            196
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The core motivation behind our search space is to search multi-resolution branches with overall low latency, which has shown effective in previous manual design works (Zhao et al., 2018; Yu et al., 2018a). Our NAS framework automatically selects and aggregates branches of different resolutions, based on efficient cells with searchable superkernels. ",
+        "bbox": [
+            174,
+            202,
+            825,
+            257
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/b3bd260199aaf4b654b0928e1011226f6d503e7862066948ccfc768299dce006.jpg",
+        "image_caption": [
+            "Figure 1: The multi-resolution branching search space for FasterSeg, where we aim to optimize multiple branches with different output resolutions. These outputs are progressively aggregated together in the head module. Each cell is individually searchable and may have two inputs and two outputs, both of different downsampling rates (s). Inside each cell, we enable searching for expansion ratios within a single superkernel. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            261,
+            728,
+            455
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 SEARCHABLE MULTI-RESOLUTION BRANCHES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            517,
+            550,
+            530
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Inspired by (Liu et al., 2019a), we enable searching for spatial resolutions within the $L$ -layer cells (Figure 1), where each cell takes inputs from two connected predecessors and outputs two feature maps of different resolutions. Hand-crafted networks for real-time segmentation found multi-branches of different resolutions to be effective (Zhao et al., 2018; Yu et al., 2018a). However, architectures explored by current NAS algorithms are restricted to a single backbone. ",
+        "bbox": [
+            174,
+            535,
+            529,
+            660
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to select $b$ $\\left( b > 1 \\right)$ ) branches of different resolutions in this $L$ -layer framework. Specifically, we could choose $b$ different final output resolutions for the last layer of cells, and decode each branch via backtrace (section 3.4). This enables our NAS framework to explore $b$ individual branches with different resolutions, which are progressively “learned to be aggregated” by the head module (Figure 1). ",
+        "bbox": [
+            174,
+            667,
+            529,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/b8d95424018b93142e9e9a55ba89868a865648c466bedd6320035f5894d75743.jpg",
+        "image_caption": [
+            "Figure 2: Our multi-resolution search space covers existing manual designs for real-time segmentation (unused cells omitted). Top: ICNet (Zhao et al., 2018). Bottom: BiSeNet (Yu et al., 2018a) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            547,
+            536,
+            820,
+            685
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We follow the convention to increase the number of channels at each time of resolution downsampling. To enlarge the model capacity without incurring much latency, we first downsample the input image to $\\frac { 1 } { 8 }$ original scale with our stem module, and then set our searchable downsample rates $s \\in \\{ 8 , 1 \\breve { 6 } , 3 2 \\}$ . Figure 2 shows that our multi-resolution search space is able to cover existing human-designed networks for real-time segmentation. See Appendix B for branch selection details. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            856
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 CHOOSING EFFICIENT OPERATORS WITH LARGE RECEPTIVE FIELDS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            871,
+            697,
+            886
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As we aim to boost the inference latency, the speed of executing an operator is a direct metric (rather than indirect metrics like FLOPs) for selecting operator candidates $\\mathcal { O }$ . Meanwhile, as we previously discussed, it is also important to ensure sufficiently large receptive field for spatial contexts. We analyze typical operators, including their common surrogate latency measures (FLOPs, parameter numbers), and their real-measured latency on an NVIDIA 1080Ti GPU with TensorRT library, and their receptive fields, as summarized in Table 1. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Compared with standard convolution, group convolution is often used for reducing FLOPs and number of parameters (Sandler et al., 2018; Ma et al., 2018). Convolving with two groups has the same receptive field with a standard convolution but is $13 \\%$ faster, while halving the parameter amount (which might not be preferable as it reduces the model learning capacity). Dilated convolution has an enlarged receptive field and is popular in dense predictions (Chen et al., 2018b; Dai et al., 2017). However, as shown in Table 1 (and as widely acknowledged in engineering practice), dilated convolution (with dilation rate 2) suffers from dramatically higher latency, although that was not directly reflected in FLOPs nor parameter numbers. In view of that, we design a new variant called “zoomed convolution”, where the input feature map is sequentially processed with bilinear downsampling, standard convolution, and bilinear upsampling. This special design enjoys $40 \\%$ lower latency and 2 times larger receptive field compared to standard convolution. Our search space hence consists of the following operators: ",
+        "bbox": [
+            173,
+            166,
+            825,
+            333
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• $3 \\times 3$ conv. $\\times 2$ ",
+        "bbox": [
+            619,
+            342,
+            732,
+            354
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• “zoomed conv.”: bilinear downsampling $+ \\ 3 \\times 3$ conv. $^ +$ bilinear upsampling • “zoomed conv. $\\times 2 ^ { , , }$ : bilinear downsampling $+ \\ 3 \\times 3$ conv. $\\times 2 +$ bilinear upsampling ",
+        "bbox": [
+            215,
+            363,
+            782,
+            392
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As mentioned by Ma et al. (2018), network fragmentation can significantly hamper the degree of parallelism, and therefore practical efficiency. Therefore, we choose a sequential search space (rather than a directed acyclic graph of nodes (Liu et al., 2018b)), i.e., convolutional layers are sequentially ",
+        "bbox": [
+            174,
+            400,
+            388,
+            537
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/bf1fd06bc1942238e93a5eafc626956495ea59f74e0499dfe14bdb6936a333a6.jpg",
+        "table_caption": [
+            "Table 1: Specifications of different convolutions. Latency is measured using an input of size $1 \\times 2 5 6 \\times 3 2 \\times 6 4$ on $1 0 8 0 \\mathrm { T i }$ with TensorRT library. Each operator only contains one convolutional layer. The receptive field (RF) is relatively compared with the standard convolution (first row). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer Type</td><td>Latency (ms)</td><td>FLOPs (G)</td><td>Params (M)</td><td>RF*</td></tr><tr><td>conv.</td><td>0.15</td><td>1.21</td><td>0.59</td><td>1</td></tr><tr><td>conv. group2</td><td>0.13(-13%)</td><td>0.60(-50%)</td><td>0.29 (-51%)</td><td>1</td></tr><tr><td>conv. dilation2</td><td>0.25(+67%)</td><td>1.10(-9%)</td><td>0.59</td><td>2</td></tr><tr><td>zoomed conv.</td><td>0.09 (-40%)</td><td>0.30(-75%)</td><td>0.59</td><td>2</td></tr></table>",
+        "bbox": [
+            415,
+            454,
+            810,
+            521
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "stacked in our network. In Figure 1, each cell is differentiable (Liu et al., 2018b; 2019a) and will contain only one operator, once the discrete architecture is derived (section 3.4). It is worth noting that we allow each cell to be individually searchable across the whole search space. ",
+        "bbox": [
+            176,
+            539,
+            825,
+            580
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.3 SEARCHABLE SUPERKERNEL FOR EXPANSION RATIOS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            590,
+            606,
+            606
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We further give each cell the flexibility to choose different channel expansion ratios. In our work, we search for the width of the connection between successive cells. That is however non-trivial due to the exponentially possible combinations of operators and widths. To tackle this problem, we propose a differentiably searchable superkernel, i.e., directly searching for the expansion ratio $\\chi$ within a single convolutional kernel which supports a set of ratios $ { \\mathcal { X } } \\subseteq N ^ { + }$ . Inspired by (Yu et al., 2018c) and (Stamoulis et al., 2019), from slim to wide our connections incrementally take larger subsets of input/output dimensions from the superkernel. During the architecture search, for each superkernel, only one expansion ratio is sampled, activated, and back-propagated in each step of stochastic gradient descent. This design contributes to a simplified and memory-efficient super network and is implemented via the renowned “Gumbel-Softmax” trick (see Appendix C for details). ",
+        "bbox": [
+            174,
+            616,
+            825,
+            756
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To follow the convention to increase the number of channels as resolution downsampling, in our search space we consider the width $= \\chi \\times s$ , where $s \\in \\{ 8 , 1 6 , 3 2 \\}$ . We allow connections between each pair of successive cells flexibly choose its own expansion ratio, instead of using a unified single expansion ratio across the whole search space. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.4 CONTINUOUS RELAXATION OF SEARCH SPACE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            830,
+            555,
+            844
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Denote the downsample rate as $s$ and layer index as $l$ . To facilitate the search of spatial resolutions, we connect each cell with two possible predecessors’ outputs with different downsample rates: ",
+        "bbox": [
+            174,
+            849,
+            825,
+            877
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5c6f97c82a3867f95a1fdb0de3ed2fe887570f15665e8d53791ff989579164a4.jpg",
+        "text": "$$\n\\overline { { I } } _ { s , l } = \\beta _ { s , l } ^ { 0 } \\overline { { O } } _ { \\frac { s } { 2 }  s , l - 1 } + \\beta _ { s , l } ^ { 1 } \\overline { { O } } _ { s  s , l - 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            882,
+            620,
+            901
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Each cell could have at most two outputs with different downsample rates into its successors: ",
+        "bbox": [
+            173,
+            909,
+            781,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8e69e1bf4dc827cf86cf9928c3d67fb2c28bb768b68151b54b5c004391174cf8.jpg",
+        "text": "$$\n\\begin{array} { r l r } {  { \\overline { { O } } _ { s \\to s , l } = \\sum _ { k = 1 } ^ { | \\mathcal { O } | } \\alpha _ { s , l } ^ { k } O _ { s \\to s , l } ^ { k } ( \\overline { { I } } _ { s , l } , \\chi _ { s , l } ^ { j } , \\mathrm { s t r i d e = 1 } ) } } \\\\ & { } & { \\overline { { O } } _ { s \\to 2 s , l } = \\sum _ { k = 1 } ^ { | \\mathcal { O } | } \\alpha _ { s , l } ^ { k } O _ { s \\to 2 s , l } ^ { k } ( \\overline { { I } } _ { s , l } , \\chi _ { s , l } ^ { j } , \\mathrm { s t r i d e = 2 } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            95,
+            663,
+            189
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The expansion ratio $\\chi _ { s , l } ^ { j }$ is sampled via “Gumbel-Softmax” trick according to $p ( \\chi = \\chi _ { s , l } ^ { j } ) = \\gamma _ { s , l } ^ { j }$ . Here, $\\alpha , \\beta$ , and $\\gamma$ are all normalized scalars, associated with each operator $O ^ { k } \\in \\mathcal { O }$ , each predecessor’s output $\\overline { { O } } _ { l - 1 }$ , and each expansion ratio $\\chi \\in \\mathcal X$ , respectively (Appendix D). They encode the architectures to be optimized and derived. ",
+        "bbox": [
+            174,
+            207,
+            825,
+            268
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 REGULARIZED LATENCY OPTIMIZATION WITH FINER GRANULARITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            286,
+            694,
+            301
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Low latency is desirable yet challenging to optimize. Previous works (Cheng et al., 2018; Zhang et al., 2019) observed that during the search procedure, the supernet or search policy often fall into bad “local minimums” where the generated architectures are of extremely low latency but with poor accuracy, especially in the early stage of exploration. In addition, the searched networked tend to use more skip connections instead of choosing low expansion ratios (Shaw et al., 2019). This problem is termed as “architecture collapse” in our paper. The potential reason is that, finding architectures with extremely low latency (e.g. trivially selecting the most light-weight operators) is significantly easier than discovering meaningful compact architectures of high accuracy. ",
+        "bbox": [
+            174,
+            318,
+            576,
+            498
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/d70f3138595d7ee2a1719b713d86d53da07cd9c555245e286159689880f1dc4a.jpg",
+        "image_caption": [
+            "Figure 3: Correlation between network latency and its estimation via our latency lookup table (linear coefficient: 0.993). Red line indicates $ { { } ^ { * } } y = x ^ { * }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            594,
+            319,
+            802,
+            450
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To address this “architecture collapse” problem, we for the first time propose to leverage a fine-grained, decoupled latency regularization. We first achieve the continuous relaxation of latency similar to the cell operations in section 3.1.4, via replacing the operator $O$ in Eqn. 1 and 2 with the corresponding latency. We build a latency lookup table that covers all possible operators to support the estimation of the relaxed latency. Figure 3 demonstrates the high correlation of 0.993 between the real and estimated latencies (see details in appendix E). ",
+        "bbox": [
+            173,
+            506,
+            825,
+            589
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We argue that the core reason behind the “architecture collapse” problem is the different sensitivities of supernet to operator $O$ , downsample rate $s$ , and expansion ratio $\\chi$ . Operators like ${ ^ { 6 6 } 3 } \\times 3$ conv. $\\times 2 ^ { , , }$ and “zoomed conv.” have a huge gap in latency. Similar latency gap (though more moderate) exists between slim and wide expansion ratios. However, downsample rates like “8” and $\\mathbf { \\vec { 3 } } \\mathbf { 2 } ^ { , }$ do not differ much, since resolution downsampling also brings doubling of the number of both input and output channels. ",
+        "bbox": [
+            174,
+            597,
+            547,
+            722
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/afa8ec877af106e307c4a02a140a5177d8a13c8116fc375ae25926b79f7106a7.jpg",
+        "table_caption": [
+            "Table 2: Supernet’s sensitivity to latency under different granularities. Input size: (1, 3, 1024, 2048). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Granularity</td><td>△Latency (ms)</td></tr><tr><td>O (operator)</td><td>10.42</td></tr><tr><td>s (downsample rate)</td><td>0.01</td></tr><tr><td>X(expansion ratio)</td><td>5.54</td></tr></table>",
+        "bbox": [
+            563,
+            642,
+            820,
+            709
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We quantitatively compared the influence of $O$ , $s$ , and $\\chi$ towards the supernet latency, by adjusting one of the three aspects and fixing the other two. Taking $O$ as the example, we first uniformly initialize $\\beta$ and $\\gamma$ , and calculate ∆Latency $( O )$ as the gap between the supernet which dominantly takes the slowest operators and the one adopts the fastest. Similar calculations were performed for $s$ and $\\chi$ . Values of $\\Delta$ Latency in Table 2 indicate the high sensitivity of the supernet’s latency to operators and expansion ratios, while not to resolutions. Figure 4(a) shows that the unregularized latency optimization will bias the supernet towards light-weight operators and slim expansion ratios to quickly minimize the latency, ending up with problematic architectures with low accuracy. ",
+        "bbox": [
+            173,
+            728,
+            825,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Based on this observation, we propose a regularized latency optimization leveraging different granularities of our search space. We decouple the calculation of supernet’s latency into three granularities of our search space $( O , s , \\chi )$ , and regularize each aspect with a different factor: ",
+        "bbox": [
+            174,
+            847,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7c28884c26bdbe95cfdbfb27e76fad8264d052fb7ac9552847bc1dbccff23d73.jpg",
+        "text": "$$\n\\mathrm { L a t e n c y } ( O , s , \\chi ) = w _ { 1 } \\mathrm { L a t e n c y } ( O | s , \\chi ) + w _ { 2 } \\mathrm { L a t e n c y } ( s | O , \\chi ) + w _ { 3 } \\mathrm { L a t e n c y } ( \\chi | O , s )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            210,
+            907,
+            785,
+            925
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where we by default set $w _ { 1 } = 0 . 0 0 1$ , $w _ { 2 } = 0 . 9 9 7$ , $w _ { 3 } = 0 . 0 0 2 ^ { 1 }$ . This decoupled and fine-grained regularization successfully addresses this “architecture collapse” problem, as shown in Figure 4(b). ",
+        "bbox": [
+            173,
+            102,
+            825,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/d493b2bc1a8149f129a23284547e3f39631109578c18432df6c493308a349bb8.jpg",
+        "image_caption": [
+            "Figure 4: Comparing mIoU $( \\% )$ and latency (ms) between supernets. The search is conducted on the Cityscapes training set and mIoU is measured on the validation set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            148,
+            815,
+            311
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 TEACHER/STUDENT CO-SEARCHING FOR KNOWLEDGE DISTILLATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            359,
+            700,
+            373
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Knowledge Distillation is an effective approach to transfer the knowledge learned by a large and complex network (teacher $\\tau$ ) into a much smaller network (student $s$ ). In our NAS framework, we can seamlessly extend to teacher-student cosearching, i.e., collaboratively searching for two networks in a single run (Figure 5). Specifically, we search a complex teacher and light-weight student simultaneously via adopting two sets of architectures in one supernet: $( \\alpha \\tau , \\beta \\tau )$ and $( \\alpha _ { S } , \\beta _ { S } , \\gamma _ { S } )$ . Note that the teacher does not search the expansion ratios and always select the widest one. ",
+        "bbox": [
+            174,
+            385,
+            576,
+            523
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/ac3dc9a0c3ce5df37ce9b18c5231ccec19510c7c0e37f8ebf1d10e913fe97c3a.jpg",
+        "image_caption": [
+            "Figure 5: Our co-searching framework, which optimizes two architectures during search (left orange) and distills from a complex teacher to a light student during training from scratch (right green). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            593,
+            386,
+            820,
+            487
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This extension does not bring any overhead in memory usage or size of supernet since the teacher and student share the same supernet weights $W$ during the search process. Two sets of architectures are iteratively optimized during search (please see details in Appendix F), and we apply the latency constraint only on the student, not on the teacher. Therefore, our searched teacher is a sophisticated network based on the same search space and supernet weights $W$ used by the student . During training from scratch, we apply a distillation loss from teacher $\\tau$ to student $s$ : ",
+        "bbox": [
+            173,
+            531,
+            575,
+            573
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            573,
+            823,
+            627
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "KL denotes the KL divergence. $\\mathbf { q } _ { i } ^ { s }$ and $\\mathbf { q } _ { i } ^ { t }$ are predicted logit for pixel $i$ from $s$ and $\\tau$ , respectively.   \nEqual weights (1.0) are assigned to the segmentation loss and this distillation loss. ",
+        "bbox": [
+            174,
+            642,
+            823,
+            670
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4 DERIVING DISCRETE ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            686,
+            485,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Once the search is completed, we derive our discrete architecture from $\\alpha , \\beta$ , and $\\gamma$ : ",
+        "bbox": [
+            174,
+            712,
+            720,
+            726
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• $\\alpha , \\gamma$ : We select the optimum operators and expansion ratios by taking the argmax of $\\alpha$ and $\\gamma$ . We shrink the operator “skip connection” to obtain a shallower architecture with less cells. • $\\beta$ : Different from (Liu et al., 2019a), for each $\\mathrm { c e l l } _ { s , l }$ we consider $\\beta ^ { 0 }$ and $\\beta ^ { 1 }$ as probabilities of two outputs from $\\mathrm { c e l l } _ { \\frac { s } { 2 } , l - 1 }$ and $\\mathrm { c e l l } _ { s , l - 1 }$ into $\\mathrm { c e l l } _ { s , l }$ . Therefore, by taking the $l ^ { * } = \\mathrm { a r g m a x } _ { l } ( \\beta _ { s , l } ^ { 0 } )$ , we find the optimum position $\\begin{array} { r } { ( \\mathrm { c e l l } _ { s , l ^ { * } } . } \\end{array}$ ) where to downsample the current resolution $( \\frac { s } { 2 }  s )$ ). 2 ",
+        "bbox": [
+            173,
+            726,
+            826,
+            804
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "It is worth noting that, the multi-resolution branches will share both cell weights and feature maps if their cells are of the same operator type, spatial resolution, and expansion ratio. This design contributes to a faster network. Once cells in branches diverge, the sharing between the branches will be stopped and they become individual branches (See Figure 6). ",
+        "bbox": [
+            174,
+            808,
+            825,
+            863
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            326,
+            118
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS AND IMPLEMENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            127,
+            460,
+            141
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use the Cityscapes (Cordts et al., 2016) as a testbed for both our architecture search and ablation studies. After that, we report our final accuracy and latency on Cityscapes, CamVid (Brostow et al., 2008), and BDD (Yu et al., 2018b). In all experiments, the class mIoU (mean Intersection over Union per class) and FPS (frame per second) are used as the metrics for accuracy and speed, respectively. Please see Appendix G for dataset details. ",
+        "bbox": [
+            174,
+            146,
+            825,
+            215
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In all experiments, we use Nvidia Geforce GTX 1080Ti for benchmarking the computing power. We employ the high-performance inference framework TensorRT v5.1.5 and report the inference speed. During this inference measurement, an image of a batch size of 1 is first loaded into the graphics memory, then the model is warmed up to reach a steady speed, and finally, the inference time is measured by running the model for six seconds. All experiments are performed under CUDA 10.0 and CUDNN V7. Our framework is implemented with PyTorch. The search, training, and latency measurement codes are available at https://github.com/TAMU-VITA/FasterSeg. ",
+        "bbox": [
+            173,
+            222,
+            825,
+            320
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 ARCHITECTURE SEARCH ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            332,
+            388,
+            344
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We consider a total of $L = 1 6$ layers in the supernet and our downsample rate $s \\in \\{ 8 , 1 6 , 3 2 \\}$ . In our work we use number of branches $b = 2$ by default, since more branches will suffer from high latency. We consider expansion ratio $\\chi _ { s , l } \\in \\mathcal { X } = \\{ 4 , 6 , 8 , 1 0 , 1 2 \\}$ for any “downsample rate” $s$ and layer $l$ . The multi-resolution branches have 1695 unique paths. For cells and expansion ratios, we have $( 1 + 4 \\times 5 ) ^ { ( 1 5 + 1 4 + 1 3 ) } + 5 ^ { 3 } \\approx 3 . 4 \\times 1 0 ^ { 5 5 }$ unique combinations. This results in a search space in the order of $1 0 ^ { 5 8 }$ , which is much larger and challenging, compared with preliminary studies. ",
+        "bbox": [
+            173,
+            351,
+            825,
+            435
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Architecture search is conducted on Cityscapes training dataset. Figure 6 visualizes the best spatial resolution discovered (FasterSeg). Our FasterSeg achieved mutli-resolutions with proper depths. The two branches share the first three operators then diverge, and choose to aggregate outputs with downsample rates of 16 and 32. Oper",
+        "bbox": [
+            173,
+            443,
+            428,
+            568
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/2ea0df57d1234a967a9286eb823fa866e296ad9cf00d801d2013c89579c5c5bc.jpg",
+        "image_caption": [
+            "Figure 6: FasterSeg network discovered by our NAS framework. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            454,
+            446,
+            810,
+            536
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ators and expansion ratios are listed in Table 7 in Appendix I, where the zoomed convolution is heavily used, suggesting the importance of low latency and large receptive field. ",
+        "bbox": [
+            173,
+            568,
+            823,
+            595
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 EVALUATION OF MULTI-RESOLUTION SEARCH SPACE AND CO-SEARCHING ",
+        "bbox": [
+            174,
+            606,
+            732,
+            619
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We conduct ablation studies on Cityscapes to evaluate the effectiveness of our NAS framework. More specifically, we examine the impact of operators $( O )$ , downsample rate (s), expansion ratios $( \\chi )$ , and also distillation on the accuracy and latency. When we expand from a single backbone $b = 1 ,$ ) to multi-branches $( b \\ = \\ 2 )$ , our FPS drops but we gain a much improvement on mIoU, indicating the multiresolution design is beneficial for ",
+        "bbox": [
+            173,
+            626,
+            408,
+            805
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/ae76cd27dc681fd0b57734c95dd7bcaeb95395ba04bc36f483ddb8f0011888d5.jpg",
+        "table_caption": [
+            "Table 3: Ablation studies of different search and training strategies. mIoU is measured on Cityscapes validation set. The input resolution is $1 0 2 4 \\times 2 0 4 8$ . $O$ : operator; $s$ : downsample rate; $\\chi$ : expansion ratios; $^ { b }$ : number of branches; $\\stackrel { 6 6 } {  } \\bar { \\cdot }$ : knowledge distillation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Settings</td><td>mIoU (%)</td><td>FPS</td><td>FLOPs</td><td>#Params</td></tr><tr><td>O,s|x=8,b=1</td><td>66.9</td><td>177.8</td><td>27.0G</td><td>6.3M</td></tr><tr><td>O,sx=8,b=2</td><td>69.5</td><td>119.9</td><td>42.8 G</td><td>10.8M</td></tr><tr><td colspan=\"5\">Teacher(T) )Student (S) Co-searching</td></tr><tr><td>S: O,s,x|b= 2</td><td>70.5</td><td>163.9</td><td>28.2G</td><td>4.4 M</td></tr><tr><td>T → pruned T</td><td>66.1</td><td>146.7</td><td>29.5 G</td><td>4.7 M</td></tr><tr><td>T → S(FasterSeg)</td><td>73.1</td><td>163.9</td><td>28.2G</td><td>4.4 M</td></tr></table>",
+        "bbox": [
+            423,
+            680,
+            823,
+            796
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "segmentation task. By enabling the search for expansion ratios $( \\chi )$ , we discover a faster network with FPS 163.9 without sacrificing accuracy $( 7 0 . 5 \\% )$ , which proves that the searchable superkernel gets the benefit from eliminating redundant channels while maintaining high accuracy. This is our student network $( S )$ discovered in our co-searching framework (see below). ",
+        "bbox": [
+            174,
+            805,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We further evaluate the efficacy of our teacher-student co-searching framework. After the collaboratively searching, we obtain a teacher architecture $( \\mathcal { T } )$ and a student architecture $( S )$ . As mentioned above, $s$ is searched with searchable expansion ratios $( \\chi )$ , achieving an FPS of 163.9 and an mIoU of $70 . 5 \\%$ . In contrast, when we directly compress the teacher (channel pruning via selecting the slimmest expansion ratio) and train with distillation from the well-trained original cumbersome teacher, it only achieved mIo $U = 6 6 . 1 \\%$ with only $\\mathrm { F P S } = 1 4 6 . 7$ , indicating that our architecture cosearching surpass the pruning based compression. Finally, when we adopt the knowledge distillation from the well-trained cumbersome teacher to our searched student, we boost the student’s accuracy to $7 3 . 1 \\%$ , which is our final network FasterSeg. This demonstrates that both a student discovered by co-searching and training with knowledge distillation from the teacher are vital for obtaining an accurate faster real-time segmentation model. ",
+        "bbox": [
+            174,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 REAL-TIME SEMANTIC SEGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            212,
+            488,
+            226
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we compare our FasterSeg with other works for real-time semantic segmentation on three popular scene segmentation datasets. Note that since we target on real-time segmentation, we measure the mIoU without any evaluation tricks like flipping, multi-scale, etc. ",
+        "bbox": [
+            174,
+            231,
+            825,
+            273
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Cityscapes: We evaluate FasterSeg on Cityscapes validation and test sets. We use original image resolution of $1 0 2 4 \\times 2 0 4 8$ to measure both mIoU and speed inference. In Table 4, we see the superior FPS (163.9) of our FasterSeg, even under the maximum image resolution. This high FPS is over $1 . 3 \\times$ faster than human-designed ",
+        "bbox": [
+            173,
+            281,
+            367,
+            446
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/3e3427c9b50ac944b859638a88c6c21de3b2dd9bc1b2f8426646b55f862759e0.jpg",
+        "table_caption": [
+            "Table 4: mIoU and inference FPS on Ciytscapes validation and test sets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">mIoU (%)</td><td rowspan=\"2\">FPS</td><td rowspan=\"2\">Resolution</td></tr><tr><td>val</td><td>test</td></tr><tr><td>ENet (Paszke et al.,2016)</td><td>=</td><td>58.3</td><td>76.9</td><td>512×1024</td></tr><tr><td>ICNet (Zhao et al., 2018)</td><td>67.7</td><td>69.5</td><td>37.7</td><td>1024×2048</td></tr><tr><td>BiSeNet (Yu et al.,2018a)</td><td>69.0</td><td>68.4</td><td>105.8</td><td>768×1536</td></tr><tr><td>CAS (Zhang et al., 2019)</td><td>71.6</td><td>70.5</td><td>108.0</td><td>768×1536</td></tr><tr><td>Fast-SCNN (Poudel et al., 2019)</td><td>68.6</td><td>68.0</td><td>123.5</td><td>1024×2048</td></tr><tr><td>DF1-Seg-d8 (Li et al.,2019)</td><td>72.4</td><td>71.4</td><td>136.9</td><td>1024×2048</td></tr><tr><td>FasterSeg (ours)</td><td>73.1</td><td>71.5</td><td>163.9</td><td>1024×2048</td></tr></table>",
+        "bbox": [
+            380,
+            299,
+            826,
+            434
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "networks. Meanwhile, our FasterSeg still maintains competitive accuracy, which is $7 3 . 1 \\%$ on the validation set and $7 1 . 5 \\%$ on the test set. This accuracy is achieved with only Cityscapes fine-annotated images, without using any extra data (coarse-annotated images, ImageNet, etc.). ",
+        "bbox": [
+            176,
+            446,
+            825,
+            488
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "CamVid: We directly transfer the searched architecture on Cityscapes to train on CamVid. Table 5 reveals that without sacrificing much accuracy, our FasterSeg achieved an FPS of 398.1. This extremely high speed is over $47 \\%$ faster than the closest competitor in FPS (Yu et al., 2018a), and is over two times faster than the work with the best mIoU (Zhang et al., 2019). This impressive result verifies both the high performance of FasterSeg and also the transferability of our NAS framework. ",
+        "bbox": [
+            174,
+            496,
+            825,
+            565
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "BDD: In addition, we also directly transfer the learned architecture to the BDD dataset. In Table 6 we compare our FasterSeg with the baseline provided by Yu et al. (2018b). Since no previous work has considered real-time segmentation on the BDD dataset, we get 15 times faster than the DRN-D22 with slightly higher mIoU. Our FasterSeg still preserve the extremely fast speed and competitive accuracy on BDD. ",
+        "bbox": [
+            173,
+            571,
+            825,
+            641
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/26ce530ff63ffdfdbc2aa57260d37d2a583318e78022c01a2d871d0ae834fc0d.jpg",
+        "table_caption": [
+            "Table 5: mIoU and inference FPS on CamVid test set. The input resolution is $7 2 0 \\times 9 6 0$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>mIoU (%)</td><td>FPS</td></tr><tr><td>ENet (Paszke et al., 2016)</td><td>68.3</td><td>61.2</td></tr><tr><td>ICNet (Zhao et al., 2018)</td><td>67.1</td><td>27.8</td></tr><tr><td>BiSeNet (Yu et al., 2018a)</td><td>65.6</td><td>269.1</td></tr><tr><td>CAS (Zhang et al., 2019)</td><td>71.2</td><td>169.0</td></tr><tr><td>FasterSeg (ours)</td><td>71.1</td><td>398.1</td></tr></table>",
+        "bbox": [
+            174,
+            674,
+            485,
+            766
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/40740ed6bbdfffc85c316edc30ce86cc68115a41d507d3ed909339054701bb75.jpg",
+        "table_caption": [
+            "Table 6: mIoU and inference FPS on BDD validation set. The input resolution is $7 2 0 \\times 1 2 8 0$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>mIoU (%)</td><td>FPS</td></tr><tr><td>DRN-D-22 (Yu et al., 2017)</td><td>53.2</td><td>21.0</td></tr><tr><td>DRN-D-38 (Yu et al., 2017)</td><td>55.2</td><td>12.9</td></tr><tr><td>FasterSeg (ours)</td><td>55.1</td><td>318.0</td></tr></table>",
+        "bbox": [
+            508,
+            674,
+            828,
+            741
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            787,
+            320,
+            804
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We introduced a novel multi-resolution NAS framework, leveraging successful design patterns in handcrafted networks for real-time segmentation. Our NAS framework can automatically discover FasterSeg, which achieved both extremely fast inference speed and competitive accuracy. Our search space is intrinsically of low-latency and is much larger and challenging due to flexible searchable expansion ratios. More importantly, we successfully addressed the “architecture collapse” problem, by proposing the novel regularized latency optimization of fine-granularity. We also demonstrate that by seamlessly extending to teacher-student co-searching, our NAS framework can boost the student’s accuracy via effective distillation. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Bender, Pieter-Jan Kindermans, Barret Zoph, Vijay Vasudevan, and Quoc Le. Understanding and simplifying one-shot architecture search. In International Conference on Machine Learning, pp. 549–558, 2018. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            167
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrew Brock, Theodore Lim, James M Ritchie, and Nick Weston. Smash: one-shot model architecture search through hypernetworks. arXiv preprint arXiv:1708.05344, 2017. ",
+        "bbox": [
+            171,
+            176,
+            821,
+            205
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gabriel J Brostow, Jamie Shotton, Julien Fauqueur, and Roberto Cipolla. Segmentation and recognition using structure from motion point clouds. In European conference on computer vision, pp. 44–57. Springer, 2008. ",
+        "bbox": [
+            173,
+            214,
+            823,
+            256
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Liang-Chieh Chen, Maxwell Collins, Yukun Zhu, George Papandreou, Barret Zoph, Florian Schroff, Hartwig Adam, and Jon Shlens. Searching for efficient multi-scale architectures for dense image prediction. In Advances in Neural Information Processing Systems, pp. 8699–8710, 2018a. ",
+        "bbox": [
+            174,
+            265,
+            825,
+            309
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Liang-Chieh Chen, Yukun Zhu, George Papandreou, Florian Schroff, and Hartwig Adam. Encoderdecoder with atrous separable convolution for semantic image segmentation. In Proceedings of the European conference on computer vision (ECCV), pp. 801–818, 2018b. ",
+        "bbox": [
+            174,
+            316,
+            825,
+            359
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wuyang Chen, Ziyu Jiang, Zhangyang Wang, Kexin Cui, and Xiaoning Qian. Collaborative globallocal networks for memory-efficient segmentation of ultra-high resolution images. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 8924–8933, 2019. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            411
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yukang Chen, Gaofeng Meng, Qian Zhang, Xinbang Zhang, Liangchen Song, Shiming Xiang, and Chunhong Pan. Joint neural architecture search and quantization. arXiv preprint arXiv:1811.09426, 2018c. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            462
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "An-Chieh Cheng, Chieh Hubert Lin, Da-Cheng Juan, Wei Wei, and Min Sun. Instanas: Instanceaware neural architecture search. arXiv preprint arXiv:1811.10201, 2018. ",
+        "bbox": [
+            173,
+            470,
+            821,
+            500
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The cityscapes dataset for semantic urban scene understanding. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3213–3223, 2016. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            564
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jifeng Dai, Haozhi Qi, Yuwen Xiong, Yi Li, Guodong Zhang, Han Hu, and Yichen Wei. Deformable convolutional networks. In Proceedings of the IEEE international conference on computer vision, pp. 764–773, 2017. ",
+        "bbox": [
+            173,
+            573,
+            825,
+            616
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xiaoliang Dai, Peizhao Zhang, Bichen Wu, Hongxu Yin, Fei Sun, Yanghan Wang, Marat Dukhan, Yunqing Hu, Yiming Wu, Yangqing Jia, et al. Chamnet: Towards efficient network design through platform-aware model adaptation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 11398–11407, 2019. ",
+        "bbox": [
+            173,
+            625,
+            825,
+            681
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009. ",
+        "bbox": [
+            171,
+            689,
+            823,
+            732
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xinyu Gong, Shiyu Chang, Yifan Jiang, and Zhangyang Wang. Autogan: Neural architecture search for generative adversarial networks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3224–3234, 2019. ",
+        "bbox": [
+            173,
+            741,
+            825,
+            784
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Emil Julius Gumbel. Statistical theory of extreme values and some practical applications. NBS Applied Mathematics Series, 33, 1954. ",
+        "bbox": [
+            169,
+            792,
+            825,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            830,
+            823,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tong He, Chunhua Shen, Zhi Tian, Dong Gong, Changming Sun, and Youliang Yan. Knowledge adaptation for efficient semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 578–587, 2019. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xin Li, Yiming Zhou, Zheng Pan, and Jiashi Feng. Partial order pruning: for best speed/accuracy trade-off in neural architecture search. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9145–9153, 2019. ",
+        "bbox": [
+            173,
+            142,
+            820,
+            185
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chenxi Liu, Barret Zoph, Maxim Neumann, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan Yuille, Jonathan Huang, and Kevin Murphy. Progressive neural architecture search. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 19–34, 2018a. ",
+        "bbox": [
+            174,
+            195,
+            823,
+            238
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chenxi Liu, Liang-Chieh Chen, Florian Schroff, Hartwig Adam, Wei Hua, Alan L Yuille, and Li FeiFei. Auto-deeplab: Hierarchical neural architecture search for semantic image segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 82–92, 2019a. ",
+        "bbox": [
+            173,
+            247,
+            825,
+            305
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hanxiao Liu, Karen Simonyan, and Yiming Yang. Darts: Differentiable architecture search. arXiv preprint arXiv:1806.09055, 2018b. ",
+        "bbox": [
+            171,
+            314,
+            823,
+            344
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yifan Liu, Ke Chen, Chris Liu, Zengchang Qin, Zhenbo Luo, and Jingdong Wang. Structured knowledge distillation for semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2604–2613, 2019b. ",
+        "bbox": [
+            178,
+            353,
+            823,
+            397
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3431–3440, 2015. ",
+        "bbox": [
+            173,
+            406,
+            823,
+            450
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ningning Ma, Xiangyu Zhang, Hai-Tao Zheng, and Jian Sun. Shufflenet v2: Practical guidelines for efficient cnn architecture design. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 116–131, 2018. ",
+        "bbox": [
+            173,
+            459,
+            825,
+            503
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chris J Maddison, Daniel Tarlow, and Tom Minka. $\\mathbf { A } ^ { * }$ sampling. In Advances in Neural Information Processing Systems, pp. 3086–3094, 2014. ",
+        "bbox": [
+            174,
+            512,
+            823,
+            542
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dmitrii Marin, Zijian He, Peter Vajda, Priyam Chatterjee, Sam Tsai, Fei Yang, and Yuri Boykov. Efficient segmentation: Learning downsampling near semantic boundaries. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2131–2141, 2019. ",
+        "bbox": [
+            174,
+            551,
+            823,
+            595
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vladimir Nekrasov, Hao Chen, Chunhua Shen, and Ian Reid. Fast neural architecture search of compact semantic segmentation models via auxiliary cells. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9126–9135, 2019. ",
+        "bbox": [
+            176,
+            604,
+            823,
+            648
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Abhishek Chaurasia, Sangpil Kim, and Eugenio Culurciello. Enet: A deep neural network architecture for real-time semantic segmentation. arXiv preprint arXiv:1606.02147, 2016. ",
+        "bbox": [
+            173,
+            656,
+            825,
+            700
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. arXiv preprint arXiv:1802.03268, 2018. ",
+        "bbox": [
+            173,
+            710,
+            823,
+            741
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rudra PK Poudel, Stephan Liwicki, and Roberto Cipolla. Fast-scnn: fast semantic segmentation network. arXiv preprint arXiv:1902.04502, 2019. ",
+        "bbox": [
+            173,
+            750,
+            823,
+            779
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4510–4520, 2018. ",
+        "bbox": [
+            174,
+            789,
+            823,
+            833
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Albert Shaw, Daniel Hunter, Forrest Iandola, and Sammy Sidhu. Squeezenas: Fast neural architecture search for faster semantic segmentation. arXiv preprint arXiv:1908.01748, 2019. ",
+        "bbox": [
+            171,
+            842,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dimitrios Stamoulis, Ruizhou Ding, Di Wang, Dimitrios Lymberopoulos, Bodhi Priyantha, Jie Liu, and Diana Marculescu. Single-path nas: Designing hardware-efficient convnets in less than 4 hours. arXiv preprint arXiv:1904.02877, 2019. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ke Sun, Bin Xiao, Dong Liu, and Jingdong Wang. Deep high-resolution representation learning for human pose estimation. arXiv preprint arXiv:1902.09212, 2019. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mingxing Tan, Bo Chen, Ruoming Pang, Vijay Vasudevan, Mark Sandler, Andrew Howard, and Quoc V Le. Mnasnet: Platform-aware neural architecture search for mobile. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2820–2828, 2019. ",
+        "bbox": [
+            178,
+            140,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jingdong Wang, Ke Sun, Tianheng Cheng, Borui Jiang, Chaorui Deng, Yang Zhao, Dong Liu, Yadong Mu, Mingkui Tan, Xinggang Wang, et al. Deep high-resolution representation learning for visual recognition. arXiv preprint arXiv:1908.07919, 2019. ",
+        "bbox": [
+            174,
+            193,
+            823,
+            234
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bichen Wu, Xiaoliang Dai, Peizhao Zhang, Yanghan Wang, Fei Sun, Yiming Wu, Yuandong Tian, Peter Vajda, Yangqing Jia, and Kurt Keutzer. Fbnet: Hardware-aware efficient convnet design via differentiable neural architecture search. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 10734–10742, 2019. ",
+        "bbox": [
+            176,
+            243,
+            821,
+            301
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Changqian Yu, Jingbo Wang, Chao Peng, Changxin Gao, Gang Yu, and Nong Sang. Bisenet: Bilateral segmentation network for real-time semantic segmentation. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 325–341, 2018a. ",
+        "bbox": [
+            174,
+            309,
+            823,
+            353
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fisher Yu, Vladlen Koltun, and Thomas Funkhouser. Dilated residual networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 472–480, 2017. ",
+        "bbox": [
+            173,
+            361,
+            825,
+            391
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fisher Yu, Wenqi Xian, Yingying Chen, Fangchen Liu, Mike Liao, Vashisht Madhavan, and Trevor Darrell. Bdd100k: A diverse driving video database with scalable annotation tooling. arXiv preprint arXiv:1805.04687, 2018b. ",
+        "bbox": [
+            174,
+            398,
+            823,
+            441
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiahui Yu, Linjie Yang, Ning Xu, Jianchao Yang, and Thomas Huang. Slimmable neural networks. arXiv preprint arXiv:1812.08928, 2018c. ",
+        "bbox": [
+            173,
+            450,
+            823,
+            479
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yiheng Zhang, Zhaofan Qiu, Jingen Liu, Ting Yao, Dong Liu, and Tao Mei. Customizable architecture search for semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 11641–11650, 2019. ",
+        "bbox": [
+            173,
+            488,
+            823,
+            531
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hengshuang Zhao, Xiaojuan Qi, Xiaoyong Shen, Jianping Shi, and Jiaya Jia. Icnet for real-time semantic segmentation on high-resolution images. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 405–420, 2018. ",
+        "bbox": [
+            173,
+            540,
+            823,
+            583
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016. ",
+        "bbox": [
+            169,
+            592,
+            823,
+            621
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A STEM AND HEAD MODULE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            436,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stem: Our stem module aims to quickly downsample the input image to $\\frac { 1 } { 8 }$ resolution while increasing the number of channels. The stem module consists of five $3 \\times 3$ convolution layers, where the first, second, and fourth layer are of stride two and double the number of channels. ",
+        "bbox": [
+            174,
+            123,
+            825,
+            166
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Head: As shown in Figure 1, feature map of shape $( C _ { 2 s } \\times H \\times W )$ is first reduced in channels by a $1 \\times 1$ convolution layer and bilinearly upsampled to match the shape of the other feature map $( C _ { s } \\times 2 H \\times 2 W )$ . Then, two feature maps are concatenated and fused together with a $3 \\times 3$ convolution layer. Note that we not necessarily have $C _ { 2 s } = 2 C _ { s }$ because of the searchable expansion ratios. ",
+        "bbox": [
+            173,
+            172,
+            825,
+            243
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B BRANCH SELECTION CRITERION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            262,
+            485,
+            279
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Since our searchable downsample rates $s \\in \\{ 8 , 1 6 , 3 2 \\}$ and the number of selected branches $b = 2$ , our supernet needs to select branches of three possible combinations of resolutions: $\\{ 8 , 1 6 \\}$ , $\\{ 8 ,$ , $3 2 \\}$ , and $\\{ 1 6 , 3 2 \\}$ . For each combination, branches of two resolutions will be aggregated by our head module. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            342
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Our supernet selects the best $b$ branches based on the criterion used in (Tan et al., 2019): ",
+        "bbox": [
+            171,
+            347,
+            750,
+            363
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/11571321f9d29c5d685fc75025ed45233ed8022182de26e5111c84a2fa32c685.jpg",
+        "text": "$$\nT a r g e t ( m ) = A C C ( m ) \\times [ \\frac { L A T ( m ) } { T } ] ^ { w } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            366,
+            637,
+            397
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "where $m$ is a searched model aggregating $b$ branches, with accuracy $A C C ( m )$ and latency $L A T ( m )$ $w$ is the weight factor defined as: ",
+        "bbox": [
+            173,
+            401,
+            821,
+            430
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1297d4bd33178124b1625f7af36f07c119aba09614cd3507e636f69131d5d381.jpg",
+        "text": "$$\nw = { \\left\\{ \\begin{array} { l l } { \\alpha , } & { { \\mathrm { i f } } L A T ( m ) \\leq T } \\\\ { \\beta , } & { { \\mathrm { o t h e r w i s e } } . } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            435,
+            593,
+            470
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We empirically set $\\alpha = \\beta = - 0 . 0 7$ and the target latency $T = 8 . 3$ ms in our work. ",
+        "bbox": [
+            173,
+            474,
+            715,
+            491
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C “GUMBEL-SOFTMAX” TRICK FOR SEARCHING EXPANSION RATIOS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            508,
+            769,
+            526
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Formally, suppose we have our set of expansion ratios $\\mathcal { X } \\subseteq N ^ { + }$ , and we want to sample one ratio $\\chi$ from $\\mathcal { X }$ . For each $\\chi ^ { i }$ we have an associated probability $\\gamma ^ { i }$ , where $\\begin{array} { r } { \\sum _ { i = 1 } ^ { | \\mathcal { X } | } \\gamma ^ { i } = 1 } \\end{array}$ . “Gumbel-Softmax” trick (Gumbel, 1954; Maddison et al., 2014) helps us approximate differentiable sampling. We first sample a “Gumbel-Noise” $o ^ { i } = - \\mathrm { l o g } ( - \\mathrm { l o g } ( u ) ) \\bar { }$ with $u \\sim \\mathrm { U n i f } [ 0 , 1 ]$ . Instead of selecting $\\chi ^ { j }$ such that $j = \\mathrm { a r g m a x } _ { i } ( \\gamma ^ { i } )$ , we choose $\\begin{array} { r } { j = \\operatorname { a r g m a x } _ { i } \\big ( \\frac { \\exp ( \\frac { \\log ( \\gamma ^ { i } ) + o ^ { i } } { \\tau } ) } { \\sum _ { m = 1 } ^ { | \\mathcal { X } | } \\exp ( \\frac { \\log ( \\gamma ^ { m } ) + o ^ { m } } { \\tau } ) } \\big ) } \\end{array}$ τ )log(γm)+om ). We set the temperature parameter $\\tau = 1$ in our work. ",
+        "bbox": [
+            173,
+            531,
+            826,
+            633
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D NORMALIZED SCALARS $\\alpha , \\beta , \\gamma$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            654,
+            465,
+            670
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "$\\alpha , \\beta$ , and $\\gamma$ are all normalized scalars and implemented as softmax. They act as probabilities associating with each operator $O ^ { k } \\in \\mathcal { O }$ , each predecessor’s output $\\overline { { O } } _ { l - 1 }$ , and each expansion ratio $\\chi \\in \\mathcal X$ , respectively: ",
+        "bbox": [
+            174,
+            675,
+            826,
+            718
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d38f0f1db3053c0a05a47dfc308fa13e67a6811961887d05a5e072ab6c8e83e9.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\displaystyle \\sum _ { k = 1 } ^ { | \\mathcal { O } | } \\alpha _ { s , l } ^ { k } = 1 , \\forall s , l } & { \\mathrm { ~ a n d ~ } } & { \\displaystyle \\alpha _ { s , l } ^ { k } \\geq 0 , \\forall k , s , l } \\\\ { \\displaystyle \\beta _ { s , l } ^ { 0 } + \\beta _ { s , l } ^ { 1 } = 1 , \\forall s , l } & { \\mathrm { ~ a n d ~ } } & { \\displaystyle \\beta _ { s , l } ^ { 0 } , \\beta _ { s , l } ^ { 1 } \\geq 0 , \\forall s , l } \\\\ { \\displaystyle \\sum _ { j = 1 } ^ { | \\mathcal { X } | } \\gamma _ { s , l } ^ { j } = 1 , \\forall s , l } & { \\mathrm { ~ a n d ~ } } & { \\displaystyle \\gamma _ { s , l } ^ { j } \\geq 0 , \\forall j , s , l , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            722,
+            668,
+            835
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "where $s$ is downsample rate and $l$ is index of the layer in our supernet. ",
+        "bbox": [
+            173,
+            838,
+            633,
+            853
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "E LATENCY ESTIMATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            873,
+            400,
+            890
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We build a latency lookup table that covers all possible situations and use this lookup table as building blocks to estimate the relaxed latency. To verify the continuous relaxation of latency, we randomly sample networks of different operators/downsample rates/expansion ratios out of the supernet $\\mathcal { M }$ , and measured both the real and estimated latency. We estimate the network latency by accumulating all latencies of operators consisted in the network. In Figure 3, we can see the high correlation between the two measurements, with a correlation coefficient of 0.993. This accurate estimation of network latency benefits from the sequential design of our search space. ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            174
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "F TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            193,
+            294,
+            209
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Given our supernet $\\mathcal { M }$ , the overall optimization target (loss) during architecture search is: ",
+        "bbox": [
+            173,
+            215,
+            761,
+            231
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b079e8c1ef28bc767a617ace8304441c635400805bd0e9742176f926dc85dbf.jpg",
+        "text": "$$\nL = L _ { \\mathrm { s e g } } ( \\mathcal { M } ) + \\lambda \\cdot L a t ( \\mathcal { M } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            236,
+            598,
+            252
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We adopt cross-entropy with “online-hard-element-mining” as our segmentation loss $L _ { \\mathrm { s e g } }$ . $L a t ( \\mathcal { M } )$ is the continuously relaxed latency of supernet, and $\\lambda$ is the balancing factor. We set $\\bar { \\lambda ( \\mathrm { = } 0 . 0 1 }$ in our work. ",
+        "bbox": [
+            174,
+            257,
+            823,
+            299
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "As the architecture $\\alpha , \\beta$ , and $\\gamma$ are now involved in the differentiable computation graph, they can be optimized using gradient descent. Similar in (Liu et al., 2019a), we adopt the first-order approximation ((Liu et al., 2018b)), randomly split our training dataset into two disjoint sets trainA and trainB, and alternates the optimization between: ",
+        "bbox": [
+            176,
+            306,
+            825,
+            363
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. Update network weights $W$ by $\\nabla _ { W } L _ { \\mathrm { s e g } } ( \\mathcal { M } | W , \\alpha , \\beta , \\gamma )$ on trainA, 2. Update architecture $\\alpha , \\beta , \\gamma$ by $\\nabla _ { \\alpha , \\beta , \\gamma } { \\cal L } _ { \\mathrm { s e g } } ( \\mathcal { M } | W , \\alpha , \\beta , \\gamma ) + \\lambda \\cdot \\nabla _ { \\alpha , \\beta , \\gamma } L A T ( \\mathcal { M } | W , \\alpha , \\beta , \\gamma )$ on trainB. ",
+        "bbox": [
+            204,
+            372,
+            825,
+            421
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "When we extend to our teacher-student co-searching where we have two sets of architectures $( \\alpha \\tau , \\beta \\tau )$ and $( \\alpha _ { S } , \\beta _ { S } , \\gamma _ { S } )$ , our alternative optimization becomes: ",
+        "bbox": [
+            173,
+            433,
+            821,
+            460
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. Update network weights $W$ by $\\nabla _ { W } L _ { \\mathrm { s e g } } ( \\mathcal { M } | W , \\alpha _ { T } , \\beta _ { T } )$ on trainA,   \n2. Update network weights $W$ by $\\nabla _ { W } L _ { \\mathrm { s e g } } ( \\mathcal { M } | W , \\alpha _ { S } , \\beta _ { S } , \\gamma _ { S } )$ on trainA,   \n3. Update architecture $\\alpha \\tau , \\beta \\tau$ by $\\nabla _ { \\alpha \\tau , \\beta \\tau , \\gamma \\tau } L _ { \\mathrm { s e g } } ( \\mathcal { M } | W , \\alpha \\tau , \\beta \\tau )$ on trainB.   \n4. Update architecture $\\alpha _ { S } , \\beta _ { S } , \\gamma _ { S }$ by $\\nabla _ { \\alpha _ { S } , \\beta _ { S } , \\gamma _ { S } } L _ { \\mathrm { s e g } } ( { \\mathcal M } | W , \\alpha _ { S } , \\beta _ { S } , \\gamma _ { S } ) ~ + ~ \\lambda ~ .$   \n$\\nabla _ { \\alpha \\boldsymbol { s } , \\beta \\boldsymbol { s } , \\gamma \\boldsymbol { s } } L A T ( \\mathcal { M } | W , \\alpha \\boldsymbol { s } , \\beta \\boldsymbol { s } , \\gamma \\boldsymbol { s } )$ on trainB. ",
+        "bbox": [
+            210,
+            470,
+            823,
+            558
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In all search experiments, we first pretrain the supernet without updating the architecture parameter for 20 epochs, then start architecture searching for 30 epochs. ",
+        "bbox": [
+            173,
+            566,
+            823,
+            595
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Optimizing Multiple Widths: To train multiple widths within a superkernel, it is unrealistic to accumulate losses from all different width options in the super network. Therefore, we approximate the multi-widths optimization by training the maximum and minimum expansion ratios. During pretraining the super network, we train each operator with the smallest width, largest width, and 2 random widths. When we are searching for architecture parameters, we train each operator with the smallest width, largest width, and the width that is sampled from the current $\\gamma$ by Gumbel Softmax. ",
+        "bbox": [
+            173,
+            602,
+            825,
+            686
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "G BENCHMARK DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            705,
+            413,
+            722
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Cityscapes (Cordts et al., 2016) is a popular urban street scene dataset for semantic segmentation. It contains high-quality pixel-level annotations, 2,975 images for training and 500 images for validation. In our experiments, we only use the fine annotated images without any coarse annotated image or extra data like ImageNet (Deng et al., 2009). For testing, it offers 1,525 images without ground-truth for a fair comparison. These images all have a resolution of $1 0 2 4 \\times 2 0 4 8$ $( \\mathrm { H } \\times \\mathrm { W } )$ , where each pixel is annotated to pre-defined 19 classes. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            811
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "CamVid (Brostow et al., 2008) is another street scene dataset, extracted from five video sequences taken from a driving automobile. It contains 701 images in total, where 367 for training, 101 for validation and 233 for testing. The images have a resolution of $7 2 0 \\times 9 6 0$ $( \\mathrm { H } \\times \\mathrm { W } )$ and 11 semantic categories. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            875
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "BDD: The BDD (Yu et al., 2018b) is a recently released urban scene dataset. For the segmentation task, it contains 7,000 images for training and 1,000 for validation. The images have a resolution of $7 2 0 \\times 1 2 8 0$ $( \\mathrm { H } \\times \\mathrm { W } )$ and shared the same 19 semantic categories as used in the Cityscapes. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "H ARCHITECTURE SEARCH IMPLEMENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            584,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "As stated in the second line of Eqn. 2, a stride 2 convolution is used for all $\\mathsf { s } \\to 2 \\mathsf { s }$ connections, both to reduce spatial size and double the number of filters. Bilinear upsampling is used for all upsampling operations. ",
+        "bbox": [
+            174,
+            125,
+            825,
+            166
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We conduct architecture search on the Cityscapes dataset. We use $1 6 0 \\times 3 2 0$ random image crops from half-resolution $( 5 1 2 \\times 1 0 2 4 )$ images in the training set. Note that the original validation set or test set is never used for our architecture search. When learning network weights $W$ , we use SGD optimizer with momentum 0.9 and weight decay of $5 \\times 1 0 ^ { - 4 }$ . We used the exponential learning rate decay of power 0.99. When learning the architecture parameters $\\alpha , \\beta , a n d \\gamma$ , we use Adam optimizer with learning rate $3 \\times 1 0 ^ { - 4 }$ . The entire architecture search optimization takes about 2 days on one 1080Ti GPU. ",
+        "bbox": [
+            173,
+            172,
+            825,
+            271
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "I FASTERSEG STRUCTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            291,
+            408,
+            308
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In Table 7 we list the operators $( O )$ and expansion ratios $( \\chi )$ selected by our FasterSeg. The downsample rates $s$ in Table 7 and Figure 6 match. We have the number of output channels $\\mathrm { c _ { o u t } } = s \\times \\chi$ We observed that the zoomed convolution is heavily used, suggesting the importance of low latency and large receptive field. ",
+        "bbox": [
+            174,
+            314,
+            823,
+            369
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/08e93c66a5d7311b38943e5557fdae771c021c15c045d28e25d5c7e994680961.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Cell</td><td>Operator</td><td>S</td><td>X</td><td>c_out</td></tr><tr><td>1</td><td>conv. ×2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>2</td><td>conv. ×2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>3</td><td>zoomed conv.×2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>4</td><td>zoomed conv. × 2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>5</td><td>conv. ×2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>6</td><td>conv. ×2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>7</td><td>zoomed conv. × 2</td><td>16</td><td>4</td><td>64</td></tr><tr><td>8</td><td>zoomed conv. × 2</td><td>16</td><td>12</td><td>192</td></tr><tr><td>9</td><td>zoomed conv. × 2</td><td>16</td><td>8</td><td>128</td></tr></table>",
+        "bbox": [
+            176,
+            428,
+            465,
+            569
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/13b74565e568f4d2b1f5b9c94d9de2591a9e18748815375124d274bee9b42f37.jpg",
+        "table_caption": [
+            "Table 7: Cells used in FasterSeg. Left: cells for branch with final downsample rate of 16. Right: cells for branch with final downsample rate of 32. s: downsample rate. $\\chi$ : expansion ratio. c out: number of output channels. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Cell</td><td>Operator</td><td>S</td><td>X</td><td>c_out</td></tr><tr><td>1</td><td>conv. ×2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>2</td><td>conv. ×2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>3</td><td>zoomed conv. ×2</td><td>8</td><td>4</td><td>32</td></tr><tr><td>4</td><td>zoomed conv.</td><td>8</td><td>8</td><td>64</td></tr><tr><td>5</td><td>zoomed conv. ×2</td><td>16</td><td>4</td><td>64</td></tr><tr><td>6</td><td>zoomed conv. ×2</td><td>16</td><td>4</td><td>64</td></tr><tr><td>7</td><td>zoomed conv. ×2</td><td>16</td><td>4</td><td>64</td></tr><tr><td>8</td><td>zoomed conv. ×2</td><td>16</td><td>4</td><td>64</td></tr><tr><td>9</td><td>zoomed conv. ×2</td><td>32</td><td>4</td><td>128</td></tr><tr><td>10</td><td>zoomed conv. ×2</td><td>32</td><td>8</td><td>256</td></tr></table>",
+        "bbox": [
+            534,
+            421,
+            818,
+            575
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "J VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            603,
+            338,
+            619
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We show some visualized segmentation results in Figure 7. From the third to the forth column $( ^ { * } O , s | \\chi = 8 , b = 1 ^ { , }$ to ${ } ^ { * * } O , s | \\chi = 8 , b = 2 ^ { * * } )$ , adding the extra branch of different scales provides more consistent segmentations (in the building and sidewalk area). From the fifth to the sixth column $^ { 6 6 } T $ pruned $\\vec { \\tau } ^ { , , }$ to FasterSeg), our FasterSeg surpasses the prunned teacher network, where the \u0001segmentation is smoother and more accurate. ",
+        "bbox": [
+            173,
+            626,
+            825,
+            695
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/d149591a0f165100c2db59c9ef8124fbe2b723ab6d8be32564187f226f473c08.jpg",
+        "image_caption": [
+            "Figure 7: Visualization on Cityscapes validation set. Columns from left to right correspond to original images, ground truths, and results of ${ } ^ { \\imath \\cdot } { \\cal O } , \\bar { s } | \\chi = 8 , b = 1 ^ { \\prime }$ , $\\ ^ { \\cdot \\cdot } { \\cal O } , s | \\chi = 8 , b = 2 ^ { , }$ , $^ { \\mathrm { 6 6 } } T $ pruned $\\gamma \"$ , FasterSeg (see Table 3 for annotation details). Best viewed in color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            709,
+            825,
+            821
+        ],
+        "page_idx": 13
+    }
+]

parse/train/BbikqBWZTGB/BbikqBWZTGB.md

@@ -0,0 +1,271 @@
+# NeRV: Neural Representations for Videos
+
+Hao Chen1, Bo He1, Hanyu Wang1, Yixuan ${ \bf R e n } ^ { 1 }$ , Ser-Nam Lim2, Abhinav Shrivastava1
+
+1University of Maryland, College Park, 2Facebook AI
+
+{chenh, bohe, hywang66, yxren, abhinav}@umd.edu, sernamlim@fb.com
+
+# Abstract
+
+We propose a novel neural representation for videos (NeRV) which encodes videos in neural networks. Unlike conventional representations that treat videos as frame sequences, we represent videos as neural networks taking frame index as input. Given a frame index, NeRV outputs the corresponding RGB image. Video encoding in NeRV is simply fitting a neural network to video frames and decoding process is a simple feedforward operation. As an image-wise implicit representation, NeRV output the whole image and shows great efficiency compared to pixelwise implicit representation, improving the encoding speed by $2 5 \times$ to ${ \bf 7 0 } \times$ , the decoding speed by $3 8 \times$ to $1 3 2 \times$ , while achieving better video quality. With such a representation, we can treat videos as neural networks, simplifying several videorelated tasks. For example, conventional video compression methods are restricted by a long and complex pipeline, specifically designed for the task. In contrast, with NeRV, we can use any neural network compression method as a proxy for video compression, and achieve comparable performance to traditional frame-based video compression approaches (H.264, HEVC etc.). Besides compression, we demonstrate the generalization of NeRV for video denoising. The source code and pre-trained model can be found at https://github.com/haochen-rye/NeRV.git.
+
+# 1 Introduction
+
+What is a video? Typically, a video captures a dynamic visual scene using a sequence of frames. A schematic interpretation of this is a curve in 2D space, where each point can be characterized with a $( x , y )$ pair representing the spatial state. If we have a model for all $( x , y )$ pairs, then, given any $x$ , we can easily find the corresponding $y$ state. Similarly, we can interpret a video as a recording of the visual world, where we can find a corresponding RGB state for every single timestamp. This leads to our main claim: can we represent a video as a function of time?
+
+More formally, can we represent a video $V$ as $V = \{ v _ { t } \} _ { t = 1 } ^ { T }$ , where $v _ { t } = f _ { \theta } ( t )$ , i.e., a frame at timestamp $t$ , is represented as a function $f$ parameterized by $\theta$ . Given their remarkable representational capacity [1], we choose deep neural networks as the function in our work. Given these intuitions, we propose NeRV, a novel representation that represents videos as implicit functions and encodes them into neural networks. Specifically, with a fairly simple deep neural network design, NeRV can reconstruct the corresponding video frames with high quality, given the frame index. Once the video is encoded into a neural network, this network can be used as a proxy for video, where we can directly extract all video information from the representation. Therefore, unlike traditional video representations which treat videos as sequences of frames, shown in Figure 1 (a), our proposed NeRV considers a video as a unified neural network with all information embedded within its architecture and parameters, shown in Figure 1 (b).
+
+As an image-wise implicit representation, NeRV shares lots of similarities with pixel-wise implicit visual representations [5, 6] which takes spatial-temporal coordinates as inputs. The main differences between our work and image-wise implicit representation are the output space and architecture designs. Pixel-wise representations output the RGB value for each pixel, while NeRV outputs a whole image, demonstrated in Figure 2. Given a video with size of $T \times H \times W$ , pixel-wise representations need to sample the video $T * H * W$ times while NeRV only need to sample $T$ times. Considering the huge pixel number, especially for high resolution videos, NeRV shows great advantage for both encoding time and decoding speed. Different output space also leads to different architecture designs, NeRV utilizes a MLP $^ +$ ConvNets architecture to output an image while pixel-wise representation uses a simple MLP to output the RGB value of the pixel. Sampling efficiency of NeRV also simplify the optimization problem, which leads to better reconstruction quality compared to pixel-wise representations.
+
+![](images/4a23b2e768e2436a9ed3bcdf94b250d7f11f0acc6ffba55b8848df60f7cba335.jpg)  
+Figure 1: (a) Conventional video representation as frame sequences. (b) NeRV, representing video as neural networks, which consists of multiple convolutional layers, taking the normalized frame index as the input and output the corresponding RGB frame.
+
+Table 1: Comparison of different video representations. Although explicit representations outperform implicit ones in encoding speed and compression ratio now, NeRV shows great advantage in decoding speed. And NeRV outperforms pixel-wise implicit representations in all metrics.   
+
+<table><tr><td rowspan="2"></td><td colspan="2">Explicit (frame-based)</td><td colspan="2">Implicit (unified)</td></tr><tr><td>Hand-crafted (e.g., HEVC [2])</td><td>Learning-based (e.g., DVC [3])</td><td>Pixel-wise (e.g., NeRF [4]</td><td>Image-wise (Ours)</td></tr><tr><td>Encoding speed</td><td>Fast</td><td>Medium</td><td>Very slow</td><td>Slow</td></tr><tr><td>Decoding speed</td><td>Medium</td><td>Slow</td><td>Very slow</td><td>Fast</td></tr><tr><td>Compression ratio</td><td>Medium</td><td>High</td><td>Low</td><td>Medium</td></tr></table>
+
+We also demonstrate the flexibility of NeRV by exploring several applications it affords. Most notably, we examine the suitability of NeRV for video compression. Traditional video compression frameworks are quite involved, such as specifying key frames and inter frames, estimating the residual information, block-size the video frames, applying discrete cosine transform on the resulting image blocks and so on. Such a long pipeline makes the decoding process very complex as well. In contrast, given a neural network that encodes a video in NeRV, we can simply cast the video compression task as a model compression problem, and trivially leverage any well-established or cutting edge model compression algorithm to achieve good compression ratios. Specifically, we explore a three-step model compression pipeline: model pruning, model quantization, and weight encoding, and show the contributions of each step for the compression task. We conduct extensive experiments on popular video compression datasets, such as UVG [7], and show the applicability of model compression techniques on NeRV for video compression. We briefly compare different video representations in Table 1 and NeRV shows great advantage in decoding speed.
+
+Besides video compression, we also explore other applications of the NeRV representation for the video denoising task. Since NeRV is a learnt implicit function, we can demonstrate its robustness to noise and perturbations. Given a noisy video as input, NeRV generates a high-quality denoised output, without any additional operation, and even outperforms conventional denoising methods.
+
+The contribution of this paper can be summarized into four parts:
+
+• We propose NeRV, a novel image-wise implicit representation for videos, representating a video as a neural network, converting video encoding to model fitting and video decoding as a simple feedforward operation.   
+• Compared to pixel-wise implicit representation, NeRV output the whole image and shows great efficiency, improving the encoding speed by $2 5 \times$ to ${ \bf 7 0 } \times$ , the decoding speed by $3 8 \times$ to $1 3 2 \times$ , while achieving better video quality.   
+• NeRV allows us to convert the video compression problem to a model compression problem, allowing us to leverage standard model compression tools and reach comparable performance with conventional video compression methods, e.g., H.264 [8], and HEVC [2].   
+• As a general representation for videos, NeRV also shows promising results in other tasks, e.g., video denoising. Without any special denoisng design, NeRV outperforms traditional hand-crafted denoising algorithms (medium filter etc.) and ConvNets-based denoisng methods.
+
+# 2 Related Work
+
+Implicit Neural Representation. Implicit neural representation is a novel way to parameterize a variety of signals. The key idea is to represent an object as a function approximated via a neural network, which maps the coordinate to its corresponding value (e.g., pixel coordinate for an image and RGB value of the pixel). It has been widely applied in many 3D vision tasks, such as 3D shapes [9, 10], 3D scenes [11–14], and appearance of the 3D structure [4, 15, 16]. Comparing to explicit 3D representations, such as voxel, point cloud, and mesh, the continuous implicit neural representation can compactly encode high-resolution signals in a memory-efficient way. Most recently, [17] demonstrated the feasibility of using implicit neural representation for image compression tasks. Although it is not yet competitive with the state-of-the-art compression methods, it shows promising and attractive proprieties. In previous methods, MLPs are often used to approximate the implicit neural representations, which take the spatial or spatio-temporal coordinate as the input and output the signals at that single point (e.g., RGB value, volume density). In contrast, our NeRV representation, trains a purposefully designed neural network composed of MLPs and convolution layers, and takes the frame index as input and directly outputs all the RGB values of that frame.
+
+Video Compression. As a fundamental task of computer vision and image processing, visual data compression has been studied for several decades. Before the resurgence of deep networks, handcrafted image compression techniques, like JPEG [18] and JPEG2000 [19], were widely used. Building upon them, many traditional video compression algorithms, such as MPEG [20], H.264 [8], and HEVC [2], have achieved great success. These methods are generally based on transform coding like Discrete Cosine Transform (DCT) [21] or wavelet transform [22], which are well-engineered and tuned to be fast and efficient. More recently, deep learning-based visual compression approaches have been gaining popularity. For video compression, the most common practice is to utilize neural networks for certain components while using the traditional video compression pipeline. For example, [23] proposed an effective image compression approach and generalized it into video compression by adding interpolation loop modules. Similarly, [24] converted the video compression problem into an image interpolation problem and proposed an interpolation network, resulting in competitive compression quality. Furthermore, [25] generalized optical flow to scale-space flow to better model uncertainty in compression. Later, [26] employed a temporal hierarchical structure, and trained neural networks for most components including key frame compression, motion estimation, motions compression, and residual compression. However, all of these works still follow the overall pipeline of traditional compression, arguably limiting their capabilities.
+
+Model Compression. The goal of model compression is to simplify an original model by reducing the number of parameters while maintaining its accuracy. Current research on model compression research can be divided into four groups: parameter pruning and quantization [27–32]; low-rank factorization [33–35]; transferred and compact convolutional filters [36–39]; and knowledge distillation [40–43]. Our proposed NeRV enables us to reformulate the video compression problem into model compression, and utilize standard model compression techniques. Specifically, we use model pruning and quantization to reduce the model size without significantly deteriorating the performance.
+
+![](images/ddffc78fed02ce59fdae910e0235d748c6f63d88aae11e74ca6bc248838f45f7.jpg)  
+Figure 2: (a) Pixel-wise implicit representation taking pixel coordinates as input and use a simple MLP to output pixel RGB value (b) NeRV: Image-wise implicit representation taking frame index as input and use a ${ \bf M L P } + { \bf \Delta }$ ConvNets to output the whole image. (c) NeRV block architecture, upscale the feature map by $S$ here.
+
+# 3 Neural Representations for Videos
+
+We first present the NeRV representation in Section 3.1, including the input embedding, the network architecture, and the loss objective. Then, we present model compression techniques on NeRV in Section 3.2 for video compression.
+
+# 3.1 NeRV Architecture
+
+In NeRV, each video $V = \{ v _ { t } \} _ { t = 1 } ^ { T } \in \mathbb { R } ^ { T \times H \times W \times 3 }$ is represented by a function $f _ { \theta } : \mathbb { R } \to \mathbb { R } ^ { H \times W \times 3 }$ , where the input is a frame index $t$ and the output is the corresponding RGB image $v _ { t } \in \mathbb { R } ^ { H \times W \times 3 }$ . The encoding function is parameterized with a deep neural network $\theta$ , $v _ { t } = f _ { \theta } ( t )$ . Therefore, video encoding is done by fitting a neural network $f _ { \theta }$ to a given video, such that it can map each input timestamp to the corresponding RGB frame.
+
+Input Embedding. Although deep neural networks can be used as universal function approximators [1], directly training the network $f _ { \theta }$ with input timestamp $t$ results in poor results, which is also observed by [4, 44]. By mapping the inputs to a high embedding space, the neural network can better fit data with high-frequency variations. Specifically, in NeRV, we use Positional Encoding [4, 6, 45] as our embedding function
+
+$$
+\Gamma ( t ) = \left( \sin \left( b ^ { 0 } \pi t \right) , \cos \left( b ^ { 0 } \pi t \right) , \ldots , \sin \left( b ^ { l - 1 } \pi t \right) , \cos \left( b ^ { l - 1 } \pi t \right) \right)
+$$
+
+where $b$ and $l$ are hyper-parameters of the networks. Given an input timestamp $t$ , normalized between $( 0 , 1 ]$ , the output of embedding function $\Gamma ( \cdot )$ is then fed to the following neural network.
+
+Network Architecture. NeRV architecture is illustrated in Figure 2 (b). NeRV takes the time embedding as input and outputs the corresponding RGB Frame. Leveraging MLPs to directly output all pixel values of the frames can lead to huge parameters, especially when the images resolutions are large. Therefore, we stack multiple NeRV blocks following the MLP layers so that pixels at different locations can share convolutional kernels, leading to an efficient and effective network. Inspired by the super-resolution networks, we design the NeRV block, illustrated in Figure 2 (c), adopting PixelShuffle technique [46] for upscaling method. Convolution and activation layers are also inserted to enhance the expressibilty. The detailed architecture can be found in the supplementary material.
+
+Loss Objective. For NeRV, we adopt combination of L1 and SSIM loss as our loss function for network optimization, which calculates the loss over all pixel locations of the predicted image and the ground-truth image as following
+
+$$
+L = \frac { 1 } { T } \sum _ { t = 1 } ^ { T } \alpha \parallel f _ { \theta } ( t ) - v _ { t } \parallel _ { 1 } + ( 1 - \alpha ) ( 1 - \mathrm { S S I M } ( f _ { \theta } ( t ) , v _ { t } ) )
+$$
+
+where $T$ is the frame number, $f _ { \theta } ( t ) \in \mathbb { R } ^ { H \times W \times 3 }$ the NeRV prediction, $v _ { t } \in \mathbb { R } ^ { H \times W \times 3 }$ the frame ground truth, $\alpha$ is hyper-parameter to balance the weight for each loss component.
+
+![](images/27d5980cbd0412a5461d542006aa45f36f1dbc6c26b32fa583f9cfd617413225.jpg)  
+Figure 3: NeRV-based video compression pipeline.
+
+# 3.2 Model Compression
+
+In this section, we briefly revisit model compression techniques used for video compression with NeRV. Our model compression composes of four standard sequential steps: video overfit, model pruning, weight quantization, and weight encoding as shown in Figure 3.
+
+Model Pruning. Given a neural network fit on a video, we use global unstructured pruning to reduce the model size first. Based on the magnitude of weight values, we set weights below a threshold as zero,
+
+$$
+\theta _ { i } = { \left\{ \begin{array} { l l } { \theta _ { i } , } & { { \mathrm { i f ~ } } \theta _ { i } \geq \theta _ { q } } \\ { 0 , } & { { \mathrm { o t h e r w i s e } } , } \end{array} \right. }
+$$
+
+where $\theta _ { q }$ is the $q$ percentile value for all parameters in $\theta$ . As a normal practice, we fine-tune the model to regain the representation, after the pruning operation.
+
+Model Quantization. After model pruning, we apply model quantization to all network parameters. Note that different from many recent works [31, 47–49] that utilize quantization during training, NeRV is only quantized post-hoc (after the training process). Given a parameter tensor $\mu$
+
+$$
+\mu _ { i } = \mathrm { r o u n d } \left( { \frac { \mu _ { i } - \mu _ { \mathrm { m i n } } } { 2 ^ { \mathrm { b i t } } } } \right) * { \mathrm { s c a l e } } + \mu _ { \mathrm { m i n } } , \quad \mathrm { s c a l e } = { \frac { \mu _ { \mathrm { m a x } } - \mu _ { \mathrm { m i n } } } { 2 ^ { \mathrm { b i t } } } }
+$$
+
+where ‘round’ is rounding value to the closest integer, ‘bit’ the bit length for quantized model, $\mu _ { \mathrm { m a x } }$ and $\mu _ { \mathrm { { m i n } } }$ the max and min value for the parameter tensor $\mu$ , ‘scale’ the scaling factor. Through Equation 4, each parameter can be mapped to a ‘bit’ length value. The overhead to store ‘scale’ and $\mu _ { \mathrm { { m i n } } }$ can be ignored given the large parameter number of $\mu$ , e.g., they account for only $0 . 0 0 5 \%$ in a small $3 \times 3$ Conv with 64 input channels and 64 output channels ( $3 7 k$ parameters in total).
+
+Entropy Encoding. Finally, we use entropy encoding to further compress the model size. By taking advantage of character frequency, entropy encoding can represent the data with a more efficient codec. Specifically, we employ Huffman Coding [50] after model quantization. Since Huffman Coding is lossless, it is guaranteed that a decent compression can be achieved without any impact on the reconstruction quality. Empirically, this further reduces the model size by around $10 \%$ .
+
+# 4 Experiments
+
+# 4.1 Datasets and Implementation Details
+
+We perform experiments on “Big Buck Bunny” sequence from scikit-video to compare our NeRV with pixel-wise implicit representations, which has 132 frames of $7 2 0 \times 1 0 8 0$ resolution. To compare with state-of-the-arts methods on video compression task, we do experiments on the widely used UVG [7], consisting of 7 videos and 3900 frames with $1 9 2 0 \times 1 0 8 0$ in total.
+
+In our experiments, we train the network using Adam optimizer [51] with learning rate of 5e-4. For ablation study on UVG, we use cosine annealing learning rate schedule [52], batchsize of 1, training epochs of 150, and warmup epochs of 30 unless otherwise denoted. When compare with state-of-the-arts, we run the model for 1500 epochs, with batchsize of 6. For experiments on “Big Buck Bunny”, we train NeRV for 1200 epochs unless otherwise denoted. For fine-tune process after pruning, we use 50 epochs for both UVG and “Big Buck Bunny”.
+
+For NeRV architecture, there are 5 NeRV blocks, with up-scale factor 5, 3, 2, 2, 2 respectively for 1080p videos, and 5, 2, 2, 2, 2 respectively for $7 2 0 \mathrm { p }$ videos. By changing the hidden dimension of MLP and channel dimension of NeRV blocks, we can build NeRV model with different sizes. For input embedding in Equation 1, we use $b = 1 . 2 5$ and $l = 8 0$ as our default setting. For loss objective in Equation 2, $\alpha$ is set to 0.7. We evaluate the video quality with two metrics: PSNR and MS-SSIM [53]. Bits-per-pixel (BPP) is adopted to indicate the compression ratio. We implement our model in PyTorch [54] and train it in full precision (FP32). All experiments are run with NVIDIA RTX2080ti. Please refer to the supplementary material for more experimental details, results, and visualizations (e.g., MCL-JCV [55] results)
+
+Table 2: Compare with pixel-wise implicit representations. Training speed means time/epoch, while encoding time is the total training time.   
+
+<table><tr><td>Methods</td><td>Parameters</td><td>Training Speed↑</td><td>Encoding Time↓</td><td>PSNR ↑</td><td>Decoding FPS↑</td></tr><tr><td>SIREN [5]</td><td>3.2M</td><td>1×</td><td>2.5×</td><td>31.39</td><td>1.4</td></tr><tr><td>NeRF[4]</td><td>3.2M</td><td>1×</td><td>2.5×</td><td>33.31</td><td>1.4</td></tr><tr><td>NeRV-S (ours)</td><td>3.2M</td><td>25×</td><td>1×</td><td>34.21</td><td>54.5</td></tr><tr><td>SIREN [5]</td><td>6.4M</td><td>1×</td><td>5×</td><td>31.37</td><td>0.8</td></tr><tr><td>NeRF[4]</td><td>6.4M</td><td>1×</td><td>5×</td><td>35.17</td><td>0.8</td></tr><tr><td>NeRV-M(ours)</td><td>6.3M</td><td>50×</td><td>1×</td><td>38.14</td><td>53.8</td></tr><tr><td>SIREN [5]</td><td>12.7M</td><td>1×</td><td>7×</td><td>25.06</td><td>0.4</td></tr><tr><td>NeRF[4]</td><td>12.7M</td><td>1×</td><td>7×</td><td>37.94</td><td>0.4</td></tr><tr><td>NeRV-L (ours)</td><td>12.5M</td><td>70×</td><td>1×</td><td>41.29</td><td>52.9</td></tr></table>
+
+Table 3: PSNR vs. epochs. Since video encoding of NeRV is an overfit process, the reconstructed video quality keeps increasing with more training epochs. NeRV-S/M/L mean models with different sizes.   
+
+<table><tr><td>Epoch</td><td>NeRV-S</td><td>NeRV-M</td><td>NeRV-L</td></tr><tr><td>300</td><td>32.21</td><td>36.05</td><td>39.75</td></tr><tr><td>600</td><td>33.56</td><td>37.47</td><td>40.84</td></tr><tr><td>1.2k</td><td>34.21</td><td>38.14</td><td>41.29</td></tr><tr><td>1.8k</td><td>34.33</td><td>38.32</td><td>41.68</td></tr><tr><td>2.4k</td><td>34.86</td><td>38.7</td><td>41.99</td></tr></table>
+
+![](images/cee23f7cec8dc9f63d7cb2b80217ea312a45e7e7a95cc5fd80819e40128d6083.jpg)  
+Figure 4: Model pruning. Sparsity is the ratio of parameters pruned.
+
+![](images/8cf5fe22f7203dd2ec3050c1eca3bf188785ee2e2f6a0834dc60e710900bcd83.jpg)  
+Figure 5: Model quantization. Bit is the bit length used to represent parameter value.
+
+![](images/acd55e6df29ba256cdef3081b2ff322d6ac8d3cc816ebebb07e2d60d51cc2791.jpg)  
+Figure 6: Compression pipeline to show how much each step contribute to compression ratio.
+
+# 4.2 Main Results
+
+We compare NeRV with pixel-wise implicit representations on ’Big Buck Bunny’ video. We take SIREN [5] and NeRF [4] as the baseline, where SIREN [5] takes the original pixel coordinates as input and uses sine activations, while NeRF [4] adds one positional embedding layer to encode the pixel coordinates and uses ReLU activations. Both SIREN and FFN use a 3-layer perceptron and we change the hidden dimension to build model of different sizes. For fair comparison, we train SIREN and FFN for 120 epochs to make encoding time comparable. And we change the filter width to build NeRV model of comparable sizes, named as NeRV-S, NeRV-M, and NeRV-L. In Table 2, NeRV outperforms them greatly in both encoding speed, decoding quality, and decoding speed. Note that NeRV can improve the training speed by $2 5 \times$ to $7 0 \times$ , and speedup the decoding FPS by $3 8 \times$ to $1 3 2 \times$ . We also conduct experiments with different training epochs in Table 3, which clearly shows that longer training time can lead to much better overfit results of the video and we notice that the final performances have not saturated as long as it trains for more epochs.
+
+# 4.3 Video Compression
+
+Compression ablation. We first conduct ablation study on video “Big Buck Bunny”. Figure 4 shows the results of different pruning ratios, where model of $40 \%$ sparsity still reach comparable performance with the full model. As for model quantization step in Figure 5, a 8-bit model still remains the video quality compared to the original one (32-bit). Figure 6 shows the full compression pipeline with NeRV. The compression performance is quite robust to NeRV models of different sizes, and each step shows consistent contribution to our final results. Please note that we only explore these three common compression techniques here, and we believe that other well-established and cutting edge model compression algorithm can be applied to further improve the final performances of video compression task, which is left for future research.
+
+Compare with state-of-the-arts methods. We then compare with state-of-the-arts methods on UVG dataset. First, we concatenate 7 videos into one single video along the time dimension and train NeRV on all the frames from different videos, which we found to be more beneficial than training a single model for each video. After training the network, we apply model pruning, quantization, and weight encoding as described in Section3.2. Figure 7 and Figure 8 show the rate-distortion curves. We compare with H.264 [8], HEVC [2], STAT-SSF-SP [56], HLVC [26], Scale-space [25], and Wu et al. [24]. H.264 and HEVC are performed with medium preset mode. As the first image-wise neural representation, NeRV generally achieves comparable performance with traditional video compression techniques and other learning-based video compression approaches. It is worth noting that when BPP is small, NeRV can match the performance of the state-of-the-art method, showing its great potential in high-rate video compression. When BPP becomes large, the performance gap is mostly because of the lack of full training due to GPU resources limitations. As shown in Table 3, the decoding video quality keeps increasing when the training epochs are longer. Figure 9 shows visualizations for decoding frames. At similar memory budget, NeRV shows image details with better quality.
+
+![](images/e24b3466b603bb859067fbf041a59f8ed274e861e03f67e7f244a71525cb3891.jpg)  
+Figure 7: PSNR vs. BPP on UVG dataset.
+
+![](images/fc114f71acbbb4cf0ecc915b70b0c82942a6d6aac03141e978d0b34760dd29b7.jpg)  
+Figure 8: MS-SSIM vs. BPP on UVG dataset.
+
+![](images/337e922d6a084dae5ade187f0d3d5a4eb2e33364f06fdd59e866cfaab4e138a2.jpg)  
+Figure 9: Video compression visualization. At similar BPP, NeRV reconstructs videos with better details.
+
+Decoding time We compare with other methods for decoding time under a similar memory budget. Note that HEVC is run on CPU, while all other learning-based methods are run on a single GPU, including our NeRV. We speedup NeRV by running it in half precision (FP16). Due to the simple decoding process (feedforward operation), NeRV shows great advantage, even for carefully-optimized H.264. And lots of speepup can be expected by running quantizaed model on special hardware. All the other video compression methods have two types of frames: key and interval frames. Key frame can be reconstructed by its encoded feature only while the interval frame reconstruction is also based on the reconstructed key frames. Since most video frames are interval frames, their decoding needs to be done in a sequential manner after the reconstruction of the respective key frames. On the contrary, our NeRV can output frames at any random time index independently, thus making parallel decoding much simpler. This can be viewed as a distinct advantage over other methods.
+
+# 4.4 Video Denoising
+
+We apply several common noise patterns on the original video and train the model on the perturbed ones. During training, no masks or noise locations are provided to the model, i.e., the target of the model is the noisy frames while the model has no extra signal of whether the input is noisy or not. Surprisingly, our model tries to avoid the influence of the noise and regularizes them implicitly with little harm to the compression task simultaneously, which can serve well for most partially distorted videos in practice.
+
+Table 4: Decoding speed with BPP 0.2 for 1080p videos   
+
+<table><tr><td>Methods</td><td>FPS ↑</td></tr><tr><td>Habibian et al. [14] Wu et al. [24] Rippel et al. [57]</td><td>10-3.7 10-3 1</td></tr><tr><td>DVC [3] Liu et al [58] H.264 [8]</td><td>1.8 3 9.2</td></tr><tr><td>NeRV (FP32) NeRV (FP16)</td><td>5.6 12.5</td></tr></table>
+
+Table 5: PSNR results for video denoising. “baseline” refers to the noisy frames before any denoising   
+
+<table><tr><td>noise</td><td>white 个</td><td>black ↑</td><td>salt&amp; 个 pepper</td><td>random 个</td><td>Average ↑</td></tr><tr><td>Baseline</td><td>27.85</td><td>28.29</td><td>27.95</td><td>30.95</td><td>28.74</td></tr><tr><td>Gaussian</td><td>30.27</td><td>30.14</td><td>30.23</td><td>30.99</td><td>30.41</td></tr><tr><td>Uniform</td><td>29.11</td><td>29.06</td><td>29.10</td><td>29.63</td><td>29.22</td></tr><tr><td>Median</td><td>33.89</td><td>33.84</td><td>33.87</td><td>33.89</td><td>33.87</td></tr><tr><td>Minimum</td><td>20.55</td><td>16.60</td><td>18.09</td><td>18.20</td><td>18.36</td></tr><tr><td>Maximum</td><td>16.16</td><td>20.26</td><td>17.69</td><td>17.83</td><td>17.99</td></tr><tr><td>NeRV</td><td>33.31</td><td>34.20</td><td>34.17</td><td>34.80</td><td>34.12</td></tr></table>
+
+![](images/b8033d8855f0573bebf69e0712b90a54f18cf5aead605e34902e9a7eef2caf56.jpg)  
+Figure 10: Denoising visualization. (c) and (e) are denoising output for DIP [59]. Data generalization of NeRV leads to robust and better denoising performance since all frames share the same representation, while DIP model overfits one model to one image only.
+
+The results are compared with some standard denoising methods including Gaussian, uniform, and median filtering. These can be viewed as denoising upper bound for any additional compression process. As listed in Table 5, the PSNR of NeRV output is usually much higher than the noisy frames although it’s trained on the noisy target in a fully supervised manner, and has reached an acceptable level for general denoising purpose. Specifically, median filtering has the best performance among the traditional denoising techniques, while NeRV outperforms it in most cases or is at least comparable without any extra denoising design in both architecture design and training strategy.
+
+We also compare NeRV with another neural-network-based denoising method, Deep Image Prior (DIP) [59]. Although its main target is image denoising, NeRV outperforms it in both qualitative and quantitative metrics, demonstrated in Figure 10. The main difference between them is that denoising of DIP only comes form architecture prior, while the denoising ability of NeRV comes from both architecture prior and data prior. DIP emphasizes that its image prior is only captured by the network structure of Convolution operations because it only feeds on a single image. But the training data of NeRV contain many video frames, sharing lots of visual contents and consistences. As a result, image prior is captured by both the network structure and the training data statistics for NeRV. DIP relies significantly on a good early stopping strategy to prevent it from overfitting to the noise. Without the noise prior, it has to be used with fixed iterations settings, which is not easy to generalize to any random kind of noises as mentioned above. By contrast, NeRV is able to handle this naturally by keeping training because the full set of consecutive video frames provides a strong regularization on image content over noise.
+
+Table 6: Input embedding ablation. PE means positional encoding   
+
+<table><tr><td></td><td>PSNR</td><td>MS-SSIM</td></tr><tr><td>None</td><td>24.93</td><td>0.769</td></tr><tr><td>PE</td><td>37.26</td><td>0.970</td></tr></table>
+
+Table 7: Upscale layer ablation   
+
+<table><tr><td></td><td>PSNR</td><td>MS-SSIM</td></tr><tr><td>Bilinear Pooling</td><td>29.56</td><td>0.873</td></tr><tr><td>Transpose Conv</td><td>36.63</td><td>0.967</td></tr><tr><td>PixelShuffle</td><td>37.26</td><td>0.970</td></tr></table>
+
+Table 8: Norm layer ablation   
+
+<table><tr><td></td><td>PSNR</td><td>MS-SSIM</td></tr><tr><td>BatchNorm</td><td>36.71</td><td>0.971</td></tr><tr><td>InstanceNorm</td><td>35.5</td><td>0.963</td></tr><tr><td>None</td><td>37.26</td><td>0.970</td></tr></table>
+
+Table 9: Activation function ablation   
+
+<table><tr><td></td><td>PSNR</td><td>MS-SSIM</td></tr><tr><td>ReLU</td><td>35.89</td><td>0.963</td></tr><tr><td>Leaky ReLU</td><td>36.76</td><td>0.968</td></tr><tr><td>Swish</td><td>37.08</td><td>0.969</td></tr><tr><td>GELU</td><td>37.26</td><td>0.970</td></tr></table>
+
+Table 10: Loss objective ablation   
+
+<table><tr><td>L2</td><td>L1</td><td>SSIM</td><td>PSNR</td><td>MS-SSIM</td></tr><tr><td>√</td><td></td><td></td><td>35.64</td><td>0.956</td></tr><tr><td></td><td>√</td><td></td><td>35.77</td><td>0.959</td></tr><tr><td></td><td></td><td>√</td><td>35.69</td><td>0.971</td></tr><tr><td>√</td><td>√</td><td></td><td>35.95</td><td>0.960</td></tr><tr><td>√</td><td></td><td>√</td><td>36.46</td><td>0.970</td></tr><tr><td></td><td>√</td><td>√</td><td>37.26</td><td>0.970</td></tr></table>
+
+# 4.5 Ablation Studies
+
+Finally, we provide ablation studies on the UVG dataset. PSNR and MS-SSIM are adopted for evaluation of the reconstructed videos.
+
+Input embedding. In Table 6, PE means positional encoding as in Equation 1, which greatly improves the baseline, None means taking the frame index as input directly. Similar findings can be found in [4], without any input embedding, the model can not learn high-frequency information, resulting in much lower performance.
+
+Upscale layer. In Table 7, we show results of three different upscale methods. i.e., Bilinear Pooling, Transpose Convolution, and PixelShuffle [46]. With similar model sizes, PixelShuffle shows best results. Please note that although Transpose convolution [60] reach comparable results, it greatly slowdown the training speed compared to the PixelShuffle.
+
+Normalization layer. In Table 8, we apply common normalization layers in NeRV block. The default setup, without normalization layer, reaches the best performance and runs slightly faster. We hypothesize that the normalization layer reduces the over-fitting capability of the neural network, which is contradictory to our training objective.
+
+Activation layer. Table 9 shows results for common activation layers. The GELU [61] activation function achieve the highest performances, which is adopted as our default design.
+
+Loss objective. We show loss objective ablation in Table 10. We shows performance results of different combinations of L2, L1, and SSIM loss. Although adopting SSIM alone can produce the highest MS-SSIM score, but the combination of L1 loss and SSIM loss can achieve the best trade-off between the PSNR performance and MS-SSIM score.
+
+# 5 Discussion
+
+Conclusion. In this work, we present a novel neural representation for videos, NeRV, which encodes videos into neural networks. Our key sight is that by directly training a neural network with video frame index and output corresponding RGB image, we can use the weights of the model to represent the videos, which is totally different from conventional representations that treat videos as consecutive frame sequences. With such a representation, we show that by simply applying general model compression techniques, NeRV can match the performances of traditional video compression approaches for the video compression task, without the need to design a long and complex pipeline. We also show that NeRV can outperform standard denoising methods. We hope that this paper can inspire further research works to design novel class of methods for video representations.
+
+Limitations and Future Work. There are some limitations with the proposed NeRV. First, to achieve the comparable PSNR and MS-SSIM performances, the training time of our proposed approach is longer than the encoding time of traditional video compression methods. Second, the architecture design of NeRV is still not optimal yet, we believe more exploration on the neural architecture design can achieve higher performances. Finally, more advanced and cutting the edge model compression methods can be applied to NeRV and obtain higher compression ratios.
+
+Acknowledgement. This project was partially funded by the DARPA SAIL-ON (W911NF2020009) program, an independent grant from Facebook AI, and Amazon Research Award to AS.
+
+References   
+[1] Kurt Hornik, Maxwell Stinchcombe, and Halbert White. Multilayer feedforward networks are universal approximators. Neural networks, 2(5):359–366, 1989. 1, 4   
+[2] Gary J Sullivan, Jens-Rainer Ohm, Woo-Jin Han, and Thomas Wiegand. Overview of the high efficiency video coding (hevc) standard. IEEE Transactions on circuits and systems for video technology, 22(12):1649– 1668, 2012. 2, 3, 6   
+[3] Guo Lu, Wanli Ouyang, Dong Xu, Xiaoyun Zhang, Chunlei Cai, and Zhiyong Gao. Dvc: An end-to-end deep video compression framework. In CVPR, 2019. 2, 8   
+[4] Ben Mildenhall, Pratul P Srinivasan, Matthew Tancik, Jonathan T Barron, Ravi Ramamoorthi, and Ren Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. In European Conference on Computer Vision, pages 405–421. Springer, 2020. 2, 3, 4, 6, 9   
+[5] Vincent Sitzmann, Julien Martel, Alexander Bergman, David Lindell, and Gordon Wetzstein. Implicit neural representations with periodic activation functions. Advances in Neural Information Processing Systems, 33, 2020. 1, 6   
+[6] Matthew Tancik, Pratul P Srinivasan, Ben Mildenhall, Sara Fridovich-Keil, Nithin Raghavan, Utkarsh Singhal, Ravi Ramamoorthi, Jonathan T Barron, and Ren $\mathrm { N g }$ . Fourier features let networks learn high frequency functions in low dimensional domains. NeurIPS, 2020. 1, 4   
+[7] Alexandre Mercat, Marko Viitanen, and Jarno Vanne. Uvg dataset: 50/120fps 4k sequences for video codec analysis and development. In Proceedings of the 11th ACM Multimedia Systems Conference, pages 297–302, 2020. 2, 5   
+[8] Thomas Wiegand, Gary J Sullivan, Gisle Bjontegaard, and Ajay Luthra. Overview of the h. 264/avc video coding standard. IEEE Transactions on circuits and systems for video technology, 13(7):560–576, 2003. 3, 6, 8   
+[9] Kyle Genova, Forrester Cole, Daniel Vlasic, Aaron Sarna, William T Freeman, and Thomas Funkhouser. Learning shape templates with structured implicit functions. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 7154–7164, 2019. 3   
+[10] Kyle Genova, Forrester Cole, Avneesh Sud, Aaron Sarna, and Thomas A Funkhouser. Deep structured implicit functions. 2019. 3   
+[11] Vincent Sitzmann, Michael Zollhöfer, and Gordon Wetzstein. Scene representation networks: Continuous 3d-structure-aware neural scene representations. arXiv preprint arXiv:1906.01618, 2019. 3   
+[12] Chiyu Jiang, Avneesh Sud, Ameesh Makadia, Jingwei Huang, Matthias Nießner, Thomas Funkhouser, et al. Local implicit grid representations for 3d scenes. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 6001–6010, 2020.   
+[13] Songyou Peng, Michael Niemeyer, Lars Mescheder, Marc Pollefeys, and Andreas Geiger. Convolutional occupancy networks. arXiv preprint arXiv:2003.04618, 2, 2020.   
+[14] Rohan Chabra, Jan E Lenssen, Eddy Ilg, Tanner Schmidt, Julian Straub, Steven Lovegrove, and Richard Newcombe. Deep local shapes: Learning local sdf priors for detailed 3d reconstruction. In European Conference on Computer Vision, pages 608–625. Springer, 2020. 3, 8   
+[15] Michael Niemeyer, Lars Mescheder, Michael Oechsle, and Andreas Geiger. Differentiable volumetric rendering: Learning implicit 3d representations without 3d supervision. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 3504–3515, 2020. 3   
+[16] Michael Oechsle, Lars Mescheder, Michael Niemeyer, Thilo Strauss, and Andreas Geiger. Texture fields: Learning texture representations in function space. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 4531–4540, 2019. 3   
+[17] Emilien Dupont, Adam Golinski, Milad Alizadeh, Yee Whye Teh, and Arnaud Doucet. Coin: Compression ´ with implicit neural representations. arXiv preprint arXiv:2103.03123, 2021. 3   
+[18] Gregory K Wallace. The jpeg still picture compression standard. IEEE transactions on consumer electronics, 38(1):xviii–xxxiv, 1992. 3   
+[19] Athanassios Skodras, Charilaos Christopoulos, and Touradj Ebrahimi. The jpeg 2000 still image compression standard. IEEE Signal processing magazine, 18(5):36–58, 2001. 3   
+[20] Didier Le Gall. Mpeg: A video compression standard for multimedia applications. Communications of the ACM, 34(4):46–58, 1991. 3   
+[21] Nasir Ahmed, T_ Natarajan, and Kamisetty R Rao. Discrete cosine transform. IEEE transactions on Computers, 100(1):90–93, 1974. 3   
+[22] Marc Antonini, Michel Barlaud, Pierre Mathieu, and Ingrid Daubechies. Image coding using wavelet transform. IEEE Transactions on image processing, 1(2):205–220, 1992. 3   
+[23] Zhengxue Cheng, Heming Sun, Masaru Takeuchi, and Jiro Katto. Learning image and video compression through spatial-temporal energy compaction. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 10071–10080, 2019. 3   
+[24] Chao-Yuan Wu, Nayan Singhal, and Philipp Krahenbuhl. Video compression through image interpolation. In Proceedings of the European Conference on Computer Vision (ECCV), pages 416–431, 2018. 3, 6, 8   
+[25] Eirikur Agustsson, David Minnen, Nick Johnston, Johannes Balle, Sung Jin Hwang, and George Toderici. Scale-space flow for end-to-end optimized video compression. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8503–8512, 2020. 3, 6   
+[26] Ren Yang, Fabian Mentzer, Luc Van Gool, and Radu Timofte. Learning for video compression with hierarchical quality and recurrent enhancement. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 6628–6637, 2020. 3, 6   
+[27] Vincent Vanhoucke, Andrew Senior, and Mark Z Mao. Improving the speed of neural networks on cpus. 2011. 3   
+[28] Suyog Gupta, Ankur Agrawal, Kailash Gopalakrishnan, and Pritish Narayanan. Deep learning with limited numerical precision. In International conference on machine learning, pages 1737–1746. PMLR, 2015.   
+[29] 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.   
+[30] Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. arXiv preprint arXiv:1608.03665, 2016.   
+[31] 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 integerarithmetic-only inference. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 2704–2713, 2018. 5   
+[32] Raghuraman Krishnamoorthi. Quantizing deep convolutional networks for efficient inference: A whitepaper. arXiv preprint arXiv:1806.08342, 2018. 3   
+[33] Roberto Rigamonti, Amos Sironi, Vincent Lepetit, and Pascal Fua. Learning separable filters. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2754–2761, 2013. 3   
+[34] Emily Denton, Wojciech Zaremba, Joan Bruna, Yann LeCun, and Rob Fergus. Exploiting linear structure within convolutional networks for efficient evaluation. arXiv preprint arXiv:1404.0736, 2014.   
+[35] Max Jaderberg, Andrea Vedaldi, and Andrew Zisserman. Speeding up convolutional neural networks with low rank expansions. arXiv preprint arXiv:1405.3866, 2014. 3   
+[36] Taco Cohen and Max Welling. Group equivariant convolutional networks. In International conference on machine learning, pages 2990–2999. PMLR, 2016. 3   
+[37] Shuangfei Zhai, Yu Cheng, Weining Lu, and Zhongfei Zhang. Doubly convolutional neural networks. arXiv preprint arXiv:1610.09716, 2016.   
+[38] Wenling Shang, Kihyuk Sohn, Diogo Almeida, and Honglak Lee. Understanding and improving convolutional neural networks via concatenated rectified linear units. In international conference on machine learning, pages 2217–2225. PMLR, 2016.   
+[39] Sander Dieleman, Jeffrey De Fauw, and Koray Kavukcuoglu. Exploiting cyclic symmetry in convolutional neural networks. In International conference on machine learning, pages 1889–1898. PMLR, 2016. 3   
+[40] Lei Jimmy Ba and Rich Caruana. Do deep nets really need to be deep? arXiv preprint arXiv:1312.6184, 2013. 3   
+[41] Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.   
+[42] Guobin Chen, Wongun Choi, Xiang Yu, Tony Han, and Manmohan Chandraker. Learning efficient object detection models with knowledge distillation. In Proceedings of the 31st International Conference on Neural Information Processing Systems, pages 742–751, 2017.   
+[43] Antonio Polino, Razvan Pascanu, and Dan Alistarh. Model compression via distillation and quantization. arXiv preprint arXiv:1802.05668, 2018. 3   
+[44] Nasim Rahaman, Aristide Baratin, Devansh Arpit, Felix Draxler, Min Lin, Fred Hamprecht, Yoshua Bengio, and Aaron Courville. On the spectral bias of neural networks. In International Conference on Machine Learning, pages 5301–5310. PMLR, 2019. 4   
+[45] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. arXiv preprint arXiv:1706.03762, 2017. 4   
+[46] Wenzhe Shi, Jose Caballero, Ferenc Huszár, Johannes Totz, Andrew P Aitken, Rob Bishop, Daniel Rueckert, and Zehan Wang. Real-time single image and video super-resolution using an efficient sub-pixel convolutional neural network. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1874–1883, 2016. 4, 9   
+[47] Ron Banner, Itay Hubara, Elad Hoffer, and Daniel Soudry. Scalable methods for 8-bit training of neural networks. arXiv preprint arXiv:1805.11046, 2018. 5   
+[48] Fartash Faghri, Iman Tabrizian, Ilia Markov, Dan Alistarh, Daniel Roy, and Ali Ramezani-Kebrya. Adaptive gradient quantization for data-parallel sgd. arXiv preprint arXiv:2010.12460, 2020.   
+[49] Naigang Wang, Jungwook Choi, Daniel Brand, Chia-Yu Chen, and Kailash Gopalakrishnan. Training deep neural networks with 8-bit floating point numbers. arXiv preprint arXiv:1812.08011, 2018. 5   
+[50] David A Huffman. A method for the construction of minimum-redundancy codes. Proceedings of the IRE, 40(9):1098–1101, 1952. 5   
+[51] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. 5   
+[52] Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint arXiv:1608.03983, 2016. 5   
+[53] Zhou Wang, Eero P Simoncelli, and Alan C Bovik. Multiscale structural similarity for image quality assessment. In The Thrity-Seventh Asilomar Conference on Signals, Systems Computers, 2003, volume 2, pages 1398–1402. Ieee, 2003. 5   
+[54] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, high-performance deep learning library. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32, pages 8024–8035. Curran Associates, Inc., 2019. 5   
+[55] Haiqiang Wang, Weihao Gan, Sudeng Hu, Joe Yuchieh Lin, Lina Jin, Longguang Song, Ping Wang, Ioannis Katsavounidis, Anne Aaron, and C-C Jay Kuo. Mcl-jcv: a jnd-based h. 264/avc video quality assessment dataset. In 2016 IEEE International Conference on Image Processing (ICIP), pages 1509–1513. IEEE, 2016. 5   
+[56] Ruihan Yang, Yibo Yang, Joseph Marino, and Stephan Mandt. Hierarchical autoregressive modeling for neural video compression. arXiv preprint arXiv:2010.10258, 2020. 6   
+[57] Oren Rippel, Sanjay Nair, Carissa Lew, Steve Branson, Alexander G Anderson, and Lubomir Bourdev. Learned video compression. In ICCV, 2019. 8   
+[58] Jerry Liu, Shenlong Wang, Wei-Chiu Ma, Meet Shah, Rui Hu, Pranaab Dhawan, and Raquel Urtasun. Conditional entropy coding for efficient video compression. In ECCV, 2020. 8   
+[59] Dmitry Ulyanov, Andrea Vedaldi, and Victor Lempitsky. Deep image prior. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 9446–9454, 2018. 8   
+[60] Vincent Dumoulin and Francesco Visin. A guide to convolution arithmetic for deep learning. arXiv preprint arXiv:1603.07285, 2016. 9   
+[61] Dan Hendrycks and Kevin Gimpel. Gaussian error linear units (gelus). arXiv preprint arXiv:1606.08415, 2016. 9

parse/train/BbikqBWZTGB/BbikqBWZTGB_content_list.json

@@ -0,0 +1,1104 @@
+[
+    {
+        "type": "text",
+        "text": "NeRV: Neural Representations for Videos ",
+        "text_level": 1,
+        "bbox": [
+            243,
+            122,
+            753,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hao Chen1, Bo He1, Hanyu Wang1, Yixuan ${ \\bf R e n } ^ { 1 }$ , Ser-Nam Lim2, Abhinav Shrivastava1 ",
+        "bbox": [
+            187,
+            199,
+            803,
+            215
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1University of Maryland, College Park, 2Facebook AI ",
+        "bbox": [
+            318,
+            220,
+            676,
+            236
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{chenh, bohe, hywang66, yxren, abhinav}@umd.edu, sernamlim@fb.com ",
+        "bbox": [
+            212,
+            241,
+            776,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            289,
+            535,
+            305
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a novel neural representation for videos (NeRV) which encodes videos in neural networks. Unlike conventional representations that treat videos as frame sequences, we represent videos as neural networks taking frame index as input. Given a frame index, NeRV outputs the corresponding RGB image. Video encoding in NeRV is simply fitting a neural network to video frames and decoding process is a simple feedforward operation. As an image-wise implicit representation, NeRV output the whole image and shows great efficiency compared to pixelwise implicit representation, improving the encoding speed by $2 5 \\times$ to ${ \\bf 7 0 } \\times$ , the decoding speed by $3 8 \\times$ to $1 3 2 \\times$ , while achieving better video quality. With such a representation, we can treat videos as neural networks, simplifying several videorelated tasks. For example, conventional video compression methods are restricted by a long and complex pipeline, specifically designed for the task. In contrast, with NeRV, we can use any neural network compression method as a proxy for video compression, and achieve comparable performance to traditional frame-based video compression approaches (H.264, HEVC etc.). Besides compression, we demonstrate the generalization of NeRV for video denoising. The source code and pre-trained model can be found at https://github.com/haochen-rye/NeRV.git. ",
+        "bbox": [
+            233,
+            320,
+            766,
+            554
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            579,
+            310,
+            597
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "What is a video? Typically, a video captures a dynamic visual scene using a sequence of frames. A schematic interpretation of this is a curve in 2D space, where each point can be characterized with a $( x , y )$ pair representing the spatial state. If we have a model for all $( x , y )$ pairs, then, given any $x$ , we can easily find the corresponding $y$ state. Similarly, we can interpret a video as a recording of the visual world, where we can find a corresponding RGB state for every single timestamp. This leads to our main claim: can we represent a video as a function of time? ",
+        "bbox": [
+            174,
+            611,
+            825,
+            695
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "More formally, can we represent a video $V$ as $V = \\{ v _ { t } \\} _ { t = 1 } ^ { T }$ , where $v _ { t } = f _ { \\theta } ( t )$ , i.e., a frame at timestamp $t$ , is represented as a function $f$ parameterized by $\\theta$ . Given their remarkable representational capacity [1], we choose deep neural networks as the function in our work. Given these intuitions, we propose NeRV, a novel representation that represents videos as implicit functions and encodes them into neural networks. Specifically, with a fairly simple deep neural network design, NeRV can reconstruct the corresponding video frames with high quality, given the frame index. Once the video is encoded into a neural network, this network can be used as a proxy for video, where we can directly extract all video information from the representation. Therefore, unlike traditional video representations which treat videos as sequences of frames, shown in Figure 1 (a), our proposed NeRV considers a video as a unified neural network with all information embedded within its architecture and parameters, shown in Figure 1 (b). ",
+        "bbox": [
+            174,
+            699,
+            825,
+            853
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As an image-wise implicit representation, NeRV shares lots of similarities with pixel-wise implicit visual representations [5, 6] which takes spatial-temporal coordinates as inputs. The main differences between our work and image-wise implicit representation are the output space and architecture designs. Pixel-wise representations output the RGB value for each pixel, while NeRV outputs a whole image, demonstrated in Figure 2. Given a video with size of $T \\times H \\times W$ , pixel-wise representations need to sample the video $T * H * W$ times while NeRV only need to sample $T$ times. Considering the huge pixel number, especially for high resolution videos, NeRV shows great advantage for both encoding time and decoding speed. Different output space also leads to different architecture designs, NeRV utilizes a MLP $^ +$ ConvNets architecture to output an image while pixel-wise representation uses a simple MLP to output the RGB value of the pixel. Sampling efficiency of NeRV also simplify the optimization problem, which leads to better reconstruction quality compared to pixel-wise representations. ",
+        "bbox": [
+            176,
+            859,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/4a23b2e768e2436a9ed3bcdf94b250d7f11f0acc6ffba55b8848df60f7cba335.jpg",
+        "image_caption": [
+            "Figure 1: (a) Conventional video representation as frame sequences. (b) NeRV, representing video as neural networks, which consists of multiple convolutional layers, taking the normalized frame index as the input and output the corresponding RGB frame. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            90,
+            808,
+            275
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/57d33f0273f5d056f70fa3841a45e6afd3b315360baeea50183c0ef059bdf9c7.jpg",
+        "table_caption": [
+            "Table 1: Comparison of different video representations. Although explicit representations outperform implicit ones in encoding speed and compression ratio now, NeRV shows great advantage in decoding speed. And NeRV outperforms pixel-wise implicit representations in all metrics. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">Explicit (frame-based)</td><td colspan=\"2\">Implicit (unified)</td></tr><tr><td>Hand-crafted (e.g., HEVC [2])</td><td>Learning-based (e.g., DVC [3])</td><td>Pixel-wise (e.g., NeRF [4]</td><td>Image-wise (Ours)</td></tr><tr><td>Encoding speed</td><td>Fast</td><td>Medium</td><td>Very slow</td><td>Slow</td></tr><tr><td>Decoding speed</td><td>Medium</td><td>Slow</td><td>Very slow</td><td>Fast</td></tr><tr><td>Compression ratio</td><td>Medium</td><td>High</td><td>Low</td><td>Medium</td></tr></table>",
+        "bbox": [
+            227,
+            392,
+            766,
+            489
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            517,
+            825,
+            642
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We also demonstrate the flexibility of NeRV by exploring several applications it affords. Most notably, we examine the suitability of NeRV for video compression. Traditional video compression frameworks are quite involved, such as specifying key frames and inter frames, estimating the residual information, block-size the video frames, applying discrete cosine transform on the resulting image blocks and so on. Such a long pipeline makes the decoding process very complex as well. In contrast, given a neural network that encodes a video in NeRV, we can simply cast the video compression task as a model compression problem, and trivially leverage any well-established or cutting edge model compression algorithm to achieve good compression ratios. Specifically, we explore a three-step model compression pipeline: model pruning, model quantization, and weight encoding, and show the contributions of each step for the compression task. We conduct extensive experiments on popular video compression datasets, such as UVG [7], and show the applicability of model compression techniques on NeRV for video compression. We briefly compare different video representations in Table 1 and NeRV shows great advantage in decoding speed. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            828
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Besides video compression, we also explore other applications of the NeRV representation for the video denoising task. Since NeRV is a learnt implicit function, we can demonstrate its robustness to noise and perturbations. Given a noisy video as input, NeRV generates a high-quality denoised output, without any additional operation, and even outperforms conventional denoising methods. ",
+        "bbox": [
+            176,
+            835,
+            825,
+            890
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The contribution of this paper can be summarized into four parts: ",
+        "bbox": [
+            173,
+            897,
+            599,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose NeRV, a novel image-wise implicit representation for videos, representating a video as a neural network, converting video encoding to model fitting and video decoding as a simple feedforward operation.   \n• Compared to pixel-wise implicit representation, NeRV output the whole image and shows great efficiency, improving the encoding speed by $2 5 \\times$ to ${ \\bf 7 0 } \\times$ , the decoding speed by $3 8 \\times$ to $1 3 2 \\times$ , while achieving better video quality.   \n• NeRV allows us to convert the video compression problem to a model compression problem, allowing us to leverage standard model compression tools and reach comparable performance with conventional video compression methods, e.g., H.264 [8], and HEVC [2].   \n• As a general representation for videos, NeRV also shows promising results in other tasks, e.g., video denoising. Without any special denoisng design, NeRV outperforms traditional hand-crafted denoising algorithms (medium filter etc.) and ConvNets-based denoisng methods. ",
+        "bbox": [
+            192,
+            92,
+            826,
+            291
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            316,
+            321,
+            333
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Implicit Neural Representation. Implicit neural representation is a novel way to parameterize a variety of signals. The key idea is to represent an object as a function approximated via a neural network, which maps the coordinate to its corresponding value (e.g., pixel coordinate for an image and RGB value of the pixel). It has been widely applied in many 3D vision tasks, such as 3D shapes [9, 10], 3D scenes [11–14], and appearance of the 3D structure [4, 15, 16]. Comparing to explicit 3D representations, such as voxel, point cloud, and mesh, the continuous implicit neural representation can compactly encode high-resolution signals in a memory-efficient way. Most recently, [17] demonstrated the feasibility of using implicit neural representation for image compression tasks. Although it is not yet competitive with the state-of-the-art compression methods, it shows promising and attractive proprieties. In previous methods, MLPs are often used to approximate the implicit neural representations, which take the spatial or spatio-temporal coordinate as the input and output the signals at that single point (e.g., RGB value, volume density). In contrast, our NeRV representation, trains a purposefully designed neural network composed of MLPs and convolution layers, and takes the frame index as input and directly outputs all the RGB values of that frame. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            553
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Video Compression. As a fundamental task of computer vision and image processing, visual data compression has been studied for several decades. Before the resurgence of deep networks, handcrafted image compression techniques, like JPEG [18] and JPEG2000 [19], were widely used. Building upon them, many traditional video compression algorithms, such as MPEG [20], H.264 [8], and HEVC [2], have achieved great success. These methods are generally based on transform coding like Discrete Cosine Transform (DCT) [21] or wavelet transform [22], which are well-engineered and tuned to be fast and efficient. More recently, deep learning-based visual compression approaches have been gaining popularity. For video compression, the most common practice is to utilize neural networks for certain components while using the traditional video compression pipeline. For example, [23] proposed an effective image compression approach and generalized it into video compression by adding interpolation loop modules. Similarly, [24] converted the video compression problem into an image interpolation problem and proposed an interpolation network, resulting in competitive compression quality. Furthermore, [25] generalized optical flow to scale-space flow to better model uncertainty in compression. Later, [26] employed a temporal hierarchical structure, and trained neural networks for most components including key frame compression, motion estimation, motions compression, and residual compression. However, all of these works still follow the overall pipeline of traditional compression, arguably limiting their capabilities. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            801
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Model Compression. The goal of model compression is to simplify an original model by reducing the number of parameters while maintaining its accuracy. Current research on model compression research can be divided into four groups: parameter pruning and quantization [27–32]; low-rank factorization [33–35]; transferred and compact convolutional filters [36–39]; and knowledge distillation [40–43]. Our proposed NeRV enables us to reformulate the video compression problem into model compression, and utilize standard model compression techniques. Specifically, we use model pruning and quantization to reduce the model size without significantly deteriorating the performance. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/ddffc78fed02ce59fdae910e0235d748c6f63d88aae11e74ca6bc248838f45f7.jpg",
+        "image_caption": [
+            "Figure 2: (a) Pixel-wise implicit representation taking pixel coordinates as input and use a simple MLP to output pixel RGB value (b) NeRV: Image-wise implicit representation taking frame index as input and use a ${ \\bf M L P } + { \\bf \\Delta }$ ConvNets to output the whole image. (c) NeRV block architecture, upscale the feature map by $S$ here. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            89,
+            823,
+            275
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Neural Representations for Videos ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            338,
+            493,
+            356
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We first present the NeRV representation in Section 3.1, including the input embedding, the network architecture, and the loss objective. Then, we present model compression techniques on NeRV in Section 3.2 for video compression. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            411
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 NeRV Architecture ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            428,
+            346,
+            443
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In NeRV, each video $V = \\{ v _ { t } \\} _ { t = 1 } ^ { T } \\in \\mathbb { R } ^ { T \\times H \\times W \\times 3 }$ is represented by a function $f _ { \\theta } : \\mathbb { R } \\to \\mathbb { R } ^ { H \\times W \\times 3 }$ , where the input is a frame index $t$ and the output is the corresponding RGB image $v _ { t } \\in \\mathbb { R } ^ { H \\times W \\times 3 }$ . The encoding function is parameterized with a deep neural network $\\theta$ , $v _ { t } = f _ { \\theta } ( t )$ . Therefore, video encoding is done by fitting a neural network $f _ { \\theta }$ to a given video, such that it can map each input timestamp to the corresponding RGB frame. ",
+        "bbox": [
+            173,
+            450,
+            826,
+            523
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Input Embedding. Although deep neural networks can be used as universal function approximators [1], directly training the network $f _ { \\theta }$ with input timestamp $t$ results in poor results, which is also observed by [4, 44]. By mapping the inputs to a high embedding space, the neural network can better fit data with high-frequency variations. Specifically, in NeRV, we use Positional Encoding [4, 6, 45] as our embedding function ",
+        "bbox": [
+            173,
+            529,
+            825,
+            598
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4ec89fde5abd4095d49be2d287c10582bd96019ed2d2434c3703be31efbe8aa7.jpg",
+        "text": "$$\n\\Gamma ( t ) = \\left( \\sin \\left( b ^ { 0 } \\pi t \\right) , \\cos \\left( b ^ { 0 } \\pi t \\right) , \\ldots , \\sin \\left( b ^ { l - 1 } \\pi t \\right) , \\cos \\left( b ^ { l - 1 } \\pi t \\right) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            606,
+            714,
+            626
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $b$ and $l$ are hyper-parameters of the networks. Given an input timestamp $t$ , normalized between $( 0 , 1 ]$ , the output of embedding function $\\Gamma ( \\cdot )$ is then fed to the following neural network. ",
+        "bbox": [
+            174,
+            631,
+            821,
+            660
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Network Architecture. NeRV architecture is illustrated in Figure 2 (b). NeRV takes the time embedding as input and outputs the corresponding RGB Frame. Leveraging MLPs to directly output all pixel values of the frames can lead to huge parameters, especially when the images resolutions are large. Therefore, we stack multiple NeRV blocks following the MLP layers so that pixels at different locations can share convolutional kernels, leading to an efficient and effective network. Inspired by the super-resolution networks, we design the NeRV block, illustrated in Figure 2 (c), adopting PixelShuffle technique [46] for upscaling method. Convolution and activation layers are also inserted to enhance the expressibilty. The detailed architecture can be found in the supplementary material. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            777
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Loss Objective. For NeRV, we adopt combination of L1 and SSIM loss as our loss function for network optimization, which calculates the loss over all pixel locations of the predicted image and the ground-truth image as following ",
+        "bbox": [
+            174,
+            782,
+            825,
+            825
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b8a057bb122f0449092ad2a97faba813cb7b3882d01d8365f91fbe90c46236c7.jpg",
+        "text": "$$\nL = \\frac { 1 } { T } \\sum _ { t = 1 } ^ { T } \\alpha \\parallel f _ { \\theta } ( t ) - v _ { t } \\parallel _ { 1 } + ( 1 - \\alpha ) ( 1 - \\mathrm { S S I M } ( f _ { \\theta } ( t ) , v _ { t } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            832,
+            699,
+            876
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $T$ is the frame number, $f _ { \\theta } ( t ) \\in \\mathbb { R } ^ { H \\times W \\times 3 }$ the NeRV prediction, $v _ { t } \\in \\mathbb { R } ^ { H \\times W \\times 3 }$ the frame ground truth, $\\alpha$ is hyper-parameter to balance the weight for each loss component. ",
+        "bbox": [
+            173,
+            881,
+            820,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/27d5980cbd0412a5461d542006aa45f36f1dbc6c26b32fa583f9cfd617413225.jpg",
+        "image_caption": [
+            "Figure 3: NeRV-based video compression pipeline. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            282,
+            0,
+            714,
+            121
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Model Compression ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            155,
+            352,
+            170
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we briefly revisit model compression techniques used for video compression with NeRV. Our model compression composes of four standard sequential steps: video overfit, model pruning, weight quantization, and weight encoding as shown in Figure 3. ",
+        "bbox": [
+            173,
+            180,
+            825,
+            223
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Model Pruning. Given a neural network fit on a video, we use global unstructured pruning to reduce the model size first. Based on the magnitude of weight values, we set weights below a threshold as zero, ",
+        "bbox": [
+            173,
+            228,
+            823,
+            270
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3a84a5fce73d77298c9106abcde65aa854fcfc673776861adb9af053121ca749.jpg",
+        "text": "$$\n\\theta _ { i } = { \\left\\{ \\begin{array} { l l } { \\theta _ { i } , } & { { \\mathrm { i f ~ } } \\theta _ { i } \\geq \\theta _ { q } } \\\\ { 0 , } & { { \\mathrm { o t h e r w i s e } } , } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            268,
+            573,
+            304
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\theta _ { q }$ is the $q$ percentile value for all parameters in $\\theta$ . As a normal practice, we fine-tune the model to regain the representation, after the pruning operation. ",
+        "bbox": [
+            173,
+            305,
+            825,
+            334
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Model Quantization. After model pruning, we apply model quantization to all network parameters. Note that different from many recent works [31, 47–49] that utilize quantization during training, NeRV is only quantized post-hoc (after the training process). Given a parameter tensor $\\mu$ ",
+        "bbox": [
+            174,
+            339,
+            825,
+            382
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3609208fcfb7f3ec93feaceecd79fd43579b2422178b44d4dff94b5144929faa.jpg",
+        "text": "$$\n\\mu _ { i } = \\mathrm { r o u n d } \\left( { \\frac { \\mu _ { i } - \\mu _ { \\mathrm { m i n } } } { 2 ^ { \\mathrm { b i t } } } } \\right) * { \\mathrm { s c a l e } } + \\mu _ { \\mathrm { m i n } } , \\quad \\mathrm { s c a l e } = { \\frac { \\mu _ { \\mathrm { m a x } } - \\mu _ { \\mathrm { m i n } } } { 2 ^ { \\mathrm { b i t } } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            383,
+            714,
+            419
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where ‘round’ is rounding value to the closest integer, ‘bit’ the bit length for quantized model, $\\mu _ { \\mathrm { m a x } }$ and $\\mu _ { \\mathrm { { m i n } } }$ the max and min value for the parameter tensor $\\mu$ , ‘scale’ the scaling factor. Through Equation 4, each parameter can be mapped to a ‘bit’ length value. The overhead to store ‘scale’ and $\\mu _ { \\mathrm { { m i n } } }$ can be ignored given the large parameter number of $\\mu$ , e.g., they account for only $0 . 0 0 5 \\%$ in a small $3 \\times 3$ Conv with 64 input channels and 64 output channels ( $3 7 k$ parameters in total). ",
+        "bbox": [
+            174,
+            420,
+            825,
+            491
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Entropy Encoding. Finally, we use entropy encoding to further compress the model size. By taking advantage of character frequency, entropy encoding can represent the data with a more efficient codec. Specifically, we employ Huffman Coding [50] after model quantization. Since Huffman Coding is lossless, it is guaranteed that a decent compression can be achieved without any impact on the reconstruction quality. Empirically, this further reduces the model size by around $10 \\%$ . ",
+        "bbox": [
+            174,
+            496,
+            825,
+            566
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            584,
+            312,
+            602
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Datasets and Implementation Details ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            612,
+            470,
+            627
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We perform experiments on “Big Buck Bunny” sequence from scikit-video to compare our NeRV with pixel-wise implicit representations, which has 132 frames of $7 2 0 \\times 1 0 8 0$ resolution. To compare with state-of-the-arts methods on video compression task, we do experiments on the widely used UVG [7], consisting of 7 videos and 3900 frames with $1 9 2 0 \\times 1 0 8 0$ in total. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            690
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we train the network using Adam optimizer [51] with learning rate of 5e-4. For ablation study on UVG, we use cosine annealing learning rate schedule [52], batchsize of 1, training epochs of 150, and warmup epochs of 30 unless otherwise denoted. When compare with state-of-the-arts, we run the model for 1500 epochs, with batchsize of 6. For experiments on “Big Buck Bunny”, we train NeRV for 1200 epochs unless otherwise denoted. For fine-tune process after pruning, we use 50 epochs for both UVG and “Big Buck Bunny”. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            780
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For NeRV architecture, there are 5 NeRV blocks, with up-scale factor 5, 3, 2, 2, 2 respectively for 1080p videos, and 5, 2, 2, 2, 2 respectively for $7 2 0 \\mathrm { p }$ videos. By changing the hidden dimension of MLP and channel dimension of NeRV blocks, we can build NeRV model with different sizes. For input embedding in Equation 1, we use $b = 1 . 2 5$ and $l = 8 0$ as our default setting. For loss objective in Equation 2, $\\alpha$ is set to 0.7. We evaluate the video quality with two metrics: PSNR and MS-SSIM [53]. Bits-per-pixel (BPP) is adopted to indicate the compression ratio. We implement our model in PyTorch [54] and train it in full precision (FP32). All experiments are run with NVIDIA RTX2080ti. Please refer to the supplementary material for more experimental details, results, and visualizations (e.g., MCL-JCV [55] results) ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/2963d196042d0122f423055a7f837f0dc6f4641fa5e4dfdbf07818bfb97d81b7.jpg",
+        "table_caption": [
+            "Table 2: Compare with pixel-wise implicit representations. Training speed means time/epoch, while encoding time is the total training time. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>Parameters</td><td>Training Speed↑</td><td>Encoding Time↓</td><td>PSNR ↑</td><td>Decoding FPS↑</td></tr><tr><td>SIREN [5]</td><td>3.2M</td><td>1×</td><td>2.5×</td><td>31.39</td><td>1.4</td></tr><tr><td>NeRF[4]</td><td>3.2M</td><td>1×</td><td>2.5×</td><td>33.31</td><td>1.4</td></tr><tr><td>NeRV-S (ours)</td><td>3.2M</td><td>25×</td><td>1×</td><td>34.21</td><td>54.5</td></tr><tr><td>SIREN [5]</td><td>6.4M</td><td>1×</td><td>5×</td><td>31.37</td><td>0.8</td></tr><tr><td>NeRF[4]</td><td>6.4M</td><td>1×</td><td>5×</td><td>35.17</td><td>0.8</td></tr><tr><td>NeRV-M(ours)</td><td>6.3M</td><td>50×</td><td>1×</td><td>38.14</td><td>53.8</td></tr><tr><td>SIREN [5]</td><td>12.7M</td><td>1×</td><td>7×</td><td>25.06</td><td>0.4</td></tr><tr><td>NeRF[4]</td><td>12.7M</td><td>1×</td><td>7×</td><td>37.94</td><td>0.4</td></tr><tr><td>NeRV-L (ours)</td><td>12.5M</td><td>70×</td><td>1×</td><td>41.29</td><td>52.9</td></tr></table>",
+        "bbox": [
+            184,
+            123,
+            589,
+            263
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/40bba571a8f420967f27f7dc7692e98e6c234400aa92e6888bc70d72113c601a.jpg",
+        "table_caption": [
+            "Table 3: PSNR vs. epochs. Since video encoding of NeRV is an overfit process, the reconstructed video quality keeps increasing with more training epochs. NeRV-S/M/L mean models with different sizes. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Epoch</td><td>NeRV-S</td><td>NeRV-M</td><td>NeRV-L</td></tr><tr><td>300</td><td>32.21</td><td>36.05</td><td>39.75</td></tr><tr><td>600</td><td>33.56</td><td>37.47</td><td>40.84</td></tr><tr><td>1.2k</td><td>34.21</td><td>38.14</td><td>41.29</td></tr><tr><td>1.8k</td><td>34.33</td><td>38.32</td><td>41.68</td></tr><tr><td>2.4k</td><td>34.86</td><td>38.7</td><td>41.99</td></tr></table>",
+        "bbox": [
+            611,
+            181,
+            820,
+            257
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/cee23f7cec8dc9f63d7cb2b80217ea312a45e7e7a95cc5fd80819e40128d6083.jpg",
+        "image_caption": [
+            "Figure 4: Model pruning. Sparsity is the ratio of parameters pruned. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            282,
+            385,
+            396
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/8cf5fe22f7203dd2ec3050c1eca3bf188785ee2e2f6a0834dc60e710900bcd83.jpg",
+        "image_caption": [
+            "Figure 5: Model quantization. Bit is the bit length used to represent parameter value. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            398,
+            277,
+            611,
+            388
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/acd55e6df29ba256cdef3081b2ff322d6ac8d3cc816ebebb07e2d60d51cc2791.jpg",
+        "image_caption": [
+            "Figure 6: Compression pipeline to show how much each step contribute to compression ratio. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            624,
+            282,
+            816,
+            385
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Main Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            453,
+            305,
+            467
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare NeRV with pixel-wise implicit representations on ’Big Buck Bunny’ video. We take SIREN [5] and NeRF [4] as the baseline, where SIREN [5] takes the original pixel coordinates as input and uses sine activations, while NeRF [4] adds one positional embedding layer to encode the pixel coordinates and uses ReLU activations. Both SIREN and FFN use a 3-layer perceptron and we change the hidden dimension to build model of different sizes. For fair comparison, we train SIREN and FFN for 120 epochs to make encoding time comparable. And we change the filter width to build NeRV model of comparable sizes, named as NeRV-S, NeRV-M, and NeRV-L. In Table 2, NeRV outperforms them greatly in both encoding speed, decoding quality, and decoding speed. Note that NeRV can improve the training speed by $2 5 \\times$ to $7 0 \\times$ , and speedup the decoding FPS by $3 8 \\times$ to $1 3 2 \\times$ . We also conduct experiments with different training epochs in Table 3, which clearly shows that longer training time can lead to much better overfit results of the video and we notice that the final performances have not saturated as long as it trains for more epochs. ",
+        "bbox": [
+            173,
+            476,
+            825,
+            641
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Video Compression ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            657,
+            348,
+            672
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Compression ablation. We first conduct ablation study on video “Big Buck Bunny”. Figure 4 shows the results of different pruning ratios, where model of $40 \\%$ sparsity still reach comparable performance with the full model. As for model quantization step in Figure 5, a 8-bit model still remains the video quality compared to the original one (32-bit). Figure 6 shows the full compression pipeline with NeRV. The compression performance is quite robust to NeRV models of different sizes, and each step shows consistent contribution to our final results. Please note that we only explore these three common compression techniques here, and we believe that other well-established and cutting edge model compression algorithm can be applied to further improve the final performances of video compression task, which is left for future research. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            808
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Compare with state-of-the-arts methods. We then compare with state-of-the-arts methods on UVG dataset. First, we concatenate 7 videos into one single video along the time dimension and train NeRV on all the frames from different videos, which we found to be more beneficial than training a single model for each video. After training the network, we apply model pruning, quantization, and weight encoding as described in Section3.2. Figure 7 and Figure 8 show the rate-distortion curves. We compare with H.264 [8], HEVC [2], STAT-SSF-SP [56], HLVC [26], Scale-space [25], and Wu et al. [24]. H.264 and HEVC are performed with medium preset mode. As the first image-wise neural representation, NeRV generally achieves comparable performance with traditional video compression techniques and other learning-based video compression approaches. It is worth noting that when BPP is small, NeRV can match the performance of the state-of-the-art method, showing its great potential in high-rate video compression. When BPP becomes large, the performance gap is mostly because of the lack of full training due to GPU resources limitations. As shown in Table 3, the decoding video quality keeps increasing when the training epochs are longer. Figure 9 shows visualizations for decoding frames. At similar memory budget, NeRV shows image details with better quality. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/e24b3466b603bb859067fbf041a59f8ed274e861e03f67e7f244a71525cb3891.jpg",
+        "image_caption": [
+            "Figure 7: PSNR vs. BPP on UVG dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            89,
+            477,
+            261
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/fc114f71acbbb4cf0ecc915b70b0c82942a6d6aac03141e978d0b34760dd29b7.jpg",
+        "image_caption": [
+            "Figure 8: MS-SSIM vs. BPP on UVG dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            87,
+            810,
+            263
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/337e922d6a084dae5ade187f0d3d5a4eb2e33364f06fdd59e866cfaab4e138a2.jpg",
+        "image_caption": [
+            "Figure 9: Video compression visualization. At similar BPP, NeRV reconstructs videos with better details. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            304,
+            815,
+            503
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            546,
+            825,
+            645
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Decoding time We compare with other methods for decoding time under a similar memory budget. Note that HEVC is run on CPU, while all other learning-based methods are run on a single GPU, including our NeRV. We speedup NeRV by running it in half precision (FP16). Due to the simple decoding process (feedforward operation), NeRV shows great advantage, even for carefully-optimized H.264. And lots of speepup can be expected by running quantizaed model on special hardware. All the other video compression methods have two types of frames: key and interval frames. Key frame can be reconstructed by its encoded feature only while the interval frame reconstruction is also based on the reconstructed key frames. Since most video frames are interval frames, their decoding needs to be done in a sequential manner after the reconstruction of the respective key frames. On the contrary, our NeRV can output frames at any random time index independently, thus making parallel decoding much simpler. This can be viewed as a distinct advantage over other methods. ",
+        "bbox": [
+            174,
+            650,
+            825,
+            803
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 Video Denoising ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            827,
+            326,
+            842
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We apply several common noise patterns on the original video and train the model on the perturbed ones. During training, no masks or noise locations are provided to the model, i.e., the target of the model is the noisy frames while the model has no extra signal of whether the input is noisy or not. Surprisingly, our model tries to avoid the influence of the noise and regularizes them implicitly with little harm to the compression task simultaneously, which can serve well for most partially distorted videos in practice. ",
+        "bbox": [
+            176,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/9cf1830a6186de3f6391ac35320318ee637bb12b55adf240921b35d9c025e482.jpg",
+        "table_caption": [
+            "Table 4: Decoding speed with BPP 0.2 for 1080p videos "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>FPS ↑</td></tr><tr><td>Habibian et al. [14] Wu et al. [24] Rippel et al. [57]</td><td>10-3.7 10-3 1</td></tr><tr><td>DVC [3] Liu et al [58] H.264 [8]</td><td>1.8 3 9.2</td></tr><tr><td>NeRV (FP32) NeRV (FP16)</td><td>5.6 12.5</td></tr></table>",
+        "bbox": [
+            189,
+            127,
+            370,
+            262
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/2307dcb8994adedc8300b21e9126079221e42c6dab6ffbbd3ded1223d07daa84.jpg",
+        "table_caption": [
+            "Table 5: PSNR results for video denoising. “baseline” refers to the noisy frames before any denoising "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>noise</td><td>white 个</td><td>black ↑</td><td>salt&amp; 个 pepper</td><td>random 个</td><td>Average ↑</td></tr><tr><td>Baseline</td><td>27.85</td><td>28.29</td><td>27.95</td><td>30.95</td><td>28.74</td></tr><tr><td>Gaussian</td><td>30.27</td><td>30.14</td><td>30.23</td><td>30.99</td><td>30.41</td></tr><tr><td>Uniform</td><td>29.11</td><td>29.06</td><td>29.10</td><td>29.63</td><td>29.22</td></tr><tr><td>Median</td><td>33.89</td><td>33.84</td><td>33.87</td><td>33.89</td><td>33.87</td></tr><tr><td>Minimum</td><td>20.55</td><td>16.60</td><td>18.09</td><td>18.20</td><td>18.36</td></tr><tr><td>Maximum</td><td>16.16</td><td>20.26</td><td>17.69</td><td>17.83</td><td>17.99</td></tr><tr><td>NeRV</td><td>33.31</td><td>34.20</td><td>34.17</td><td>34.80</td><td>34.12</td></tr></table>",
+        "bbox": [
+            428,
+            123,
+            846,
+            265
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/b8033d8855f0573bebf69e0712b90a54f18cf5aead605e34902e9a7eef2caf56.jpg",
+        "image_caption": [
+            "Figure 10: Denoising visualization. (c) and (e) are denoising output for DIP [59]. Data generalization of NeRV leads to robust and better denoising performance since all frames share the same representation, while DIP model overfits one model to one image only. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            292,
+            810,
+            512
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            593,
+            823,
+            622
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results are compared with some standard denoising methods including Gaussian, uniform, and median filtering. These can be viewed as denoising upper bound for any additional compression process. As listed in Table 5, the PSNR of NeRV output is usually much higher than the noisy frames although it’s trained on the noisy target in a fully supervised manner, and has reached an acceptable level for general denoising purpose. Specifically, median filtering has the best performance among the traditional denoising techniques, while NeRV outperforms it in most cases or is at least comparable without any extra denoising design in both architecture design and training strategy. ",
+        "bbox": [
+            174,
+            627,
+            825,
+            726
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also compare NeRV with another neural-network-based denoising method, Deep Image Prior (DIP) [59]. Although its main target is image denoising, NeRV outperforms it in both qualitative and quantitative metrics, demonstrated in Figure 10. The main difference between them is that denoising of DIP only comes form architecture prior, while the denoising ability of NeRV comes from both architecture prior and data prior. DIP emphasizes that its image prior is only captured by the network structure of Convolution operations because it only feeds on a single image. But the training data of NeRV contain many video frames, sharing lots of visual contents and consistences. As a result, image prior is captured by both the network structure and the training data statistics for NeRV. DIP relies significantly on a good early stopping strategy to prevent it from overfitting to the noise. Without the noise prior, it has to be used with fixed iterations settings, which is not easy to generalize to any random kind of noises as mentioned above. By contrast, NeRV is able to handle this naturally by keeping training because the full set of consecutive video frames provides a strong regularization on image content over noise. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/622df440ccd2de292e2f8d7c7b62fb15adfc251828f422b01b4ecf6ffd404ad8.jpg",
+        "table_caption": [
+            "Table 6: Input embedding ablation. PE means positional encoding "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>PSNR</td><td>MS-SSIM</td></tr><tr><td>None</td><td>24.93</td><td>0.769</td></tr><tr><td>PE</td><td>37.26</td><td>0.970</td></tr></table>",
+        "bbox": [
+            207,
+            123,
+            356,
+            167
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/d1d19c7ed365dddddede4f37e32c19c86e661a2be2a43bb1ec5808aebeba6a52.jpg",
+        "table_caption": [
+            "Table 7: Upscale layer ablation "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>PSNR</td><td>MS-SSIM</td></tr><tr><td>Bilinear Pooling</td><td>29.56</td><td>0.873</td></tr><tr><td>Transpose Conv</td><td>36.63</td><td>0.967</td></tr><tr><td>PixelShuffle</td><td>37.26</td><td>0.970</td></tr></table>",
+        "bbox": [
+            398,
+            111,
+            606,
+            167
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/565d613a58407c0fb3b51cd93ca8d77d0cd4ba4d74da944c6245e5cabd01d0f0.jpg",
+        "table_caption": [
+            "Table 8: Norm layer ablation "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>PSNR</td><td>MS-SSIM</td></tr><tr><td>BatchNorm</td><td>36.71</td><td>0.971</td></tr><tr><td>InstanceNorm</td><td>35.5</td><td>0.963</td></tr><tr><td>None</td><td>37.26</td><td>0.970</td></tr></table>",
+        "bbox": [
+            620,
+            111,
+            816,
+            167
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/c910f490724ad52936cf9f86ba1937c3809411de934e48110248cf8a9dbebf87.jpg",
+        "table_caption": [
+            "Table 9: Activation function ablation "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>PSNR</td><td>MS-SSIM</td></tr><tr><td>ReLU</td><td>35.89</td><td>0.963</td></tr><tr><td>Leaky ReLU</td><td>36.76</td><td>0.968</td></tr><tr><td>Swish</td><td>37.08</td><td>0.969</td></tr><tr><td>GELU</td><td>37.26</td><td>0.970</td></tr></table>",
+        "bbox": [
+            222,
+            190,
+            439,
+            268
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/d10c16544b950c858ff0b273547a0944cc1a7988a385d61d3adb7b763899b52b.jpg",
+        "table_caption": [
+            "Table 10: Loss objective ablation "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>L2</td><td>L1</td><td>SSIM</td><td>PSNR</td><td>MS-SSIM</td></tr><tr><td>√</td><td></td><td></td><td>35.64</td><td>0.956</td></tr><tr><td></td><td>√</td><td></td><td>35.77</td><td>0.959</td></tr><tr><td></td><td></td><td>√</td><td>35.69</td><td>0.971</td></tr><tr><td>√</td><td>√</td><td></td><td>35.95</td><td>0.960</td></tr><tr><td>√</td><td></td><td>√</td><td>36.46</td><td>0.970</td></tr><tr><td></td><td>√</td><td>√</td><td>37.26</td><td>0.970</td></tr></table>",
+        "bbox": [
+            555,
+            190,
+            743,
+            267
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 Ablation Studies ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            295,
+            328,
+            310
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, we provide ablation studies on the UVG dataset. PSNR and MS-SSIM are adopted for evaluation of the reconstructed videos. ",
+        "bbox": [
+            174,
+            325,
+            825,
+            353
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Input embedding. In Table 6, PE means positional encoding as in Equation 1, which greatly improves the baseline, None means taking the frame index as input directly. Similar findings can be found in [4], without any input embedding, the model can not learn high-frequency information, resulting in much lower performance. ",
+        "bbox": [
+            174,
+            353,
+            825,
+            409
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Upscale layer. In Table 7, we show results of three different upscale methods. i.e., Bilinear Pooling, Transpose Convolution, and PixelShuffle [46]. With similar model sizes, PixelShuffle shows best results. Please note that although Transpose convolution [60] reach comparable results, it greatly slowdown the training speed compared to the PixelShuffle. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            463
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Normalization layer. In Table 8, we apply common normalization layers in NeRV block. The default setup, without normalization layer, reaches the best performance and runs slightly faster. We hypothesize that the normalization layer reduces the over-fitting capability of the neural network, which is contradictory to our training objective. ",
+        "bbox": [
+            174,
+            464,
+            825,
+            518
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Activation layer. Table 9 shows results for common activation layers. The GELU [61] activation function achieve the highest performances, which is adopted as our default design. ",
+        "bbox": [
+            171,
+            520,
+            823,
+            546
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Loss objective. We show loss objective ablation in Table 10. We shows performance results of different combinations of L2, L1, and SSIM loss. Although adopting SSIM alone can produce the highest MS-SSIM score, but the combination of L1 loss and SSIM loss can achieve the best trade-off between the PSNR performance and MS-SSIM score. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            602
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            633,
+            294,
+            650
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Conclusion. In this work, we present a novel neural representation for videos, NeRV, which encodes videos into neural networks. Our key sight is that by directly training a neural network with video frame index and output corresponding RGB image, we can use the weights of the model to represent the videos, which is totally different from conventional representations that treat videos as consecutive frame sequences. With such a representation, we show that by simply applying general model compression techniques, NeRV can match the performances of traditional video compression approaches for the video compression task, without the need to design a long and complex pipeline. We also show that NeRV can outperform standard denoising methods. We hope that this paper can inspire further research works to design novel class of methods for video representations. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            787
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Limitations and Future Work. There are some limitations with the proposed NeRV. First, to achieve the comparable PSNR and MS-SSIM performances, the training time of our proposed approach is longer than the encoding time of traditional video compression methods. Second, the architecture design of NeRV is still not optimal yet, we believe more exploration on the neural architecture design can achieve higher performances. Finally, more advanced and cutting the edge model compression methods can be applied to NeRV and obtain higher compression ratios. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            877
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgement. This project was partially funded by the DARPA SAIL-ON (W911NF2020009) program, an independent grant from Facebook AI, and Amazon Research Award to AS. ",
+        "bbox": [
+            173,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Kurt Hornik, Maxwell Stinchcombe, and Halbert White. Multilayer feedforward networks are universal approximators. Neural networks, 2(5):359–366, 1989. 1, 4   \n[2] Gary J Sullivan, Jens-Rainer Ohm, Woo-Jin Han, and Thomas Wiegand. Overview of the high efficiency video coding (hevc) standard. IEEE Transactions on circuits and systems for video technology, 22(12):1649– 1668, 2012. 2, 3, 6   \n[3] Guo Lu, Wanli Ouyang, Dong Xu, Xiaoyun Zhang, Chunlei Cai, and Zhiyong Gao. Dvc: An end-to-end deep video compression framework. In CVPR, 2019. 2, 8   \n[4] Ben Mildenhall, Pratul P Srinivasan, Matthew Tancik, Jonathan T Barron, Ravi Ramamoorthi, and Ren Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. In European Conference on Computer Vision, pages 405–421. Springer, 2020. 2, 3, 4, 6, 9   \n[5] Vincent Sitzmann, Julien Martel, Alexander Bergman, David Lindell, and Gordon Wetzstein. Implicit neural representations with periodic activation functions. Advances in Neural Information Processing Systems, 33, 2020. 1, 6   \n[6] Matthew Tancik, Pratul P Srinivasan, Ben Mildenhall, Sara Fridovich-Keil, Nithin Raghavan, Utkarsh Singhal, Ravi Ramamoorthi, Jonathan T Barron, and Ren $\\mathrm { N g }$ . Fourier features let networks learn high frequency functions in low dimensional domains. NeurIPS, 2020. 1, 4   \n[7] Alexandre Mercat, Marko Viitanen, and Jarno Vanne. Uvg dataset: 50/120fps 4k sequences for video codec analysis and development. In Proceedings of the 11th ACM Multimedia Systems Conference, pages 297–302, 2020. 2, 5   \n[8] Thomas Wiegand, Gary J Sullivan, Gisle Bjontegaard, and Ajay Luthra. Overview of the h. 264/avc video coding standard. IEEE Transactions on circuits and systems for video technology, 13(7):560–576, 2003. 3, 6, 8   \n[9] Kyle Genova, Forrester Cole, Daniel Vlasic, Aaron Sarna, William T Freeman, and Thomas Funkhouser. Learning shape templates with structured implicit functions. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 7154–7164, 2019. 3   \n[10] Kyle Genova, Forrester Cole, Avneesh Sud, Aaron Sarna, and Thomas A Funkhouser. Deep structured implicit functions. 2019. 3   \n[11] Vincent Sitzmann, Michael Zollhöfer, and Gordon Wetzstein. Scene representation networks: Continuous 3d-structure-aware neural scene representations. arXiv preprint arXiv:1906.01618, 2019. 3   \n[12] Chiyu Jiang, Avneesh Sud, Ameesh Makadia, Jingwei Huang, Matthias Nießner, Thomas Funkhouser, et al. Local implicit grid representations for 3d scenes. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 6001–6010, 2020.   \n[13] Songyou Peng, Michael Niemeyer, Lars Mescheder, Marc Pollefeys, and Andreas Geiger. Convolutional occupancy networks. arXiv preprint arXiv:2003.04618, 2, 2020.   \n[14] Rohan Chabra, Jan E Lenssen, Eddy Ilg, Tanner Schmidt, Julian Straub, Steven Lovegrove, and Richard Newcombe. Deep local shapes: Learning local sdf priors for detailed 3d reconstruction. In European Conference on Computer Vision, pages 608–625. Springer, 2020. 3, 8   \n[15] Michael Niemeyer, Lars Mescheder, Michael Oechsle, and Andreas Geiger. Differentiable volumetric rendering: Learning implicit 3d representations without 3d supervision. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 3504–3515, 2020. 3   \n[16] Michael Oechsle, Lars Mescheder, Michael Niemeyer, Thilo Strauss, and Andreas Geiger. Texture fields: Learning texture representations in function space. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 4531–4540, 2019. 3   \n[17] Emilien Dupont, Adam Golinski, Milad Alizadeh, Yee Whye Teh, and Arnaud Doucet. Coin: Compression ´ with implicit neural representations. arXiv preprint arXiv:2103.03123, 2021. 3   \n[18] Gregory K Wallace. The jpeg still picture compression standard. IEEE transactions on consumer electronics, 38(1):xviii–xxxiv, 1992. 3   \n[19] Athanassios Skodras, Charilaos Christopoulos, and Touradj Ebrahimi. The jpeg 2000 still image compression standard. IEEE Signal processing magazine, 18(5):36–58, 2001. 3   \n[20] Didier Le Gall. Mpeg: A video compression standard for multimedia applications. Communications of the ACM, 34(4):46–58, 1991. 3   \n[21] Nasir Ahmed, T_ Natarajan, and Kamisetty R Rao. Discrete cosine transform. IEEE transactions on Computers, 100(1):90–93, 1974. 3   \n[22] Marc Antonini, Michel Barlaud, Pierre Mathieu, and Ingrid Daubechies. Image coding using wavelet transform. IEEE Transactions on image processing, 1(2):205–220, 1992. 3   \n[23] Zhengxue Cheng, Heming Sun, Masaru Takeuchi, and Jiro Katto. Learning image and video compression through spatial-temporal energy compaction. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 10071–10080, 2019. 3   \n[24] Chao-Yuan Wu, Nayan Singhal, and Philipp Krahenbuhl. Video compression through image interpolation. In Proceedings of the European Conference on Computer Vision (ECCV), pages 416–431, 2018. 3, 6, 8   \n[25] Eirikur Agustsson, David Minnen, Nick Johnston, Johannes Balle, Sung Jin Hwang, and George Toderici. Scale-space flow for end-to-end optimized video compression. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8503–8512, 2020. 3, 6   \n[26] Ren Yang, Fabian Mentzer, Luc Van Gool, and Radu Timofte. Learning for video compression with hierarchical quality and recurrent enhancement. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 6628–6637, 2020. 3, 6   \n[27] Vincent Vanhoucke, Andrew Senior, and Mark Z Mao. Improving the speed of neural networks on cpus. 2011. 3   \n[28] Suyog Gupta, Ankur Agrawal, Kailash Gopalakrishnan, and Pritish Narayanan. Deep learning with limited numerical precision. In International conference on machine learning, pages 1737–1746. PMLR, 2015.   \n[29] 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.   \n[30] Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. arXiv preprint arXiv:1608.03665, 2016.   \n[31] 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 integerarithmetic-only inference. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 2704–2713, 2018. 5   \n[32] Raghuraman Krishnamoorthi. Quantizing deep convolutional networks for efficient inference: A whitepaper. arXiv preprint arXiv:1806.08342, 2018. 3   \n[33] Roberto Rigamonti, Amos Sironi, Vincent Lepetit, and Pascal Fua. Learning separable filters. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2754–2761, 2013. 3   \n[34] Emily Denton, Wojciech Zaremba, Joan Bruna, Yann LeCun, and Rob Fergus. Exploiting linear structure within convolutional networks for efficient evaluation. arXiv preprint arXiv:1404.0736, 2014.   \n[35] Max Jaderberg, Andrea Vedaldi, and Andrew Zisserman. Speeding up convolutional neural networks with low rank expansions. arXiv preprint arXiv:1405.3866, 2014. 3   \n[36] Taco Cohen and Max Welling. Group equivariant convolutional networks. In International conference on machine learning, pages 2990–2999. PMLR, 2016. 3   \n[37] Shuangfei Zhai, Yu Cheng, Weining Lu, and Zhongfei Zhang. Doubly convolutional neural networks. arXiv preprint arXiv:1610.09716, 2016.   \n[38] Wenling Shang, Kihyuk Sohn, Diogo Almeida, and Honglak Lee. Understanding and improving convolutional neural networks via concatenated rectified linear units. In international conference on machine learning, pages 2217–2225. PMLR, 2016.   \n[39] Sander Dieleman, Jeffrey De Fauw, and Koray Kavukcuoglu. Exploiting cyclic symmetry in convolutional neural networks. In International conference on machine learning, pages 1889–1898. PMLR, 2016. 3   \n[40] Lei Jimmy Ba and Rich Caruana. Do deep nets really need to be deep? arXiv preprint arXiv:1312.6184, 2013. 3   \n[41] Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.   \n[42] Guobin Chen, Wongun Choi, Xiang Yu, Tony Han, and Manmohan Chandraker. Learning efficient object detection models with knowledge distillation. In Proceedings of the 31st International Conference on Neural Information Processing Systems, pages 742–751, 2017.   \n[43] Antonio Polino, Razvan Pascanu, and Dan Alistarh. Model compression via distillation and quantization. arXiv preprint arXiv:1802.05668, 2018. 3   \n[44] Nasim Rahaman, Aristide Baratin, Devansh Arpit, Felix Draxler, Min Lin, Fred Hamprecht, Yoshua Bengio, and Aaron Courville. On the spectral bias of neural networks. In International Conference on Machine Learning, pages 5301–5310. PMLR, 2019. 4   \n[45] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. arXiv preprint arXiv:1706.03762, 2017. 4   \n[46] Wenzhe Shi, Jose Caballero, Ferenc Huszár, Johannes Totz, Andrew P Aitken, Rob Bishop, Daniel Rueckert, and Zehan Wang. Real-time single image and video super-resolution using an efficient sub-pixel convolutional neural network. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1874–1883, 2016. 4, 9   \n[47] Ron Banner, Itay Hubara, Elad Hoffer, and Daniel Soudry. Scalable methods for 8-bit training of neural networks. arXiv preprint arXiv:1805.11046, 2018. 5   \n[48] Fartash Faghri, Iman Tabrizian, Ilia Markov, Dan Alistarh, Daniel Roy, and Ali Ramezani-Kebrya. Adaptive gradient quantization for data-parallel sgd. arXiv preprint arXiv:2010.12460, 2020.   \n[49] Naigang Wang, Jungwook Choi, Daniel Brand, Chia-Yu Chen, and Kailash Gopalakrishnan. Training deep neural networks with 8-bit floating point numbers. arXiv preprint arXiv:1812.08011, 2018. 5   \n[50] David A Huffman. A method for the construction of minimum-redundancy codes. Proceedings of the IRE, 40(9):1098–1101, 1952. 5   \n[51] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. 5   \n[52] Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint arXiv:1608.03983, 2016. 5   \n[53] Zhou Wang, Eero P Simoncelli, and Alan C Bovik. Multiscale structural similarity for image quality assessment. In The Thrity-Seventh Asilomar Conference on Signals, Systems Computers, 2003, volume 2, pages 1398–1402. Ieee, 2003. 5   \n[54] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, high-performance deep learning library. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32, pages 8024–8035. Curran Associates, Inc., 2019. 5   \n[55] Haiqiang Wang, Weihao Gan, Sudeng Hu, Joe Yuchieh Lin, Lina Jin, Longguang Song, Ping Wang, Ioannis Katsavounidis, Anne Aaron, and C-C Jay Kuo. Mcl-jcv: a jnd-based h. 264/avc video quality assessment dataset. In 2016 IEEE International Conference on Image Processing (ICIP), pages 1509–1513. IEEE, 2016. 5   \n[56] Ruihan Yang, Yibo Yang, Joseph Marino, and Stephan Mandt. Hierarchical autoregressive modeling for neural video compression. arXiv preprint arXiv:2010.10258, 2020. 6   \n[57] Oren Rippel, Sanjay Nair, Carissa Lew, Steve Branson, Alexander G Anderson, and Lubomir Bourdev. Learned video compression. In ICCV, 2019. 8   \n[58] Jerry Liu, Shenlong Wang, Wei-Chiu Ma, Meet Shah, Rui Hu, Pranaab Dhawan, and Raquel Urtasun. Conditional entropy coding for efficient video compression. In ECCV, 2020. 8   \n[59] Dmitry Ulyanov, Andrea Vedaldi, and Victor Lempitsky. Deep image prior. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 9446–9454, 2018. 8   \n[60] Vincent Dumoulin and Francesco Visin. A guide to convolution arithmetic for deep learning. arXiv preprint arXiv:1603.07285, 2016. 9   \n[61] Dan Hendrycks and Kevin Gimpel. Gaussian error linear units (gelus). arXiv preprint arXiv:1606.08415, 2016. 9 ",
+        "bbox": [
+            173,
+            61,
+            828,
+            920
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            61,
+            828,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            25,
+            828,
+            917
+        ],
+        "page_idx": 11
+    }
+]

parse/train/HJgS7p4FPH/HJgS7p4FPH.md

@@ -0,0 +1,273 @@
+# ACCELERATING REINFORCEMENT LEARNING THROUGH GPU ATARI EMULATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We introduce CuLE (CUDA Learning Environment), a CUDA port of the Atari Learning Environment (ALE) which is used for the development of deep reinforcement algorithms. CuLE overcomes many limitations of existing CPU-based emulators and scales naturally to multiple GPUs. It leverages GPU parallelization to run thousands of games simultaneously and it renders frames directly on the GPU, to avoid the bottleneck arising from the limited CPU-GPU communication bandwidth. CuLE generates up to 155M frames per hour on a single GPU, a finding previously achieved only through a cluster of CPUs. Beyond highlighting the differences between CPU and GPU emulators in the context of reinforcement learning, we show how to leverage the high throughput of CuLE by effective batching of the training data, and show accelerated convergence for $\mathrm { { A 2 C + V } } .$ -trace. CuLE is available at [URL revealed upon acceptance].
+
+# 1 INTRODUCTION
+
+Initially triggered by the success of DQN Mnih et al. (2015), research in Deep Reinforcement Learning (DRL) has grown in popularity in the last years Lillicrap et al. (2015); Mnih et al. (2016; 2015), leading to intelligent agents that solve non-trivial tasks in complex environments. But DRL also soon proved to be a challenging computational problem, especially if one wants to achieve peak performance on modern architectures.
+
+Fig. 1 is a schematic representation of a modern DRL algorithm implementation: CPU environments execute a set of actions $\left\{ a _ { t - 1 } \right\}$ at time $t - 1$ , and produce observable states $\left\{ { { s } _ { t } } \right\}$ and rewards $\{ r _ { t } \}$ . These data are migrated to a Deep Neural Network (DNN) on the GPU to eventu
+
+![](images/780bd4014390345fd53e4c0a0b32fde9e675cbc1b659a08ee61a4765138ee8dc.jpg)  
+Figure 1: In a typical DRL system, environments run on CPUs and DNNs on GPUs. The limited CPU-GPU communication bandwidth and small set of environments prevent full GPU usage.
+
+ally select the next action set, $\left\{ { { a } _ { t } } \right\}$ , which is copied back to the CPU. This sequence of operations defines the inference path, whose main aim is to generate training data. A training buffer on the GPU stores the states generated on the inference path; this is periodically used to update the DNN’s weights $\theta$ , according to the training rule of the DRL algorithm (training path). A computationally efficient DRL system should balance the data generation and training processes, while minimizing the communication overhead along the inference path and consuming, along the training path, as many data per second as possible Babaeizadeh et al. (2016; 2017). The solution to this problem is however non-trivial and many DRL implementations do not leverage the full computational potential of modern systems Stooke & Abbeel (2018b).
+
+We focus our attention on the inference path and move from the traditional CPU implementation of the Atari Learning Environment (ALE), a set of Atari 2600 games that emerged as an excellent DRL benchmark Bellemare et al. (2013); Machado et al. (2017). We show that significant performance bottlenecks primarily stem from CPU environment emulation: the CPU cannot run a large set of environments simultaneously, the CPU-GPU communication bandwidth is limited, and the GPU is consequently underutilized. To both investigate and mitigate these limitations we introduce CuLE (CUDA Learning Environment), a DRL library containing a CUDA enabled Atari 2600 emulator, that renders frames directly in the GPU memory, avoids off-chip communication and achieves high GPU utilization by processing thousands of environments in parallel—something so far achievable only through large and costly distributed systems. Compared to the traditional CPU-based approach, GPU emulation improves the utilization of the computational resources: CuLE on a single GPU generates more Frames Per Second1 (FPS) on the inference path (between 39K and 125K, depending on the game, see Table 1) compared to its CPU counterpart (between 12.5K and 19.8K). Beyond offering CuLE ([URL revealed upon acceptance]) as a tool for research in the DRL field, our contribution can be summarized as follow:
+
+(1) We identify common computational bottlenecks in several DRL implementations that prevent effective utilization of high throughput compute units and effective scaling to distributed systems.
+
+(2) We introduce an effective batching strategy for large environment sets, that allows leveraging the high throughput generated by CuLE to quickly reach convergence with $\mathrm { { A 2 C + V } } .$ -trace Espeholt et al. (2018), and show effective scaling on multiple GPUs. This leads to the consumption of 26-68K FPS along the training path on a single GPU, and up to 187K FPS using four GPUs, comparable (Table 1) to those achieved by large clusters Stooke & Abbeel (2018a); Espeholt et al. (2018).
+
+(3) We analyze advantages and limitations of GPU emulation with CuLE in DRL, including the effect of thread divergence and of the lower (compared to CPU) number of instructions per second per thread, and hope that our insights may be of value for the development of efficient DRL systems.
+
+Table 1: Average training times, raw frames to reach convergence, FPS, and computational resources of existing accelerated DRL schemes, compared to CuLE. Data from Horgan et al. (2018); FPS are taken from the corresponding papers, if available, and measured on the entire Atari suite for CuLE.   
+
+<table><tr><td>Algorithm</td><td>Time</td><td>Frames</td><td>FPS</td><td>Resources</td><td>Notes</td></tr><tr><td>Ape-X DQN Horgan et al. (2018)</td><td>5days</td><td>22.800M</td><td>50K</td><td>376 cores,1 GPU</td><td></td></tr><tr><td>Rainbow Hessel et al. (2017)</td><td>10 days</td><td>200M</td><td></td><td>1GPU</td><td></td></tr><tr><td>Distributional (C51) Bellemare et al. (2017)</td><td>10 days</td><td>200M</td><td></td><td>1GPU</td><td></td></tr><tr><td>A3C Mnih et al. (2016)</td><td>4 days</td><td></td><td>2K</td><td>16 cores</td><td></td></tr><tr><td>GA3C Babaeizadeh et al. (2016; 2017)</td><td>1 day</td><td></td><td>8K</td><td>16 cores,1 GPU</td><td></td></tr><tr><td>Prioritized Dueling Wang et al.(2015)</td><td>9.5 days</td><td>200M</td><td></td><td>1 GPU</td><td></td></tr><tr><td>DQN Mnih et al. (2015)</td><td>9.5 days</td><td>200M</td><td></td><td>1GPU</td><td></td></tr><tr><td>Gorila DQN Nair et al. (2015)</td><td>4 days</td><td></td><td></td><td>&gt;100 cores</td><td></td></tr><tr><td>Unreal Jaderberg et al. (2016)</td><td></td><td>250M</td><td></td><td>16 cores</td><td></td></tr><tr><td>Stooke (A2C/DQN) Stooke&amp; Abbeel (2018b)</td><td>hours</td><td>200M</td><td>35K</td><td>40 CPUs,8 GPUs (DGX-1)</td><td></td></tr><tr><td>IMPALA (A2C+V-Trace) Espeholt et al.(2018)</td><td>mins/hours</td><td>200M</td><td>250K</td><td>100-200 cores,1 GPU</td><td></td></tr><tr><td>CuLE(emulation only)</td><td>N/A</td><td>N/A</td><td>41K-155K</td><td>SystemI(1 GPU)</td><td>4096 ALEs</td></tr><tr><td>CuLE(inference only,A2C,single batch)</td><td>N/A</td><td>N/A</td><td>39K-125K</td><td>System I(1GPU)</td><td>4096 ALEs</td></tr><tr><td>CuLE(training,A2C + V-trace,multiple batches)</td><td>1 hour</td><td>200M</td><td>26K-68K</td><td>System I(1 GPU)</td><td>1200 ALEs</td></tr><tr><td>CuLE(training,A2C+ V-trace,multiple batches)*</td><td>mins</td><td>200M</td><td>142-187K</td><td>System III (4 GPUs)</td><td>1200×4 ALEs</td></tr></table>
+
+\*FPS measured on Asterix, Assault, MsPacman, and Pong.
+
+# 2 RELATED WORK
+
+The wall clock convergence time of a DRL algorithm is determined by two main factors: its sample efficiency, and the computational efficiency of its implementation. Here we analyze the sample and computational efficiency of different DRL algorithms, in connection with their implementation.
+
+Table 2: Systems used for experiments.   
+
+<table><tr><td>System</td><td>Intel CPU</td><td>NVIDIA GPU</td></tr><tr><td>I</td><td>12-core Core i7-5930K @3.50GHz</td><td>Titan V</td></tr><tr><td>II</td><td>6-core Core i7-8086K @5GHz</td><td>Tesla V100</td></tr><tr><td>ⅢI</td><td>20-core Core E5-2698 v4 @2.20GHz × 2</td><td>TeslaV100×8,NVLink</td></tr></table>
+
+We first divide DRL algorithms into policy gradient and Q-value methods, as in Stooke & Abbeel (2018b). Q-learning optimizes the error on the estimated action values as a proxy for policy optimization, whereas policy gradient methods directly learn the relation between a state, $s _ { t }$ , and the optimal action, $a _ { t }$ ; since at each update they follow, by definition, the gradient with respect to the policy itself, they improve the policy more efficiently. Policy methods are also considered more general, e.g. they can handle continuous actions easily. Also the on- or off-policy nature of an algorithm profoundly affects both its sample and computational efficiency. Off-policy methods allow re-using experiences multiple times, which directly improves the sample efficiency; additionally, old data stored in the GPU memory (replay buffer in Fig. 1) can be used to continuously update the DNN on the GPU, leading to high GPU utilization without saturating the inference path. The replay buffer has a positive effect on the stability of learning as well Mnih et al. (2015). On-policy algorithms saturate the inference path more easily, as frames have to be generated on-the-fly using the current policy and moved from the CPU emulators to the GPU for processing with the DNN. On-policy updates are generally effective but they are also more prone to fall into local minima because of noise, especially if the number of environment is small — this is the reason why on-policy algorithms largely benefit (in term of stability) from a significant increase of the number of environments.
+
+Among the policy gradient methods, A3C Mnih et al. (2016) is an asynchronous, on-policy, actorcritic algorithm where 16 CPU agents use copies of the same DNN to interact with CPU environments; $N$ -step bootstrapping is used to reduce the variance of the critic, $V \left( s _ { t } ; \theta \right)$ : the agents send updates to the DNN after every $N = 5$ actions, and the new set of global $\theta$ weights are broadcast to all agents after each update. A3C can solve an Atari game in approximately 4 days; its hybrid CPUGPU implementation (GA3C Babaeizadeh et al. (2016; 2017)) stores a single DNN on the GPU, collects CPU data in a system of queues to send them to the GPU in large batches, and achieves convergence in 1 day. Recent (and faster) policy gradient implementations, like PAAC Clemente et al. (2017), PPO Schulman et al. (2017), or A2C OpenAI (2017), store training data directly in a GPU training buffer, as depicted in Fig. 1, which is well representative of the flow of computation of modern DRL algorithms.
+
+Policy gradient algorithms are often on-policy: their efficient update strategy is counterbalanced by the bottlenecks in the inference path and competition for the use of the GPU along the inference and training path at the same time. Acceleration by scaling to a distributed system is possible but inefficient in this case: in IMPALA Espeholt et al. (2018) a cluster with hundreds of CPU cores is needed to accelerate A2C, while training is desynchronized to hide latency. As a consequence, the algorithm becomes off-policy, and V-trace was introduced to deal with off-policy data (see details in the Appendix). Acceleration on a DGX-1 has also been demonstrated for A2C and PPO, using large batch sizes to increase the GPU occupancy, and asynchronous distributed models that hide latency, but require periodic updates to remain synchronized Stooke & Abbeel (2018b) and overall achieves sublinear scaling with the number of GPUs. In practice, the efficiency generally scales sub-linearly on distributed systems, and though Atari games can be solved in a few hours or even minutes, the cost of such systems makes them prohibitive for many researchers.
+
+Q-value methods, like DQN Mnih et al. (2015) and its more recent, improved versions (DoubleDQN van Hasselt et al. (2015), Dueling Networks Wang et al. (2015), Prioritized Replay Schaul et al. (2015), n-step learning Peng & Williams (1996), NoisyNets Fortunato et al. (2017), Rainbow Hessel et al. (2017)) are generally off-policy and can be accelerated more easily, as the inference and training path can be decoupled, with the GPU continuously fed with training data from the replay buffer in Fig.1. Mapping the two paths on different devices is natural and effective, and indeed DQN methods have been significantly accelerated on distributed systems (see Nair et al. (2015) and Jaderberg et al. (2016) in Table 1). The replay buffer increases the sample efficiency, but the overall convergence time has to pay the cost of using a Q-value method. Furthermore, implementation on large scale systems still incurs a communication overhead and thus generally achieves sub-linear scaling on large distributed systems.
+
+The best compromise between sample efficiency, computational efficiency and effectiveness of the DNN update seems to be achieved by using an on-policy while correcting for stale data, gradient policy methods like $\mathrm { { A 2 C + V } } .$ -trace, which is therefore the algorithm analyzed in detail here, but still suffers from computational bottlenecks in its CPU distributed implementation Espeholt et al. (2018).
+
+Other Data Generation Engines Frameworks to generate training experiences already exist, like the well-known OpenAI Gym, built on top of the $\mathrm { C } { + } { + }$ Stella emulator Brockman et al. (2016) for Atari games. Other frameworks that target specific problems, such as navigation Mirowski et al. (2016), aim at creating large benchmark for DRL Tassa et al. (2018), or accelerate simulation on the CPU with optimized $\mathrm { C } { + } { + }$ multi-threaded implementations, while also providing large, GPU-friendly batches for inference and training Tian et al. (2017). To the best of our knowledge, however, none of these attempts directly address the problem of optimizing the inference path, i.e., trying to increase the number of environments while avoiding the CPU and bandwidth bottlenecks, by providing a direct implementation of the environments on the GPU.
+
+# 3 CUDA LEARNING ENVIRONMENT (CULE)
+
+Despite the number and variety of games developed for the Atari 2600, it is relatively simple to emulate the functioning of its hardware much faster than real-time. The Atari console has a 1.19Mhz CPU (to execute the game instructions) and a 128 bytes RAM (containing the game state); the code of each game is stored in a cartridge ROM (typically 2–4kB). The instruction set of each game contains both game and rendering instructions; the first ones are executed by the CPU, while the second ones are sent to the Television Interface Adaptor (TIA), a secondary processor embedded in the Atari hardware that executes the rendering instructions to update a limited set of registers and render the $1 6 0 \times 2 1 0$ game screen using a 128- colour palette.
+
+In CuLE, we emulate the functioning of many Atari consoles in parallel using the CUDA programming model, where a sequential host program executes parallel programs, known as kernels, on a GPU. In a trivial mapping of the Atari emulator to CUDA, a single thread emulates both the Atari CPU and TIA to execute the ROM
+
+![](images/39c9814e291badeb4864b5565279807735c0ad27747fbd2f757a12d3b88bc712.jpg)  
+Figure 2: Our CUDA-based Atari emulator uses an Atari CPU kernel to emulate the functioning of the Atari CPU and advance the game state, and a second TIA kernel to emulate the TIA and render frames directly in GPU memory. For episode resetting we generate and store a cache of random initial states. Massive parallelization on GPU threads allows the parallel emulation of thousands of Atari games.
+
+code, update the Atari CPU and TIA registers as well as the game state in the 128 bytes RAM, and eventually render the pixels in the output frame. However, the contrasting nature of the game code execution and renderings tasks, the first dominated by reading from the RAM/ROM and writing tens of bytes to RAM, while the second writes hundreds of pixels to the framebuffer, poses a serious issue in terms of performance, such as thread divergence and an imbalanced number of registers required by the first and second tasks. To mitigate these issues, CuLE uses two CUDA kernels: the first one first loads data from the GPU global memory, where we store the state of each emulated Atari processor, and the 128 bytes RAM data containing the current state of the game; it also reads ROM instructions from the constant GPU memory, executes them to update the Atari CPU and game states, and stores the updated Atari CPU and game states back into GPU global memory. It is important to notice that this first kernel does not execute the TIA instructions read from the ROM, but copies them into the TIA instruction buffer in GPU global memory, which we implemented to decouple the execution of the Atari CPU and TIA instructions in CuLE. The second CuLE kernel emulates the functioning of the TIA processor: it first reads the instructions stored in the TIA instruction buffer, execute them to update the TIA registers, and renders the $1 6 0 \times 2 1 0$ output framebuffer in global GPU memory. Despite this implementation requires going through the TIA instruction twice, it has several advantages over the single-kernel trivial implementation. First of all, the requirements in terms of registers per thread and the chance of having divergent code are different for the Atari CPU and TIA kernels, and the use of different kernels achieves a better GPU usage. A second advantage that we exploit is that not all frames are rendered in ALE: the input of the RL algorithm is the pixelwise maximum between the last two frames in a sequence of four, so we can avoid calling the TIA kernel when rendering of the screen is not needed. A last advantage, not exploited in our implementation yet, is that the TIA kernel may be scheduled one the GPU with more than one thread per game, as rendering of diverse rows on the screen is indeed a parallel operation - we leave this optimization for future developments of CuLE.
+
+To better fit our execution model, our game reset strategy is also different from the one in the existing CPU emulators, where 64 startup frames are executed at the end of each episode. Furthermore, wrapper interfaces for RL, such as ALE, randomly execute an additional number of frames (up to 30) to introduce randomness into the initial state. This results into up to 94 frames to reset a game, which may cause massive divergence between thousands of emulators executing in SIMD fashion on a GPU. To address this issue, we generate and store a cache of random initial states (30 by default) when a set of environments is initialized in CuLE. At the end of an episode, each emulator randomly selects one of the cached states as a seed and copies it into the terminal emulator state.
+
+Some of the choices made for the implementation of CuLE are informed by ease of debugging, like associating one state update kernel to one environment, or need for flexibility, like emulating the Atari console instead of directly writing CUDA code for each Atari game. A 1-to-1 mapping between threads and emulators is not the most computationally efficient way to run Atari games on a GPU, but it makes the implementation relatively straightforward and has the additional advantage that the same emulator code can be executed on the CPU for debugging and benchmarking (in the following, we will refer to this implementation as CuLECPU). Despite of this, the computational advantage provided by CuLE over traditional CPU emulation remains significant, as shows in the next Section.
+
+# 4 EXPERIMENTS
+
+Atari emulation We measure the FPS under different conditions: we get an upper bound on the maximum achievable FPS in the emulation only case, when we emulate the environments and use a random policy to select actions. In the inference only case, we measure the FPS along the inference path: a policy DNN selects the actions, CPU-GPU data transfer occur for CPU emulators, while both emulation and DNN inference run on the GPU when CuLE is used. This is the maximum throughput achievable by off-policy algorithms, when data generation and consumption are decoupled and run on different devices. In the training case, the entire DRL system is at work: emulation, inference, and training may all run on the same GPU. This is representative of the case of on-policy algorithms, but the FPS are also affected by the computational cost of the specific DRL update algorithm; in our experiments we use a vanilla A2C OpenAI (2017), with N-step bootstrapping, and $N = 5$ as the baseline (for details of A2C and off-policy correction with V-trace, see the Appendix).
+
+![](images/4c09a344d6beabf4b49f9a470684a519d98a37d99ad27bddbe7d3d0f07598f44.jpg)  
+Figure 3: FPS and FPS / environment on System I in Table 2, for OpenAI Gym OpenAI (2017), CuLECPU, and CuLE, as a function of the number of environments, under different load conditions: emulation only, and inference only. The boxplots indicate the minimum, $2 5 ^ { t h }$ , $5 0 ^ { t h }$ , $7 5 ^ { t h }$ percentiles and maximum FPS, for the entire set of 57 Atari games.
+
+Table 3: Training FPS, DNN’s Update Per Second (UPS), time to reach a given score, and corresponding number of training frames for four Atari games, $\mathrm { { A 2 C + V } } .$ trace, and different configurations of the emulation engines, measured on System I in Table 2 (System III for the multi-GPU case). The best metric in each row is in bold.   
+
+<table><tr><td>Engine</td><td colspan="4">OpenAI Gym</td><td colspan="3">CuLE,1 GPU</td><td>CuLE,4 GPUs</td><td>Game</td></tr><tr><td>Envs</td><td>120</td><td>120</td><td>120</td><td>1200</td><td>1200</td><td>1200</td><td>1200</td><td>1200×4</td><td></td></tr><tr><td>Batches</td><td>1</td><td>5</td><td>20</td><td>20</td><td>1</td><td>5</td><td>20</td><td>20×4</td><td>一</td></tr><tr><td>N-steps</td><td>5</td><td>5</td><td>20</td><td>20</td><td>5</td><td>5</td><td>20</td><td>20</td><td></td></tr><tr><td>SPU</td><td>5</td><td>1</td><td>1</td><td>1</td><td>5</td><td>1</td><td>1</td><td>1</td><td></td></tr><tr><td>Training KFPS</td><td>4.2</td><td>3.4</td><td>3.0</td><td>4.9</td><td>10.6</td><td>11.5</td><td>11.0</td><td>42.7</td><td>1sssst</td></tr><tr><td>UPS</td><td>7.0</td><td>28.3</td><td>24.7</td><td>4.1</td><td>1.8</td><td>9.6</td><td>9.1</td><td>8.9</td><td></td></tr><tr><td>Time [mins]</td><td>20.2 5.0</td><td></td><td>42.6</td><td>44.2</td><td>18.8</td><td>9.4</td><td>9.9</td><td>7.9</td><td></td></tr><tr><td>Training Mframes (for average score: 800)</td><td></td><td></td><td>7.5</td><td>13.0</td><td>12.0</td><td>6.5</td><td>6.5</td><td>18.0</td><td></td></tr><tr><td>Training KFPS</td><td>4.3</td><td>3.3</td><td>3.0</td><td>4.9</td><td>11.9</td><td>12.5</td><td>12.1</td><td>46.6</td><td>XAestt</td></tr><tr><td>UPS</td><td>7.1</td><td>27.9</td><td>24.8</td><td>4.1</td><td>2.0</td><td>10.4</td><td>10.0</td><td>9.7</td><td></td></tr><tr><td>Time [mins]</td><td>8.1 2.0</td><td>35.2 7.0</td><td>14.4</td><td>27.1</td><td>一</td><td>14.0</td><td>3.4</td><td>2.5</td><td></td></tr><tr><td>Training Mframes (for average score: 1,000)</td><td></td><td></td><td>2.5</td><td>8.0</td><td>1</td><td>10.5</td><td>2.5</td><td>7.0</td><td></td></tr><tr><td>Training KFPS</td><td>4.0</td><td>3.3</td><td>2.8</td><td>4.8</td><td>9.0</td><td>9.6</td><td>9.2</td><td>35.5</td><td></td></tr><tr><td>UPS</td><td>6.7</td><td>27.1</td><td>23.7</td><td>4.0</td><td>1.5</td><td>8.0</td><td>7.7</td><td>7.4</td><td>Waeraa</td></tr><tr><td>Time [mins]</td><td>16.6 4.0</td><td>20.5 4.0</td><td>14.7 2.5</td><td>12.4 3.5</td><td>/</td><td>6.9 4.0</td><td>11.8 6.5</td><td>2.4</td><td></td></tr><tr><td>Training Mframes (for average score: 1,500)</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>3.0</td><td></td></tr><tr><td>Training KFPS</td><td>4.3</td><td>3.4</td><td>3.0</td><td>4.8</td><td>10.5</td><td>11.2</td><td>10.6</td><td>41.7K</td><td></td></tr><tr><td>UPS</td><td>7.2</td><td>28.1</td><td>24.9</td><td>4.0</td><td>1.8</td><td>9.3</td><td>8.9</td><td>8.7</td><td></td></tr><tr><td>Time [mins]</td><td>21.2</td><td>12.2</td><td>8.4</td><td>8.7</td><td>1</td><td>5.9</td><td>3.1</td><td>2.4</td><td></td></tr><tr><td>Training Mframes (for average score:18)</td><td>5.5</td><td>2.5</td><td>1.5</td><td>2.5</td><td>1</td><td>4.0</td><td>2.0</td><td>6.0</td><td></td></tr></table>
+
+Figs. 3(a)-3(b) show the FPS generated by OpenAI Gym, $\mathrm { C u L E _ { C P U } }$ , and CuLE, on the entire set of Atari games, as a function of the number of environments. In the emulation only case, CPU emulation is more efficient for a number of environments up to 128, when the GPU computational power is not leveraged because of the low occupancy. For a larger number of environments, CuLE significantly overcomes OpenAI Gym, for which FPS are mostly stable for 64 environments or more, indicating that the CPU is saturated: the ratio between the median FPS generated by CuLE with 4096 environment (64K) and the peak FPS for OpenAI Gym (18K) is $3 . 5 6 \times$ . In the inference only case there are two additional overheads: CPU-GPU communication (to transfer observations), and DNN inference on the GPU. Consequently, CPU emulators achieve a lower FPS in inference only when compared to emulation only; the effects of the overheads is more evident for a small number of environments, while the FPS slightly increase with the number of environments without reaching the emulation only FPS. CuLE’s FPS are also lower for inference only, because of the latency introduced by DNN inference, but the FPS grow with the number of environments, suggesting that the computational capability of the GPU is still far from being saturated.
+
+![](images/d2b7c56ff3eacb743c7e3e23f2ff4ffb98e21dd9826febc95bb042b9737b245d.jpg)  
+Figure 4: FPS as a function of the environment step, measured on System I in Table 2 for emulation only on four Atari games, 512 environments, for CuLE; each panel also shows the number of resetting environments. FPS is higher at the beginning, when all environments are in similar states and thread divergence within warps is minimized; after some steps, correlation is lost, FPS decreases and stabilizes. Minor oscillations in FPS are possibly associated to more or less computational demanding phases in the emulation of the environments (e.g., when a goal is scored in Pong).
+
+Factors affecting the FPS Figs. 3(a)-3(b) shows that the throughput varies dramatically across games: 4096 CuLECPU environments run at 27K FPS on Riverraid, but only 14K FPS for Boxing: a
+
+$1 . 9 3 \times$ difference, explained by the different complexity of the ROM code of each game. The ratio between the maximum and minimum FPS is amplified in the case of GPU emulation: Riverraid runs in emulation only at 155K FPS when emulated by CuLE and 4096 environments, while UpNDown runs at 41K FPS —a $3 . 7 8 \times$ ratio.
+
+To better highlight the impact of thread divergence on throughput, we measure the FPS for CuLE, emulation only, 512 environments, and four games (Fig. 4). All the environments share the same initial state, but random action selection leads them to diverge after some steps. Each environment resets at the end of an episode. The FPS is maximum at the very beginning, when all the environments are in similar states and the chance to execute the same instruction in all the threads is high. When they move towards different states, code divergence negatively impacts the FPS, until it reaches an asymptotic value. This effect is present in all games and particularly evident for MsPacman in Fig. 4; it is not present in CPU emulation (see Appendix). Although divergence can reduce FPS by $3 0 \%$ in the worst case, this has to be compared with case of complete divergence within each thread and for each instruction, which would yield $1 / 3 2 \simeq 3 \%$ of the peak performances. Minor oscillations of the FPS are also visible especially for games with a repetitive pattern (e.g. Pong), where different environments can be more or less correlated with a typical oscillation frequency.
+
+Performances during training Fig. 5 compares the FPS generated by different emulation engines on a specific game (Assault)2, for different load conditions, including the training case, and number of environments. As expected, when the entire training path is at work, the FPS decreases even further. However, for CPU emulators, the difference between FPS in the inference only and training cases decreases when the number of environments increases, as the system is bounded by the CPU computational capability and CPU-GPU communication bandwidth. In the case of the CPU scaling to multiple GPUs would be ineffective for on-policy algorithms, such GA3C Babaeizadeh et al. (2016; 2017), or sub-optimal, in the case of distributed systems Espeholt et al. (2018); Stooke & Abbeel (2018b). On the other hand, the difference between inference only and training FPS increases with the number of environments for CuLE, because of the additional training overhead on the GPU. The potential speed-up provided by CuLE for vanilla A2C and Assault in Fig. 5 is $2 . 5 3 \times$ for 1,024 environments, but the system is bounded by the GPU computational power; as a consequence, better batching strategies that reduce the training computational overhead as well as scaling to multiple GPUs are effective to further increase the speed-up ratio, as demonstrated later in this Section.
+
+![](images/3c5538b6112ee87bb0aa7e36a680921fa4e1b85131c89f78d3d477becb1b34a6.jpg)  
+Figure 5: FPS generated by different emulation engines on System I in Table 2 for Assault, as a function of the number of environments, and different load conditions for A2C with N-step bootstrapping, $N = 5$ ).
+
+When data generation and training can be decoupled, like for off-policy algorithms, training can be easily moved to a different GPU and the inference path can be used at maximum speed. The potential speed-up provided by CuLE for off-policy algorithms is then given by the ratio between the inference only median FPS for CuLE (56K) and CuLECPU (18K), which is $3 . 1 1 \times$ for 4,096 environments. Furthermore, since the FPS remains flat for CPU emulation, the advantage of CuLE amplifies (for both on- and off-policy methods) with the number of environments.
+
+Frames per second per environment Fig. 3(c)-3(d) show the FPS / environment for different emulation engines on System I, as a function of the number of environments. For 128 environments or fewer, CPU emulators generate frames at a higher rate (compared to CuLE), because CPUs are optimized for low latency, and execute a high number of instructions per second per thread. However, the FPS / environment decrease with the number of environments, that have to share the same CPU cores. Instead, the GPU architecture maximizes the throughput and has a lower number of instructions per second per thread. As a consequence, the FPS / environment is smaller (compared to CPU emulation) for a small number of environments, but they are almost constant up to 512 environments, and starts decreasing only after this point. In practice, CuLE environments provide an efficient means of training with a diverse set of data and collect large statistics about the rewards experienced by numerous agents, and consequently lowering the variance of the value estimate. On the other hand, samples are collected less efficiently in the temporal domain, which may worsen the bias on the estimate of the value function by preventing the use of large N in N-step bootstrapping. The last paragraph of this Section shows how to leverage the high throughput generated by CuLE, considering these peculiarities.
+
+Memory limitations Emulating a massively large number of environments can be problematic considering the relatively small amount of GPU DRAM. Our PyTorch Paszke et al. (2017) implementation of A2C requires each environment to store $4 8 4 \mathrm { x } 8 4$ frames, plus some additional variables for the emulator state. For 16K environments this translates into 1GB of memory, but the primary issue is the combined memory pressure to store the DNN with 4M parameters and the meta-data during training, including the past states: training with 16K environments easily exhausts the DRAM on a single GPU (while training on multiple GPUs increases the amount of available RAM). Since we did not implement any data compression scheme as in Horgan et al. (2018), we constrain our training configuration to fewer than 5K environments, but peak performance in terms of FPS would be achieved for a higher number of environments - this is left as a possible future improvement.
+
+A2C We analyze in detail the case of A2C with CuLE on a single GPU. As a baseline, we consider vanilla A2C, using 120 OpenAI Gym CPU environments that send training data to the GPU to update the DNN (Fig. 6(a)) every $N = 5$ steps. This configuration takes, on average, 21.2 minutes (and $5 . 5  { \mathrm { M } }$ training frames) to reach a score of 18 for Pong and 16.6 minutes (4.0M training frames) for a score of 1,500 on Ms-Pacman (Fig. 7, red line; first column of Table 3). CuLE with 1,200 environments generates approximately $2 . 5 \times$ more FPS compared to OpenAI Gym, but this alone is not sufficient to improve the convergence speed (blue line, Fig. 7). CuLE generates larger batches but, because FPS / environment is lower when compared to CPU emulation, fewer Updates Per Second (UPS) are performed for training the DNN (Table 3), which is detrimental for learning.
+
+$\mathbf { A 2 C + V } .$ -trace and batching strategy To better leverage CuLE, and similar in spirit to the approach in IMPALA Espeholt et al. (2018), we employ a different batching strategy, illustrated in Fig. 6(b): environment steps occur in parallel on the GPU, but training data are read in batches to update the DNN every Steps Per Update (SPU) steps. This batching strategy significantly increases the DNN’s UPS at the cost of a slight decrease in FPS (second columns of OpenAI Gym and CuLE in Table 3), due to the fact that the GPU has to dedicate more time to training. Furthermore, as only the most recent data in a batch are generated with the current policy, we use V-trace Espeholt et al. (2018) for off-policy correction. The net result is an increase of the overall training time when 120
+
+![](images/38a3faa977d18863aef8187ad152e7cb6433535d7f1060fcbe0a2d6923ce4c17.jpg)  
+Figure 6: Different batching strategies are defined by the number of batches, N-Steps and Steps Per Update (SPU) parameters. The on-policy single batch case (panel a) is a special case of the more general, off-policy multi batch approach (panel b). The batching strategy affects both the computational and convergence aspects of the DRL algorithm, as shown in Fig. 7 and in Table 3.
+
+OpenAI Gym CPU environments are used, as this configuration pays for the increased training and communication overhead, while the smaller batch size increases the variance in the estimate of the value function and leads to noisy DNN updates (second column in Table 3, orange lines in Fig. 7). Since CuLE does not suffer from the same computational bottlenecks, and at the same time benefits from the variance reduction associated with the large number (1,200) of environments, using the same batching strategy with CuLE reduces the time to reach a score of 18 for Pong and 1,500 for Pacman respectively to 5.9 and 6.9 minutes. The number of frames required to reach the same score is sometimes higher for CuLE (Table 3), which can lead to less sample efficient implementation when compared to the baseline, but the higher FPS largely compensates for this. Extending the batch size in the temporal dimension (N-steps bootstrapping, $N = 2 0$ ) increases the GPU computational load and reduces both the FPS and UPS, but it also reduces the bias in the estimate of the value function, making each DNN update more effective, and leads to an overall decrease of the wall clock training time, the fastest convergence being achieved by CuLE with 1,200 environments. Using OpenAI Gym with the same configuration results in a longer training time, because of the lower FPS generated by CPU emulation.
+
+![](images/dd2dbc43dfa9bda856eb75060f513594e44e6ae5fa16bb24248ea97e58ed6195.jpg)  
+Figure 7: Average testing score and standard deviation on four Atari games as a function of the training time, for $\mathrm { { A 2 C + V } } .$ -trace, System III in Table 2, and different batching strategies (see also Table 3). Training frames are double for the multi-GPU case (black line). Training performed on CuLE or OpenAI Gym; testing performed on OpenAI Gym environments (see the last paragraph of Section 4).
+
+Scaling to multiple GPUs The black line in Fig. 7 represents the case of $\mathrm { A 2 C + V } .$ - Trace with CuLE and 4 GPUs, each emulating 1,200 environments. The FPS grow almost linearly with the number of GPUs under this training load: CuLE running on 4 GPUs allows generating and consuming a comparable number of FPS with respect to IMPALA on a large CPU cluster (Table 1)). This leads to a dramatic reduction of the convergence time, as documented in Table 3, with Pong almost solved in less than 3 minutes.
+
+Beyond $\mathrm { { A 2 C + V } } .$ -trace, we report in Table 4 the time to generate 200M frames for PPO and Rainbow DQN by running CuLE on 1 to 8 GPUs on a single system. We
+
+use the PyTorch multiprocessing facilities to launch 1 process for each GPU and update gradients in a distributed manner using the NVIDIA NCCL multi-GPU communication backend. This Table shows efficient scaling of the training FPS with the number of GPUs. As in the case of $\mathrm { A 2 C + V } .$ - trace, an efficient batching strategy is then required to fully leverage the high throughput generated by CuLE and can significantly improve these figures.
+
+Generalization for different systems Table 5 reports the FPS for the implementations of vanilla DQN, A2C, and PPO, on System I and II in Table 2. The speed-up in terms of FPS provided by CuLE is consistent across different systems, different algorithms, and larger in percentage for a large number of environments. Different DRL algorithms achieve different FPS depending on the complexity and frequency of the training step on the GPU.
+
+Table 4: Hours to complete 50M training frames (200M raw frames) on System III in Table 2, by GPU count, for two different DRL algorithms, 2,048 environments per GPU.   
+
+<table><tr><td>Alg0</td><td>1 GPU</td><td>2 GPUs</td><td>4 GPUs</td><td>8 GPUs</td></tr><tr><td>PPO</td><td>9.38</td><td>4.45</td><td>2.12</td><td>1.1</td></tr><tr><td>Rainbow DQN</td><td>10.5</td><td>5.1</td><td>3.2</td><td>2.1</td></tr></table>
+
+The same Table also reports the minimum and maximum GPU utilization measured while running each DRL algorithm. In its vanilla implementation DQN is characterized by long GPU idle times occurring during CPU emulation, leading to a low GPU utilization. The GPU utilization increases when emulation is moved to the GPU, while GPU peak utilization is reached during the DNN training step. GPU underutilization can be observed also for policy-gradient algorithms (A2C, PPO) and CPU emulation; peak utilization is higher for PPO, because of its larger computational complexity. Nearly full GPU utilization is achieved only by CuLE for a large number of environments.
+
+Correctness of the implementation To guarantee that CuLE is compliant with OpenAI Gym, we seed OpenAI Gym and CuLE environments with the same game state and successfully verify that the sequence of game states and frames returned by each environment are equivalent. A more subtle question to answer is if the CuLE reset procedure, based on a set of random initial states, can reduce the variability in the environments and consequently be detrimental for the learning and generalization capability of the trained agents. Our code ([URL revealed upon acceptance]) allows the user to test the training agent on CuLE, CuLECPU, and OpenAI Gym environments: in our tests the results are comparable for the three backends. Results reported in Fig. 7 and in the Appendix further suggest that CuLE trained agents do not suffer any performance loss when tested on OpenAI Gym environments.
+
+Table 5: Average FPS and min/max GPU utilization during training for Pong with different algorithms and using different emulation engines on different systems (see Table 2); CuLE consistently leads to higher FPS and GPU utilization.   
+
+<table><tr><td rowspan="2">Algorithm</td><td rowspan="2">Emulation engine</td><td colspan="4">FPS [GPU utilization %]</td></tr><tr><td>System I[256 envs]</td><td>System I[1024 envs]</td><td>System II [256 envs]</td><td>System II [1024 envs]</td></tr><tr><td rowspan="3">DQN</td><td>OpenAI</td><td>6.4K[15-42%]</td><td>8.4K [0-69%]</td><td>10.8K[26-32%]</td><td>21.2K [28-75%]</td></tr><tr><td>CuLEcPU</td><td>7.2K[16-43%]</td><td>8.6K[0-72%]</td><td>6.8K[17-25%]</td><td>20.8K [8-21%]</td></tr><tr><td>CuLE</td><td>14.4K [16-99%]</td><td>25.6K[17-99%]</td><td>11.2K [48-62%]</td><td>33.2K [57-77%]</td></tr><tr><td rowspan="3">A2C</td><td>OpenAI</td><td>12.8K [2-15%]</td><td>15.2K [0-43%]</td><td>24.4K [5-23%]</td><td>30.4K [3-45%]</td></tr><tr><td>CuLEcPU</td><td>10.4K[2-15%]</td><td>14.2K [0-43%]</td><td>12.8K [1-18%]</td><td>25.6K[3-47%]</td></tr><tr><td>CuLE</td><td>19.6K [97-98%]</td><td>51K [98-100%]</td><td>23.2K [97-98%]</td><td>48.0K[98-99%]</td></tr><tr><td rowspan="3">PPO</td><td>OpenAI</td><td>12K[3-99%]</td><td>10.6K [0-96%]</td><td>16.0K [4-33%]</td><td>19.2K [4-62%]</td></tr><tr><td>CuLEcPU</td><td>10K[2-99%]</td><td>10.2K [0-96%]</td><td>9.2K[2-28%]</td><td>18.4K [3-61%]</td></tr><tr><td>CuLE</td><td>14K [95-99%]</td><td>36K[95-100%]</td><td>14.4K [43-98%]</td><td>28.0K[45-99%]</td></tr></table>
+
+# 5 DISCUSSION AND CONCLUSION
+
+The common allocation of the tasks in a DRL system dictates that the environment should run on CPUs, whereas GPUs should be dedicated to DNN operations. With most of the existing frameworks Brockman et al. (2016); Mirowski et al. (2016); Tassa et al. (2018); Tian et al. (2017) following this paradigm, the limited CPU-GPU communication bandwidth and CPU capability to emulate a large number of environments represent two limiting factors to effectively accelerate DRL algorithms, even when mapped to expensive distributed systems. By rendering frames directly on the GPU, CuLE overcomes these limitations and generate as many FPS as those generated by large, expensive CPU systems. CuLE promises to be an effective tool to develop and test DRL algorithms by significantly reducing the experiment turnaround time.
+
+As already shown by others in the case of DRL on distributed system, our experiments show that proper batching coupled with a slight off-policy gradient policy algorithm can significantly accelerate the wall clock convergence time; CuLE has the additional advantage of allowing effective scaling of this implementation to a system with multiple GPUs. CuLE effectively allows increasing the number of parallel environments but, because of the low number of instructions per second per thread on the GPU, training data can be narrow in the time direction. This can be problematic for problems with sparse temporal rewards, but rather than considering this as a pure limitation of CuLE, we believe that this peculiarity opens the door to new interesting research questions, like active sampling of important states Hessel et al. (2017); Wang et al. (2015) that can then be effectively analyzed on a large number of parallel environments with CuLE. CuLE also hits a new obstacle, which is the limited amount of DRAM available on the GPU; studying new compression schemes, like the one proposed in Hessel et al. (2017), as well as training methods with smaller memory footprints may help extend the utility of CuLE to even larger environment counts, and design better GPU-based simulator for RL in the future. Since these are only two of the possible research directions for which CuLE is an effective investigation instrument, CuLE comes with a python interface that allows easy experimentation and is freely available to any researcher at [URL revealed upon acceptance].
+
+A last note has to be done on CuLE’s implementation, that is informed by ease of debugging, need for flexibility, and compatibility with standard DRL benchmarks. These choices put a limit on the achievable speed up factor (for instance by using emulation of the Atari 2600 console instead of direct CUDA implementations of Atari games), but the analysis and insights provided in our paper furnish indications for the design of efficient simulators for DRL.
+
+# REFERENCES
+
+Mohammad Babaeizadeh, Iuri Frosio, Stephen Tyree, Jason Clemons, and Jan Kautz. GA3C: gpubased A3C for deep reinforcement learning. CoRR, abs/1611.06256, 2016. URL http:// arxiv.org/abs/1611.06256.
+
+Mohammad Babaeizadeh, Iuri Frosio, Stephen Tyree, Jason Clemons, and Jan Kautz. Reinforcement learning through asynchronous advantage actor-critic on a gpu. In ICLR, 2017.
+
+M. G. Bellemare, Y. Naddaf, J. Veness, and M. Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, jun 2013.
+
+Marc G. Bellemare, Will Dabney, and Remi Munos. A distributional perspective on reinforcement ´ learning. CoRR, abs/1707.06887, 2017. URL http://arxiv.org/abs/1707.06887.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016.
+
+Alfredo V. Clemente, Humberto Nicolas Castej ´ on Mart ´ ´ınez, and Arjun Chandra. Efficient parallel methods for deep reinforcement learning. CoRR, abs/1705.04862, 2017. URL http://arxiv. org/abs/1705.04862.
+
+Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Volodymyr Mnih, Tom Ward, Yotam´ Doron, Vlad Firoiu, Tim Harley, Iain Dunning, Shane Legg, and Koray Kavukcuoglu. IMPALA: scalable distributed deep-rl with importance weighted actor-learner architectures. CoRR, abs/1802.01561, 2018. URL http://arxiv.org/abs/1802.01561.
+
+Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, and Shane Legg. ´ Noisy networks for exploration. CoRR, abs/1706.10295, 2017. URL http://arxiv.org/ abs/1706.10295.
+
+Matteo Hessel, Joseph Modayil, Hado van Hasselt, Tom Schaul, Georg Ostrovski, Will Dabney, Daniel Horgan, Bilal Piot, Mohammad Gheshlaghi Azar, and David Silver. Rainbow: Combining improvements in deep reinforcement learning. CoRR, abs/1710.02298, 2017. URL http:// arxiv.org/abs/1710.02298.
+
+Dan Horgan, John Quan, David Budden, Gabriel Barth-Maron, Matteo Hessel, Hado van Hasselt, and David Silver. Distributed prioritized experience replay. CoRR, abs/1803.00933, 2018. URL http://arxiv.org/abs/1803.00933.
+
+Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016.
+
+Timothy P. Lillicrap, Jonathan J. Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. CoRR, abs/1509.02971, 2015. URL http://arxiv.org/abs/1509.02971.
+
+Marlos C. Machado, Marc G. Bellemare, Erik Talvitie, Joel Veness, Matthew J. Hausknecht, and Michael Bowling. Revisiting the arcade learning environment: Evaluation protocols and open problems for general agents. CoRR, abs/1709.06009, 2017.
+
+Piotr Mirowski, Razvan Pascanu, Fabio Viola, Hubert Soyer, Andrew J. Ballard, Andrea Banino, Misha Denil, Ross Goroshin, Laurent Sifre, Koray Kavukcuoglu, Dharshan Kumaran, and Raia Hadsell. Learning to navigate in complex environments. CoRR, abs/1611.03673, 2016. URL http://arxiv.org/abs/1611.03673.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, February 2015. ISSN 00280836. URL http://dx.doi.org/10.1038/nature14236.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In Maria Florina Balcan and Kilian Q. Weinberger (eds.), Proceedings of The 33rd International Conference on Machine Learning, volume 48 of Proceedings of Machine Learning Research, pp. 1928–1937, New York, New York, USA, 20–22 Jun 2016. PMLR. URL http: //proceedings.mlr.press/v48/mniha16.html.
+
+Arun Nair, Praveen Srinivasan, Sam Blackwell, Cagdas Alcicek, Rory Fearon, Alessandro De Maria, Vedavyas Panneershelvam, Mustafa Suleyman, Charles Beattie, Stig Petersen, Shane Legg, Volodymyr Mnih, Koray Kavukcuoglu, and David Silver. Massively parallel methods for deep reinforcement learning. CoRR, abs/1507.04296, 2015. URL http://arxiv.org/abs/ 1507.04296.
+
+OpenAI. Openai baselines: Acktr & a2c, 2017. URL https://blog.openai.com/ baselines-acktr-a2c/.
+
+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. In NIPS-W, 2017.
+
+Jing Peng and Ronald J. Williams. Incremental multi-step q-learning. Machine Learning, 22(1): 283–290, Mar 1996. ISSN 1573-0565. doi: 10.1007/BF00114731. URL https://doi.org/ 10.1007/BF00114731.
+
+Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. CoRR, abs/1511.05952, 2015. URL http://arxiv.org/abs/1511.05952.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. CoRR, abs/1707.06347, 2017. URL http://arxiv.org/abs/ 1707.06347.
+
+Adam Stooke and Pieter Abbeel. Accelerated methods for deep reinforcement learning. CoRR, abs/1803.02811, 2018a. URL http://arxiv.org/abs/1803.02811.
+
+Adam Stooke and Pieter Abbeel. Accelerated methods for deep reinforcement learning. CoRR, abs/1803.02811, 2018b. URL http://arxiv.org/abs/1803.02811.
+
+Richard S. Sutton and Andrew G. Barto. Introduction to Reinforcement Learning. MIT Press, Cambridge, MA, USA, 1st edition, 1998. ISBN 0262193981.
+
+Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, Timothy P. Lillicrap, and Martin A. Riedmiller. Deepmind control suite. CoRR, abs/1801.00690, 2018. URL http: //arxiv.org/abs/1801.00690.
+
+Yuandong Tian, Qucheng Gong, Wenling Shang, Yuxin Wu, and Larry Zitnick. ELF: an extensive, lightweight and flexible research platform for real-time strategy games. CoRR, abs/1707.01067, 2017. URL http://arxiv.org/abs/1707.01067.
+
+Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double qlearning. CoRR, abs/1509.06461, 2015. URL http://arxiv.org/abs/1509.06461.
+
+Ziyu Wang, Nando de Freitas, and Marc Lanctot. Dueling network architectures for deep reinforcement learning. CoRR, abs/1511.06581, 2015. URL http://arxiv.org/abs/1511. 06581.
+
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992.
+
+# A APPENDIX
+
+# A.1 REINFORCEMENT LEARNING, A2C AND V-TRACE
+
+Reinforcement learning In RL, an agent observes a state $s _ { t }$ at time $t$ and follows a policy $\pi =$ $\pi ( s _ { t } )$ to select an action $a _ { t }$ ; the agent also receives a scalar reward $r _ { t }$ from the environment. The goal of RL is to optimize $\pi$ such that the sum of the expected rewards is maximized.
+
+In model-free policy gradient methods $\pi ( { a } _ { t } | s _ { t } ; \theta )$ is the output of a policy DNN with weights $\theta$ , and represents the probability of selecting action $a _ { t }$ in the state $s _ { t }$ . Updates to the DNN are generally aligned in the direction of the gradient of $E [ R _ { t } ]$ , where $\begin{array} { r } { R _ { t } = \sum _ { i = 0 } ^ { \infty ^ { \ast } } \gamma ^ { i } r _ { t + i } } \end{array}$ is the discounted reward from time $t$ , with discount factor $\gamma \in \left( 0 , 1 \right]$ (see also REINFORCE Williams (1992)) The vanilla implementation updates $\theta$ along $\nabla _ { \theta } \log \pi ( a _ { t } | s _ { t } ; \theta ) R _ { t }$ , which is an unbiased estimator of $\nabla _ { \boldsymbol { \theta } } E [ R _ { t } ]$ . The training procedure can be improved by reducing the variance of the estimator by subtracting a learned baseline $b _ { t } ( s _ { t } )$ and using the gradient $\nabla _ { \theta } \mathrm { { ~ \bar { ~ } l o g ~ } } \pi ( a _ { t } | s _ { t } ; \theta ) [ R _ { t } ~ - ~ b _ { t } ( s _ { t } ) ]$ . One common baseline is the value function $V ^ { \pi } \bar { ( s _ { t } ) } = \bar { E } [ R _ { t } | s _ { t } ]$ , which is the expected return for the policy $\pi$ starting from $s _ { t }$ . The policy $\pi$ and the baseline $b _ { t }$ can be viewed as actor and critic in an actor-critic architecture Sutton & Barto (1998).
+
+A2C A2C OpenAI (2017) is the synchronous version of A3C Mnih et al. (2016), a successful actor-critic algorithm, where a single DNN outputs a softmax layer for the policy $\pi \left( a _ { t } | s _ { t } ; \theta \right)$ , and a linear layer for $V \left( s _ { t } ; \theta \right)$ . In A2C, multiple agents perform simultaneous steps on a set of parallel environments, while the DNN is updated every $t _ { m a x }$ actions using the experiences collected by all the agents in the last $t _ { m a x }$ steps. This means that the variance of the critic $V \left( s _ { t } ; \theta \right)$ is reduced (at the price of an increase in the bias) by $N$ -step bootstrapping, with $N = t _ { m a x }$ . The cost function for the policy is then:
+
+$$
+\begin{array} { r } { \log \pi \left( a _ { t } | s _ { t } ; \theta \right) \left[ \tilde { R } _ { t } - V \left( s _ { t } ; \theta _ { t } \right) \right] + \beta H \left[ \pi \left( s _ { t } ; \theta \right) \right] , } \end{array}
+$$
+
+where discou $\theta _ { t }$ are the DNN wed reward from ighto $\theta$ timand $t$ , i $\begin{array} { r } { \tilde { R } _ { t } = \sum _ { i = 0 } ^ { k - 1 } \gamma ^ { i } r _ { t + i } + \gamma ^ { k } V \left( s _ { t + k } ; \theta _ { t } \right) } \end{array}$ bootstrappedis an entropy $t$ $t + k$ $k$ $t _ { m a x }$ $H \left[ \pi \left( \boldsymbol { s } _ { t } ; \boldsymbol { \theta } \right) \right]$ term that favors exploration, weighted by the hyper-parameter $\beta$ . The cost function for the estimated value function is:
+
+$$
+\left[ \tilde { R } _ { t } - V \left( s _ { t } ; \theta \right) \right] ^ { 2 } ,
+$$
+
+which uses, again, the bootstrapped estimate $\tilde { R } _ { t }$ . Gradients $\nabla \theta$ are collected from both of the cost functions; standard optimizers, such as Adam or RMSProp, can be used for optimization.
+
+V-trace In the case where there is a large number of environments, such as in CuLE or IMPALA Espeholt et al. (2018), the synchronous nature of A2C become detrimental for the learning speed, as one should wait for all the environments to complete $t _ { m a x }$ steps before computing a single DNN update. Faster convergence is achieved (both in our paper and in Espeholt et al. (2018)) by desynchronizing data generation and DNN updates, which in practice means sampling a subset of experiences generated by the agents, and updating the policy using an approximate gradient, which makes the algorithm slightly off-policy.
+
+To correct for the off-policy nature of the data, that may lead to inefficiency or, even worse, instabilities, in the training process, V-trace is introduced in Espeholt et al. (2018). In summary, the aim of off-policy correction is to give less weight to experiences that have been generated with policy $\mu$ , called the behaviour policy, when it differs from the target policy, $\pi$ ; for a more principled explanation we remand the curios reader to Espeholt et al. (2018).
+
+For a set of experiences collected from time $t = t _ { 0 }$ to time $t = t _ { 0 } + N$ following some policy $\mu$ , the $N$ -steps $\mathrm { v } .$ -trace target for $V ( s _ { t _ { 0 } } ; \theta )$ is defined as:
+
+![](images/574cb1aec32cf61e869b644174f9d3144b031fdbc2689cffd8c7e23a3686c553.jpg)  
+Figure 8: FPS as a function of the environment step, measured on System I in Table 2 for emulation only on four Atari games, 512 environments, for $\mathrm { C u L E _ { C P U } }$ ; each panel also shows the number of resetting environments. A peak in the FPS at the beginning of the emulation period, as in the case of GPU emulation in Fig. 4, is not visible in this case.
+
+$$
+\begin{array} { r c l } { { v _ { t _ { 0 } } } } & { { = } } & { { V ( s _ { t _ { 0 } } ; \theta ) + \sum _ { t = t _ { 0 } } ^ { t _ { 0 } + N - 1 } \gamma ^ { t - t _ { 0 } } \Bigl ( \prod _ { i = t _ { 0 } } ^ { t - 1 } c _ { i } \Bigr ) \delta _ { t } V , } } \\ { { \delta _ { t } V } } & { { = } } & { { \rho _ { t } \bigl ( r _ { t } + \gamma V ( s _ { t + 1 } ; \theta ) - V ( s _ { t } ; \theta ) \bigr ) } } \\ { { \rho _ { t } } } & { { = } } & { { \operatorname* { m i n } \bigl ( \bar { \rho } , \frac { \pi \bigl ( a _ { t } | s _ { t } \bigr ) } { \mu \bigl ( a _ { t } | s _ { t } \bigr ) } \bigr ) } } \\ { { c _ { i } } } & { { = } } & { { \operatorname* { m i n } \bigl ( \bar { c } , \frac { \pi \bigl ( a _ { i } | s _ { i } \bigr ) } { \mu \bigl ( a _ { i } | s _ { i } \bigr ) } \bigr ) ; } } \end{array}
+$$
+
+$\rho _ { t }$ and $c _ { i }$ are truncated importance sampling (IS) weights, and $\textstyle \prod _ { i = t 0 } ^ { t - 1 } c _ { i } = 1$ for $s = t$ , and $\bar { \rho } \geq$ c¯. Notice that, when we adopt the proposed multi-batching strategy, there are multiple behaviour policies $\mu$ that have been followed to generate the training data — e.g., $_ \mathrm { N }$ different policies are used when $\mathrm { S P U } { = } 1$ in Fig. 6(b). Eqs. 5-6 do not need to be changed in this case, but we have to store all the $\mu ( a _ { i } | s _ { i } )$ in the training buffer to compute the, $\mathrm { V } .$ -trace corrected, DNN update. In our implementation, we compute the V-trace update recursively as:
+
+$$
+v _ { t } = V ( s _ { t } ; \theta ) + \delta _ { t } V + \gamma c _ { s } \bigl ( v _ { t + 1 } - V ( s _ { t + 1 } ; \theta ) \bigr ) .
+$$
+
+At training time $t$ , we update $\theta$ with respect to the value output, $v _ { s }$ , given by:
+
+$$
+\bigl ( v _ { t } - V ( s _ { t } ; \theta ) \bigr ) \nabla _ { \theta } V ( s _ { t } ; \theta ) ,
+$$
+
+whereas the policy gradient is given by:
+
+$$
+\begin{array} { r } { \rho _ { t } \nabla _ { \omega } \log \pi _ { \omega } ( a _ { s } | s _ { t } ) \big ( r _ { t } + \gamma v _ { t + 1 } - V ( s _ { t } ; \theta ) \big ) . } \end{array}
+$$
+
+An entropy regularization term that favors exploration and prevents premature convergence (as in Eq. 1) is also added.
+
+# A.2 THREAD DIVERGENCE IS NOT PRESENT IN THE CASE OF CPU EMULATION
+
+We show here that thread divergence, that affects GPU-based emulation (see Fig. 4), does not affect CPU-based emulation. Fig. 8 shows the FPS on four Atari games where all the environments share the same initial state. In constrast with GPU emulation, the CPU FPS do not peak at the beginning of the emulation period, where many environments are correlated.
+
+For sake of space, we only report (Fig. 9) the FPS measured on system I in Table 2 for three additional games, as a function of different load conditions and number of environments.
+
+![](images/c50ce8c6a2e7a2a93217492c801d7d5dd5426e0ca5072f7c8a8d90a8c19a1859.jpg)  
+Figure 9: FPS generated by different emulation engines on System I in Table 2 for different Atari games, as a function of the number of environments, and different load conditions (the main A2C OpenAI (2017) loop is run here, with N-step bootstrapping, $N = 5$ .
+
+# A.4 CORRECTNESS OF THE IMPLEMENTATION
+
+To demonstrate the correctness of our implementation, and thus that policies learned with CuLE generalize to the same game emulated by OpenAI Gym, we report in Fig. 10 the average scores achieved in testing, while training an agent with with $\mathrm { { A 2 C + V } } .$ -trace and CuLE. The testing scores measured on $\mathrm { C u L E _ { C P U } }$ and OpenAI Gym environments do not show any relevant statistical difference, even for the case of Ms-Pacman, where the variability of the scores is higher because of the nature of the game.
+
+![](images/e3221fe154bd92530f5e90843f67b93bbdd016709dec3c4c5326270e8b762e83.jpg)  
+Figure 10: Average testing scores measured on $1 0 \mathrm { C u L E } _ { \mathrm { C P U } }$ and OpenAI Gym environments, while training with $\mathrm { { A 2 C + V } } .$ -trace and CuLE, as a function of the training frames; 250 environments are used for Ms-Pacman, given its higher variability. The shaded area represents 2 standard deviations.

parse/train/HJgS7p4FPH/HJgS7p4FPH_content_list.json

@@ -0,0 +1,1479 @@
+[
+    {
+        "type": "text",
+        "text": "ACCELERATING REINFORCEMENT LEARNING THROUGH GPU ATARI EMULATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We introduce CuLE (CUDA Learning Environment), a CUDA port of the Atari Learning Environment (ALE) which is used for the development of deep reinforcement algorithms. CuLE overcomes many limitations of existing CPU-based emulators and scales naturally to multiple GPUs. It leverages GPU parallelization to run thousands of games simultaneously and it renders frames directly on the GPU, to avoid the bottleneck arising from the limited CPU-GPU communication bandwidth. CuLE generates up to 155M frames per hour on a single GPU, a finding previously achieved only through a cluster of CPUs. Beyond highlighting the differences between CPU and GPU emulators in the context of reinforcement learning, we show how to leverage the high throughput of CuLE by effective batching of the training data, and show accelerated convergence for $\\mathrm { { A 2 C + V } } .$ -trace. CuLE is available at [URL revealed upon acceptance]. ",
+        "bbox": [
+            233,
+            263,
+            764,
+            431
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            454,
+            336,
+            470
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Initially triggered by the success of DQN Mnih et al. (2015), research in Deep Reinforcement Learning (DRL) has grown in popularity in the last years Lillicrap et al. (2015); Mnih et al. (2016; 2015), leading to intelligent agents that solve non-trivial tasks in complex environments. But DRL also soon proved to be a challenging computational problem, especially if one wants to achieve peak performance on modern architectures. ",
+        "bbox": [
+            174,
+            507,
+            490,
+            645
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Fig. 1 is a schematic representation of a modern DRL algorithm implementation: CPU environments execute a set of actions $\\left\\{ a _ { t - 1 } \\right\\}$ at time $t - 1$ , and produce observable states $\\left\\{ { { s } _ { t } } \\right\\}$ and rewards $\\{ r _ { t } \\}$ . These data are migrated to a Deep Neural Network (DNN) on the GPU to eventu",
+        "bbox": [
+            174,
+            652,
+            490,
+            736
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/780bd4014390345fd53e4c0a0b32fde9e675cbc1b659a08ee61a4765138ee8dc.jpg",
+        "image_caption": [
+            "Figure 1: In a typical DRL system, environments run on CPUs and DNNs on GPUs. The limited CPU-GPU communication bandwidth and small set of environments prevent full GPU usage. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            508,
+            523,
+            818,
+            651
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ally select the next action set, $\\left\\{ { { a } _ { t } } \\right\\}$ , which is copied back to the CPU. This sequence of operations defines the inference path, whose main aim is to generate training data. A training buffer on the GPU stores the states generated on the inference path; this is periodically used to update the DNN’s weights $\\theta$ , according to the training rule of the DRL algorithm (training path). A computationally efficient DRL system should balance the data generation and training processes, while minimizing the communication overhead along the inference path and consuming, along the training path, as many data per second as possible Babaeizadeh et al. (2016; 2017). The solution to this problem is however non-trivial and many DRL implementations do not leverage the full computational potential of modern systems Stooke & Abbeel (2018b). ",
+        "bbox": [
+            174,
+            736,
+            825,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We focus our attention on the inference path and move from the traditional CPU implementation of the Atari Learning Environment (ALE), a set of Atari 2600 games that emerged as an excellent DRL benchmark Bellemare et al. (2013); Machado et al. (2017). We show that significant performance bottlenecks primarily stem from CPU environment emulation: the CPU cannot run a large set of environments simultaneously, the CPU-GPU communication bandwidth is limited, and the GPU is consequently underutilized. To both investigate and mitigate these limitations we introduce CuLE (CUDA Learning Environment), a DRL library containing a CUDA enabled Atari 2600 emulator, that renders frames directly in the GPU memory, avoids off-chip communication and achieves high GPU utilization by processing thousands of environments in parallel—something so far achievable only through large and costly distributed systems. Compared to the traditional CPU-based approach, GPU emulation improves the utilization of the computational resources: CuLE on a single GPU generates more Frames Per Second1 (FPS) on the inference path (between 39K and 125K, depending on the game, see Table 1) compared to its CPU counterpart (between 12.5K and 19.8K). Beyond offering CuLE ([URL revealed upon acceptance]) as a tool for research in the DRL field, our contribution can be summarized as follow: ",
+        "bbox": [
+            174,
+            868,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(1) We identify common computational bottlenecks in several DRL implementations that prevent effective utilization of high throughput compute units and effective scaling to distributed systems. ",
+        "bbox": [
+            171,
+            263,
+            823,
+            291
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(2) We introduce an effective batching strategy for large environment sets, that allows leveraging the high throughput generated by CuLE to quickly reach convergence with $\\mathrm { { A 2 C + V } } .$ -trace Espeholt et al. (2018), and show effective scaling on multiple GPUs. This leads to the consumption of 26-68K FPS along the training path on a single GPU, and up to 187K FPS using four GPUs, comparable (Table 1) to those achieved by large clusters Stooke & Abbeel (2018a); Espeholt et al. (2018). ",
+        "bbox": [
+            174,
+            299,
+            825,
+            368
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(3) We analyze advantages and limitations of GPU emulation with CuLE in DRL, including the effect of thread divergence and of the lower (compared to CPU) number of instructions per second per thread, and hope that our insights may be of value for the development of efficient DRL systems. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            417
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/a5deff33b0e5b2b7771bc46bbe7cf9ce1b19078f78f8f1d84e778579baff03ce.jpg",
+        "table_caption": [
+            "Table 1: Average training times, raw frames to reach convergence, FPS, and computational resources of existing accelerated DRL schemes, compared to CuLE. Data from Horgan et al. (2018); FPS are taken from the corresponding papers, if available, and measured on the entire Atari suite for CuLE. "
+        ],
+        "table_footnote": [
+            "\\*FPS measured on Asterix, Assault, MsPacman, and Pong. "
+        ],
+        "table_body": "<table><tr><td>Algorithm</td><td>Time</td><td>Frames</td><td>FPS</td><td>Resources</td><td>Notes</td></tr><tr><td>Ape-X DQN Horgan et al. (2018)</td><td>5days</td><td>22.800M</td><td>50K</td><td>376 cores,1 GPU</td><td></td></tr><tr><td>Rainbow Hessel et al. (2017)</td><td>10 days</td><td>200M</td><td></td><td>1GPU</td><td></td></tr><tr><td>Distributional (C51) Bellemare et al. (2017)</td><td>10 days</td><td>200M</td><td></td><td>1GPU</td><td></td></tr><tr><td>A3C Mnih et al. (2016)</td><td>4 days</td><td></td><td>2K</td><td>16 cores</td><td></td></tr><tr><td>GA3C Babaeizadeh et al. (2016; 2017)</td><td>1 day</td><td></td><td>8K</td><td>16 cores,1 GPU</td><td></td></tr><tr><td>Prioritized Dueling Wang et al.(2015)</td><td>9.5 days</td><td>200M</td><td></td><td>1 GPU</td><td></td></tr><tr><td>DQN Mnih et al. (2015)</td><td>9.5 days</td><td>200M</td><td></td><td>1GPU</td><td></td></tr><tr><td>Gorila DQN Nair et al. (2015)</td><td>4 days</td><td></td><td></td><td>&gt;100 cores</td><td></td></tr><tr><td>Unreal Jaderberg et al. (2016)</td><td></td><td>250M</td><td></td><td>16 cores</td><td></td></tr><tr><td>Stooke (A2C/DQN) Stooke&amp; Abbeel (2018b)</td><td>hours</td><td>200M</td><td>35K</td><td>40 CPUs,8 GPUs (DGX-1)</td><td></td></tr><tr><td>IMPALA (A2C+V-Trace) Espeholt et al.(2018)</td><td>mins/hours</td><td>200M</td><td>250K</td><td>100-200 cores,1 GPU</td><td></td></tr><tr><td>CuLE(emulation only)</td><td>N/A</td><td>N/A</td><td>41K-155K</td><td>SystemI(1 GPU)</td><td>4096 ALEs</td></tr><tr><td>CuLE(inference only,A2C,single batch)</td><td>N/A</td><td>N/A</td><td>39K-125K</td><td>System I(1GPU)</td><td>4096 ALEs</td></tr><tr><td>CuLE(training,A2C + V-trace,multiple batches)</td><td>1 hour</td><td>200M</td><td>26K-68K</td><td>System I(1 GPU)</td><td>1200 ALEs</td></tr><tr><td>CuLE(training,A2C+ V-trace,multiple batches)*</td><td>mins</td><td>200M</td><td>142-187K</td><td>System III (4 GPUs)</td><td>1200×4 ALEs</td></tr></table>",
+        "bbox": [
+            174,
+            486,
+            830,
+            666
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            718,
+            344,
+            733
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The wall clock convergence time of a DRL algorithm is determined by two main factors: its sample efficiency, and the computational efficiency of its implementation. Here we analyze the sample and computational efficiency of different DRL algorithms, in connection with their implementation. ",
+        "bbox": [
+            174,
+            772,
+            483,
+            869
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/9eaf9fc6d32f1c9f8d327d91f33376a6447ddff3c2e024671c4efc4c81917364.jpg",
+        "table_caption": [
+            "Table 2: Systems used for experiments. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>System</td><td>Intel CPU</td><td>NVIDIA GPU</td></tr><tr><td>I</td><td>12-core Core i7-5930K @3.50GHz</td><td>Titan V</td></tr><tr><td>II</td><td>6-core Core i7-8086K @5GHz</td><td>Tesla V100</td></tr><tr><td>ⅢI</td><td>20-core Core E5-2698 v4 @2.20GHz × 2</td><td>TeslaV100×8,NVLink</td></tr></table>",
+        "bbox": [
+            500,
+            794,
+            825,
+            837
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We first divide DRL algorithms into policy gradient and Q-value methods, as in Stooke & Abbeel (2018b). Q-learning optimizes the error on the estimated action values as a proxy for policy optimization, whereas policy gradient methods directly learn the relation between a state, $s _ { t }$ , and the optimal action, $a _ { t }$ ; since at each update they follow, by definition, the gradient with respect to the policy itself, they improve the policy more efficiently. Policy methods are also considered more general, e.g. they can handle continuous actions easily. Also the on- or off-policy nature of an algorithm profoundly affects both its sample and computational efficiency. Off-policy methods allow re-using experiences multiple times, which directly improves the sample efficiency; additionally, old data stored in the GPU memory (replay buffer in Fig. 1) can be used to continuously update the DNN on the GPU, leading to high GPU utilization without saturating the inference path. The replay buffer has a positive effect on the stability of learning as well Mnih et al. (2015). On-policy algorithms saturate the inference path more easily, as frames have to be generated on-the-fly using the current policy and moved from the CPU emulators to the GPU for processing with the DNN. On-policy updates are generally effective but they are also more prone to fall into local minima because of noise, especially if the number of environment is small — this is the reason why on-policy algorithms largely benefit (in term of stability) from a significant increase of the number of environments. ",
+        "bbox": [
+            174,
+            104,
+            825,
+            325
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Among the policy gradient methods, A3C Mnih et al. (2016) is an asynchronous, on-policy, actorcritic algorithm where 16 CPU agents use copies of the same DNN to interact with CPU environments; $N$ -step bootstrapping is used to reduce the variance of the critic, $V \\left( s _ { t } ; \\theta \\right)$ : the agents send updates to the DNN after every $N = 5$ actions, and the new set of global $\\theta$ weights are broadcast to all agents after each update. A3C can solve an Atari game in approximately 4 days; its hybrid CPUGPU implementation (GA3C Babaeizadeh et al. (2016; 2017)) stores a single DNN on the GPU, collects CPU data in a system of queues to send them to the GPU in large batches, and achieves convergence in 1 day. Recent (and faster) policy gradient implementations, like PAAC Clemente et al. (2017), PPO Schulman et al. (2017), or A2C OpenAI (2017), store training data directly in a GPU training buffer, as depicted in Fig. 1, which is well representative of the flow of computation of modern DRL algorithms. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            486
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Policy gradient algorithms are often on-policy: their efficient update strategy is counterbalanced by the bottlenecks in the inference path and competition for the use of the GPU along the inference and training path at the same time. Acceleration by scaling to a distributed system is possible but inefficient in this case: in IMPALA Espeholt et al. (2018) a cluster with hundreds of CPU cores is needed to accelerate A2C, while training is desynchronized to hide latency. As a consequence, the algorithm becomes off-policy, and V-trace was introduced to deal with off-policy data (see details in the Appendix). Acceleration on a DGX-1 has also been demonstrated for A2C and PPO, using large batch sizes to increase the GPU occupancy, and asynchronous distributed models that hide latency, but require periodic updates to remain synchronized Stooke & Abbeel (2018b) and overall achieves sublinear scaling with the number of GPUs. In practice, the efficiency generally scales sub-linearly on distributed systems, and though Atari games can be solved in a few hours or even minutes, the cost of such systems makes them prohibitive for many researchers. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            659
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Q-value methods, like DQN Mnih et al. (2015) and its more recent, improved versions (DoubleDQN van Hasselt et al. (2015), Dueling Networks Wang et al. (2015), Prioritized Replay Schaul et al. (2015), n-step learning Peng & Williams (1996), NoisyNets Fortunato et al. (2017), Rainbow Hessel et al. (2017)) are generally off-policy and can be accelerated more easily, as the inference and training path can be decoupled, with the GPU continuously fed with training data from the replay buffer in Fig.1. Mapping the two paths on different devices is natural and effective, and indeed DQN methods have been significantly accelerated on distributed systems (see Nair et al. (2015) and Jaderberg et al. (2016) in Table 1). The replay buffer increases the sample efficiency, but the overall convergence time has to pay the cost of using a Q-value method. Furthermore, implementation on large scale systems still incurs a communication overhead and thus generally achieves sub-linear scaling on large distributed systems. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            819
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The best compromise between sample efficiency, computational efficiency and effectiveness of the DNN update seems to be achieved by using an on-policy while correcting for stale data, gradient policy methods like $\\mathrm { { A 2 C + V } } .$ -trace, which is therefore the algorithm analyzed in detail here, but still suffers from computational bottlenecks in its CPU distributed implementation Espeholt et al. (2018). ",
+        "bbox": [
+            174,
+            825,
+            823,
+            882
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Other Data Generation Engines Frameworks to generate training experiences already exist, like the well-known OpenAI Gym, built on top of the $\\mathrm { C } { + } { + }$ Stella emulator Brockman et al. (2016) for Atari games. Other frameworks that target specific problems, such as navigation Mirowski et al. (2016), aim at creating large benchmark for DRL Tassa et al. (2018), or accelerate simulation on the CPU with optimized $\\mathrm { C } { + } { + }$ multi-threaded implementations, while also providing large, GPU-friendly batches for inference and training Tian et al. (2017). To the best of our knowledge, however, none of these attempts directly address the problem of optimizing the inference path, i.e., trying to increase the number of environments while avoiding the CPU and bandwidth bottlenecks, by providing a direct implementation of the environments on the GPU. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 CUDA LEARNING ENVIRONMENT (CULE) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            251,
+            563,
+            268
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Despite the number and variety of games developed for the Atari 2600, it is relatively simple to emulate the functioning of its hardware much faster than real-time. The Atari console has a 1.19Mhz CPU (to execute the game instructions) and a 128 bytes RAM (containing the game state); the code of each game is stored in a cartridge ROM (typically 2–4kB). The instruction set of each game contains both game and rendering instructions; the first ones are executed by the CPU, while the second ones are sent to the Television Interface Adaptor (TIA), a secondary processor embedded in the Atari hardware that executes the rendering instructions to update a limited set of registers and render the $1 6 0 \\times 2 1 0$ game screen using a 128- colour palette. ",
+        "bbox": [
+            174,
+            306,
+            450,
+            570
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In CuLE, we emulate the functioning of many Atari consoles in parallel using the CUDA programming model, where a sequential host program executes parallel programs, known as kernels, on a GPU. In a trivial mapping of the Atari emulator to CUDA, a single thread emulates both the Atari CPU and TIA to execute the ROM ",
+        "bbox": [
+            174,
+            577,
+            450,
+            688
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/39c9814e291badeb4864b5565279807735c0ad27747fbd2f757a12d3b88bc712.jpg",
+        "image_caption": [
+            "Figure 2: Our CUDA-based Atari emulator uses an Atari CPU kernel to emulate the functioning of the Atari CPU and advance the game state, and a second TIA kernel to emulate the TIA and render frames directly in GPU memory. For episode resetting we generate and store a cache of random initial states. Massive parallelization on GPU threads allows the parallel emulation of thousands of Atari games. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            467,
+            323,
+            813,
+            541
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "code, update the Atari CPU and TIA registers as well as the game state in the 128 bytes RAM, and eventually render the pixels in the output frame. However, the contrasting nature of the game code execution and renderings tasks, the first dominated by reading from the RAM/ROM and writing tens of bytes to RAM, while the second writes hundreds of pixels to the framebuffer, poses a serious issue in terms of performance, such as thread divergence and an imbalanced number of registers required by the first and second tasks. To mitigate these issues, CuLE uses two CUDA kernels: the first one first loads data from the GPU global memory, where we store the state of each emulated Atari processor, and the 128 bytes RAM data containing the current state of the game; it also reads ROM instructions from the constant GPU memory, executes them to update the Atari CPU and game states, and stores the updated Atari CPU and game states back into GPU global memory. It is important to notice that this first kernel does not execute the TIA instructions read from the ROM, but copies them into the TIA instruction buffer in GPU global memory, which we implemented to decouple the execution of the Atari CPU and TIA instructions in CuLE. The second CuLE kernel emulates the functioning of the TIA processor: it first reads the instructions stored in the TIA instruction buffer, execute them to update the TIA registers, and renders the $1 6 0 \\times 2 1 0$ output framebuffer in global GPU memory. Despite this implementation requires going through the TIA instruction twice, it has several advantages over the single-kernel trivial implementation. First of all, the requirements in terms of registers per thread and the chance of having divergent code are different for the Atari CPU and TIA kernels, and the use of different kernels achieves a better GPU usage. A second advantage that we exploit is that not all frames are rendered in ALE: the input of the RL algorithm is the pixelwise maximum between the last two frames in a sequence of four, so we can avoid calling the TIA kernel when rendering of the screen is not needed. A last advantage, not exploited in our implementation yet, is that the TIA kernel may be scheduled one the GPU with more than one thread per game, as rendering of diverse rows on the screen is indeed a parallel operation - we leave this optimization for future developments of CuLE. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To better fit our execution model, our game reset strategy is also different from the one in the existing CPU emulators, where 64 startup frames are executed at the end of each episode. Furthermore, wrapper interfaces for RL, such as ALE, randomly execute an additional number of frames (up to 30) to introduce randomness into the initial state. This results into up to 94 frames to reset a game, which may cause massive divergence between thousands of emulators executing in SIMD fashion on a GPU. To address this issue, we generate and store a cache of random initial states (30 by default) when a set of environments is initialized in CuLE. At the end of an episode, each emulator randomly selects one of the cached states as a seed and copies it into the terminal emulator state. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            333
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Some of the choices made for the implementation of CuLE are informed by ease of debugging, like associating one state update kernel to one environment, or need for flexibility, like emulating the Atari console instead of directly writing CUDA code for each Atari game. A 1-to-1 mapping between threads and emulators is not the most computationally efficient way to run Atari games on a GPU, but it makes the implementation relatively straightforward and has the additional advantage that the same emulator code can be executed on the CPU for debugging and benchmarking (in the following, we will refer to this implementation as CuLECPU). Despite of this, the computational advantage provided by CuLE over traditional CPU emulation remains significant, as shows in the next Section. ",
+        "bbox": [
+            174,
+            339,
+            825,
+            465
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            488,
+            326,
+            503
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Atari emulation We measure the FPS under different conditions: we get an upper bound on the maximum achievable FPS in the emulation only case, when we emulate the environments and use a random policy to select actions. In the inference only case, we measure the FPS along the inference path: a policy DNN selects the actions, CPU-GPU data transfer occur for CPU emulators, while both emulation and DNN inference run on the GPU when CuLE is used. This is the maximum throughput achievable by off-policy algorithms, when data generation and consumption are decoupled and run on different devices. In the training case, the entire DRL system is at work: emulation, inference, and training may all run on the same GPU. This is representative of the case of on-policy algorithms, but the FPS are also affected by the computational cost of the specific DRL update algorithm; in our experiments we use a vanilla A2C OpenAI (2017), with N-step bootstrapping, and $N = 5$ as the baseline (for details of A2C and off-policy correction with V-trace, see the Appendix). ",
+        "bbox": [
+            173,
+            551,
+            825,
+            705
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/4c09a344d6beabf4b49f9a470684a519d98a37d99ad27bddbe7d3d0f07598f44.jpg",
+        "image_caption": [
+            "Figure 3: FPS and FPS / environment on System I in Table 2, for OpenAI Gym OpenAI (2017), CuLECPU, and CuLE, as a function of the number of environments, under different load conditions: emulation only, and inference only. The boxplots indicate the minimum, $2 5 ^ { t h }$ , $5 0 ^ { t h }$ , $7 5 ^ { t h }$ percentiles and maximum FPS, for the entire set of 57 Atari games. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            718,
+            823,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/f3695b709576e6dfddff314f1ee8c26773d2cbc036ec5587f931c8553c308fa6.jpg",
+        "table_caption": [
+            "Table 3: Training FPS, DNN’s Update Per Second (UPS), time to reach a given score, and corresponding number of training frames for four Atari games, $\\mathrm { { A 2 C + V } } .$ trace, and different configurations of the emulation engines, measured on System I in Table 2 (System III for the multi-GPU case). The best metric in each row is in bold. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Engine</td><td colspan=\"4\">OpenAI Gym</td><td colspan=\"3\">CuLE,1 GPU</td><td>CuLE,4 GPUs</td><td>Game</td></tr><tr><td>Envs</td><td>120</td><td>120</td><td>120</td><td>1200</td><td>1200</td><td>1200</td><td>1200</td><td>1200×4</td><td></td></tr><tr><td>Batches</td><td>1</td><td>5</td><td>20</td><td>20</td><td>1</td><td>5</td><td>20</td><td>20×4</td><td>一</td></tr><tr><td>N-steps</td><td>5</td><td>5</td><td>20</td><td>20</td><td>5</td><td>5</td><td>20</td><td>20</td><td></td></tr><tr><td>SPU</td><td>5</td><td>1</td><td>1</td><td>1</td><td>5</td><td>1</td><td>1</td><td>1</td><td></td></tr><tr><td>Training KFPS</td><td>4.2</td><td>3.4</td><td>3.0</td><td>4.9</td><td>10.6</td><td>11.5</td><td>11.0</td><td>42.7</td><td>1sssst</td></tr><tr><td>UPS</td><td>7.0</td><td>28.3</td><td>24.7</td><td>4.1</td><td>1.8</td><td>9.6</td><td>9.1</td><td>8.9</td><td></td></tr><tr><td>Time [mins]</td><td>20.2 5.0</td><td></td><td>42.6</td><td>44.2</td><td>18.8</td><td>9.4</td><td>9.9</td><td>7.9</td><td></td></tr><tr><td>Training Mframes (for average score: 800)</td><td></td><td></td><td>7.5</td><td>13.0</td><td>12.0</td><td>6.5</td><td>6.5</td><td>18.0</td><td></td></tr><tr><td>Training KFPS</td><td>4.3</td><td>3.3</td><td>3.0</td><td>4.9</td><td>11.9</td><td>12.5</td><td>12.1</td><td>46.6</td><td>XAestt</td></tr><tr><td>UPS</td><td>7.1</td><td>27.9</td><td>24.8</td><td>4.1</td><td>2.0</td><td>10.4</td><td>10.0</td><td>9.7</td><td></td></tr><tr><td>Time [mins]</td><td>8.1 2.0</td><td>35.2 7.0</td><td>14.4</td><td>27.1</td><td>一</td><td>14.0</td><td>3.4</td><td>2.5</td><td></td></tr><tr><td>Training Mframes (for average score: 1,000)</td><td></td><td></td><td>2.5</td><td>8.0</td><td>1</td><td>10.5</td><td>2.5</td><td>7.0</td><td></td></tr><tr><td>Training KFPS</td><td>4.0</td><td>3.3</td><td>2.8</td><td>4.8</td><td>9.0</td><td>9.6</td><td>9.2</td><td>35.5</td><td></td></tr><tr><td>UPS</td><td>6.7</td><td>27.1</td><td>23.7</td><td>4.0</td><td>1.5</td><td>8.0</td><td>7.7</td><td>7.4</td><td>Waeraa</td></tr><tr><td>Time [mins]</td><td>16.6 4.0</td><td>20.5 4.0</td><td>14.7 2.5</td><td>12.4 3.5</td><td>/</td><td>6.9 4.0</td><td>11.8 6.5</td><td>2.4</td><td></td></tr><tr><td>Training Mframes (for average score: 1,500)</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>3.0</td><td></td></tr><tr><td>Training KFPS</td><td>4.3</td><td>3.4</td><td>3.0</td><td>4.8</td><td>10.5</td><td>11.2</td><td>10.6</td><td>41.7K</td><td></td></tr><tr><td>UPS</td><td>7.2</td><td>28.1</td><td>24.9</td><td>4.0</td><td>1.8</td><td>9.3</td><td>8.9</td><td>8.7</td><td></td></tr><tr><td>Time [mins]</td><td>21.2</td><td>12.2</td><td>8.4</td><td>8.7</td><td>1</td><td>5.9</td><td>3.1</td><td>2.4</td><td></td></tr><tr><td>Training Mframes (for average score:18)</td><td>5.5</td><td>2.5</td><td>1.5</td><td>2.5</td><td>1</td><td>4.0</td><td>2.0</td><td>6.0</td><td></td></tr></table>",
+        "bbox": [
+            173,
+            165,
+            825,
+            417
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figs. 3(a)-3(b) show the FPS generated by OpenAI Gym, $\\mathrm { C u L E _ { C P U } }$ , and CuLE, on the entire set of Atari games, as a function of the number of environments. In the emulation only case, CPU emulation is more efficient for a number of environments up to 128, when the GPU computational power is not leveraged because of the low occupancy. For a larger number of environments, CuLE significantly overcomes OpenAI Gym, for which FPS are mostly stable for 64 environments or more, indicating that the CPU is saturated: the ratio between the median FPS generated by CuLE with 4096 environment (64K) and the peak FPS for OpenAI Gym (18K) is $3 . 5 6 \\times$ . In the inference only case there are two additional overheads: CPU-GPU communication (to transfer observations), and DNN inference on the GPU. Consequently, CPU emulators achieve a lower FPS in inference only when compared to emulation only; the effects of the overheads is more evident for a small number of environments, while the FPS slightly increase with the number of environments without reaching the emulation only FPS. CuLE’s FPS are also lower for inference only, because of the latency introduced by DNN inference, but the FPS grow with the number of environments, suggesting that the computational capability of the GPU is still far from being saturated. ",
+        "bbox": [
+            173,
+            445,
+            825,
+            641
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/d2b7c56ff3eacb743c7e3e23f2ff4ffb98e21dd9826febc95bb042b9737b245d.jpg",
+        "image_caption": [
+            "Figure 4: FPS as a function of the environment step, measured on System I in Table 2 for emulation only on four Atari games, 512 environments, for CuLE; each panel also shows the number of resetting environments. FPS is higher at the beginning, when all environments are in similar states and thread divergence within warps is minimized; after some steps, correlation is lost, FPS decreases and stabilizes. Minor oscillations in FPS are possibly associated to more or less computational demanding phases in the emulation of the environments (e.g., when a goal is scored in Pong). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            679,
+            813,
+            758
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Factors affecting the FPS Figs. 3(a)-3(b) shows that the throughput varies dramatically across games: 4096 CuLECPU environments run at 27K FPS on Riverraid, but only 14K FPS for Boxing: a ",
+        "bbox": [
+            171,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$1 . 9 3 \\times$ difference, explained by the different complexity of the ROM code of each game. The ratio between the maximum and minimum FPS is amplified in the case of GPU emulation: Riverraid runs in emulation only at 155K FPS when emulated by CuLE and 4096 environments, while UpNDown runs at 41K FPS —a $3 . 7 8 \\times$ ratio. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To better highlight the impact of thread divergence on throughput, we measure the FPS for CuLE, emulation only, 512 environments, and four games (Fig. 4). All the environments share the same initial state, but random action selection leads them to diverge after some steps. Each environment resets at the end of an episode. The FPS is maximum at the very beginning, when all the environments are in similar states and the chance to execute the same instruction in all the threads is high. When they move towards different states, code divergence negatively impacts the FPS, until it reaches an asymptotic value. This effect is present in all games and particularly evident for MsPacman in Fig. 4; it is not present in CPU emulation (see Appendix). Although divergence can reduce FPS by $3 0 \\%$ in the worst case, this has to be compared with case of complete divergence within each thread and for each instruction, which would yield $1 / 3 2 \\simeq 3 \\%$ of the peak performances. Minor oscillations of the FPS are also visible especially for games with a repetitive pattern (e.g. Pong), where different environments can be more or less correlated with a typical oscillation frequency. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            333
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Performances during training Fig. 5 compares the FPS generated by different emulation engines on a specific game (Assault)2, for different load conditions, including the training case, and number of environments. As expected, when the entire training path is at work, the FPS decreases even further. However, for CPU emulators, the difference between FPS in the inference only and training cases decreases when the number of environments increases, as the system is bounded by the CPU computational capability and CPU-GPU communication bandwidth. In the case of the CPU scaling to multiple GPUs would be ineffective for on-policy algorithms, such GA3C Babaeizadeh et al. (2016; 2017), or sub-optimal, in the case of distributed systems Espeholt et al. (2018); Stooke & Abbeel (2018b). On the other hand, the difference between inference only and training FPS increases with the number of environments for CuLE, because of the additional training overhead on the GPU. The potential speed-up provided by CuLE for vanilla A2C and Assault in Fig. 5 is $2 . 5 3 \\times$ for 1,024 environments, but the system is bounded by the GPU computational power; as a consequence, better batching strategies that reduce the training computational overhead as well as scaling to multiple GPUs are effective to further increase the speed-up ratio, as demonstrated later in this Section. ",
+        "bbox": [
+            174,
+            349,
+            516,
+            598
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3c5538b6112ee87bb0aa7e36a680921fa4e1b85131c89f78d3d477becb1b34a6.jpg",
+        "image_caption": [
+            "Figure 5: FPS generated by different emulation engines on System I in Table 2 for Assault, as a function of the number of environments, and different load conditions for A2C with N-step bootstrapping, $N = 5$ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            531,
+            371,
+            823,
+            501
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            598,
+            825,
+            667
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "When data generation and training can be decoupled, like for off-policy algorithms, training can be easily moved to a different GPU and the inference path can be used at maximum speed. The potential speed-up provided by CuLE for off-policy algorithms is then given by the ratio between the inference only median FPS for CuLE (56K) and CuLECPU (18K), which is $3 . 1 1 \\times$ for 4,096 environments. Furthermore, since the FPS remains flat for CPU emulation, the advantage of CuLE amplifies (for both on- and off-policy methods) with the number of environments. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            758
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Frames per second per environment Fig. 3(c)-3(d) show the FPS / environment for different emulation engines on System I, as a function of the number of environments. For 128 environments or fewer, CPU emulators generate frames at a higher rate (compared to CuLE), because CPUs are optimized for low latency, and execute a high number of instructions per second per thread. However, the FPS / environment decrease with the number of environments, that have to share the same CPU cores. Instead, the GPU architecture maximizes the throughput and has a lower number of instructions per second per thread. As a consequence, the FPS / environment is smaller (compared to CPU emulation) for a small number of environments, but they are almost constant up to 512 environments, and starts decreasing only after this point. In practice, CuLE environments provide an efficient means of training with a diverse set of data and collect large statistics about the rewards experienced by numerous agents, and consequently lowering the variance of the value estimate. On the other hand, samples are collected less efficiently in the temporal domain, which may worsen the bias on the estimate of the value function by preventing the use of large N in N-step bootstrapping. The last paragraph of this Section shows how to leverage the high throughput generated by CuLE, considering these peculiarities. ",
+        "bbox": [
+            173,
+            773,
+            825,
+            898
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Memory limitations Emulating a massively large number of environments can be problematic considering the relatively small amount of GPU DRAM. Our PyTorch Paszke et al. (2017) implementation of A2C requires each environment to store $4 8 4 \\mathrm { x } 8 4$ frames, plus some additional variables for the emulator state. For 16K environments this translates into 1GB of memory, but the primary issue is the combined memory pressure to store the DNN with 4M parameters and the meta-data during training, including the past states: training with 16K environments easily exhausts the DRAM on a single GPU (while training on multiple GPUs increases the amount of available RAM). Since we did not implement any data compression scheme as in Horgan et al. (2018), we constrain our training configuration to fewer than 5K environments, but peak performance in terms of FPS would be achieved for a higher number of environments - this is left as a possible future improvement. ",
+        "bbox": [
+            174,
+            204,
+            825,
+            343
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A2C We analyze in detail the case of A2C with CuLE on a single GPU. As a baseline, we consider vanilla A2C, using 120 OpenAI Gym CPU environments that send training data to the GPU to update the DNN (Fig. 6(a)) every $N = 5$ steps. This configuration takes, on average, 21.2 minutes (and $5 . 5  { \\mathrm { M } }$ training frames) to reach a score of 18 for Pong and 16.6 minutes (4.0M training frames) for a score of 1,500 on Ms-Pacman (Fig. 7, red line; first column of Table 3). CuLE with 1,200 environments generates approximately $2 . 5 \\times$ more FPS compared to OpenAI Gym, but this alone is not sufficient to improve the convergence speed (blue line, Fig. 7). CuLE generates larger batches but, because FPS / environment is lower when compared to CPU emulation, fewer Updates Per Second (UPS) are performed for training the DNN (Table 3), which is detrimental for learning. ",
+        "bbox": [
+            173,
+            358,
+            825,
+            484
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { A 2 C + V } .$ -trace and batching strategy To better leverage CuLE, and similar in spirit to the approach in IMPALA Espeholt et al. (2018), we employ a different batching strategy, illustrated in Fig. 6(b): environment steps occur in parallel on the GPU, but training data are read in batches to update the DNN every Steps Per Update (SPU) steps. This batching strategy significantly increases the DNN’s UPS at the cost of a slight decrease in FPS (second columns of OpenAI Gym and CuLE in Table 3), due to the fact that the GPU has to dedicate more time to training. Furthermore, as only the most recent data in a batch are generated with the current policy, we use V-trace Espeholt et al. (2018) for off-policy correction. The net result is an increase of the overall training time when 120 ",
+        "bbox": [
+            174,
+            522,
+            483,
+            757
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/38a3faa977d18863aef8187ad152e7cb6433535d7f1060fcbe0a2d6923ce4c17.jpg",
+        "image_caption": [
+            "Figure 6: Different batching strategies are defined by the number of batches, N-Steps and Steps Per Update (SPU) parameters. The on-policy single batch case (panel a) is a special case of the more general, off-policy multi batch approach (panel b). The batching strategy affects both the computational and convergence aspects of the DRL algorithm, as shown in Fig. 7 and in Table 3. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            504,
+            513,
+            808,
+            601
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "OpenAI Gym CPU environments are used, as this configuration pays for the increased training and communication overhead, while the smaller batch size increases the variance in the estimate of the value function and leads to noisy DNN updates (second column in Table 3, orange lines in Fig. 7). Since CuLE does not suffer from the same computational bottlenecks, and at the same time benefits from the variance reduction associated with the large number (1,200) of environments, using the same batching strategy with CuLE reduces the time to reach a score of 18 for Pong and 1,500 for Pacman respectively to 5.9 and 6.9 minutes. The number of frames required to reach the same score is sometimes higher for CuLE (Table 3), which can lead to less sample efficient implementation when compared to the baseline, but the higher FPS largely compensates for this. Extending the batch size in the temporal dimension (N-steps bootstrapping, $N = 2 0$ ) increases the GPU computational load and reduces both the FPS and UPS, but it also reduces the bias in the estimate of the value function, making each DNN update more effective, and leads to an overall decrease of the wall clock training time, the fastest convergence being achieved by CuLE with 1,200 environments. Using OpenAI Gym with the same configuration results in a longer training time, because of the lower FPS generated by CPU emulation. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/dd2dbc43dfa9bda856eb75060f513594e44e6ae5fa16bb24248ea97e58ed6195.jpg",
+        "image_caption": [
+            "Figure 7: Average testing score and standard deviation on four Atari games as a function of the training time, for $\\mathrm { { A 2 C + V } } .$ -trace, System III in Table 2, and different batching strategies (see also Table 3). Training frames are double for the multi-GPU case (black line). Training performed on CuLE or OpenAI Gym; testing performed on OpenAI Gym environments (see the last paragraph of Section 4). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            176,
+            601,
+            405
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Scaling to multiple GPUs The black line in Fig. 7 represents the case of $\\mathrm { A 2 C + V } .$ - Trace with CuLE and 4 GPUs, each emulating 1,200 environments. The FPS grow almost linearly with the number of GPUs under this training load: CuLE running on 4 GPUs allows generating and consuming a comparable number of FPS with respect to IMPALA on a large CPU cluster (Table 1)). This leads to a dramatic reduction of the convergence time, as documented in Table 3, with Pong almost solved in less than 3 minutes. ",
+        "bbox": [
+            630,
+            164,
+            823,
+            426
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Beyond $\\mathrm { { A 2 C + V } } .$ -trace, we report in Table 4 the time to generate 200M frames for PPO and Rainbow DQN by running CuLE on 1 to 8 GPUs on a single system. We ",
+        "bbox": [
+            630,
+            435,
+            823,
+            517
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "use the PyTorch multiprocessing facilities to launch 1 process for each GPU and update gradients in a distributed manner using the NVIDIA NCCL multi-GPU communication backend. This Table shows efficient scaling of the training FPS with the number of GPUs. As in the case of $\\mathrm { A 2 C + V } .$ - trace, an efficient batching strategy is then required to fully leverage the high throughput generated by CuLE and can significantly improve these figures. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Generalization for different systems Table 5 reports the FPS for the implementations of vanilla DQN, A2C, and PPO, on System I and II in Table 2. The speed-up in terms of FPS provided by CuLE is consistent across different systems, different algorithms, and larger in percentage for a large number of environments. Different DRL algorithms achieve different FPS depending on the complexity and frequency of the training step on the GPU. ",
+        "bbox": [
+            174,
+            606,
+            450,
+            758
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/85240f6c550a5a123747270613b2ed771d8a88acb57c4abdca8994de1d0ae686.jpg",
+        "table_caption": [
+            "Table 4: Hours to complete 50M training frames (200M raw frames) on System III in Table 2, by GPU count, for two different DRL algorithms, 2,048 environments per GPU. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Alg0</td><td>1 GPU</td><td>2 GPUs</td><td>4 GPUs</td><td>8 GPUs</td></tr><tr><td>PPO</td><td>9.38</td><td>4.45</td><td>2.12</td><td>1.1</td></tr><tr><td>Rainbow DQN</td><td>10.5</td><td>5.1</td><td>3.2</td><td>2.1</td></tr></table>",
+        "bbox": [
+            465,
+            690,
+            831,
+            744
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The same Table also reports the minimum and maximum GPU utilization measured while running each DRL algorithm. In its vanilla implementation DQN is characterized by long GPU idle times occurring during CPU emulation, leading to a low GPU utilization. The GPU utilization increases when emulation is moved to the GPU, while GPU peak utilization is reached during the DNN training step. GPU underutilization can be observed also for policy-gradient algorithms (A2C, PPO) and CPU emulation; peak utilization is higher for PPO, because of its larger computational complexity. Nearly full GPU utilization is achieved only by CuLE for a large number of environments. ",
+        "bbox": [
+            174,
+            766,
+            825,
+            863
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Correctness of the implementation To guarantee that CuLE is compliant with OpenAI Gym, we seed OpenAI Gym and CuLE environments with the same game state and successfully verify that the sequence of game states and frames returned by each environment are equivalent. A more subtle question to answer is if the CuLE reset procedure, based on a set of random initial states, can reduce the variability in the environments and consequently be detrimental for the learning and generalization capability of the trained agents. Our code ([URL revealed upon acceptance]) allows the user to test the training agent on CuLE, CuLECPU, and OpenAI Gym environments: in our tests the results are comparable for the three backends. Results reported in Fig. 7 and in the Appendix further suggest that CuLE trained agents do not suffer any performance loss when tested on OpenAI Gym environments. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/22da880529ff1c634a289586afe4b540f2005736a1ada688d5231303f38ff6af.jpg",
+        "table_caption": [
+            "Table 5: Average FPS and min/max GPU utilization during training for Pong with different algorithms and using different emulation engines on different systems (see Table 2); CuLE consistently leads to higher FPS and GPU utilization. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Algorithm</td><td rowspan=\"2\">Emulation engine</td><td colspan=\"4\">FPS [GPU utilization %]</td></tr><tr><td>System I[256 envs]</td><td>System I[1024 envs]</td><td>System II [256 envs]</td><td>System II [1024 envs]</td></tr><tr><td rowspan=\"3\">DQN</td><td>OpenAI</td><td>6.4K[15-42%]</td><td>8.4K [0-69%]</td><td>10.8K[26-32%]</td><td>21.2K [28-75%]</td></tr><tr><td>CuLEcPU</td><td>7.2K[16-43%]</td><td>8.6K[0-72%]</td><td>6.8K[17-25%]</td><td>20.8K [8-21%]</td></tr><tr><td>CuLE</td><td>14.4K [16-99%]</td><td>25.6K[17-99%]</td><td>11.2K [48-62%]</td><td>33.2K [57-77%]</td></tr><tr><td rowspan=\"3\">A2C</td><td>OpenAI</td><td>12.8K [2-15%]</td><td>15.2K [0-43%]</td><td>24.4K [5-23%]</td><td>30.4K [3-45%]</td></tr><tr><td>CuLEcPU</td><td>10.4K[2-15%]</td><td>14.2K [0-43%]</td><td>12.8K [1-18%]</td><td>25.6K[3-47%]</td></tr><tr><td>CuLE</td><td>19.6K [97-98%]</td><td>51K [98-100%]</td><td>23.2K [97-98%]</td><td>48.0K[98-99%]</td></tr><tr><td rowspan=\"3\">PPO</td><td>OpenAI</td><td>12K[3-99%]</td><td>10.6K [0-96%]</td><td>16.0K [4-33%]</td><td>19.2K [4-62%]</td></tr><tr><td>CuLEcPU</td><td>10K[2-99%]</td><td>10.2K [0-96%]</td><td>9.2K[2-28%]</td><td>18.4K [3-61%]</td></tr><tr><td>CuLE</td><td>14K [95-99%]</td><td>36K[95-100%]</td><td>14.4K [43-98%]</td><td>28.0K[45-99%]</td></tr></table>",
+        "bbox": [
+            173,
+            155,
+            810,
+            294
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            319,
+            825,
+            417
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION AND CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            439,
+            467,
+            455
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The common allocation of the tasks in a DRL system dictates that the environment should run on CPUs, whereas GPUs should be dedicated to DNN operations. With most of the existing frameworks Brockman et al. (2016); Mirowski et al. (2016); Tassa et al. (2018); Tian et al. (2017) following this paradigm, the limited CPU-GPU communication bandwidth and CPU capability to emulate a large number of environments represent two limiting factors to effectively accelerate DRL algorithms, even when mapped to expensive distributed systems. By rendering frames directly on the GPU, CuLE overcomes these limitations and generate as many FPS as those generated by large, expensive CPU systems. CuLE promises to be an effective tool to develop and test DRL algorithms by significantly reducing the experiment turnaround time. ",
+        "bbox": [
+            173,
+            492,
+            825,
+            618
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As already shown by others in the case of DRL on distributed system, our experiments show that proper batching coupled with a slight off-policy gradient policy algorithm can significantly accelerate the wall clock convergence time; CuLE has the additional advantage of allowing effective scaling of this implementation to a system with multiple GPUs. CuLE effectively allows increasing the number of parallel environments but, because of the low number of instructions per second per thread on the GPU, training data can be narrow in the time direction. This can be problematic for problems with sparse temporal rewards, but rather than considering this as a pure limitation of CuLE, we believe that this peculiarity opens the door to new interesting research questions, like active sampling of important states Hessel et al. (2017); Wang et al. (2015) that can then be effectively analyzed on a large number of parallel environments with CuLE. CuLE also hits a new obstacle, which is the limited amount of DRAM available on the GPU; studying new compression schemes, like the one proposed in Hessel et al. (2017), as well as training methods with smaller memory footprints may help extend the utility of CuLE to even larger environment counts, and design better GPU-based simulator for RL in the future. Since these are only two of the possible research directions for which CuLE is an effective investigation instrument, CuLE comes with a python interface that allows easy experimentation and is freely available to any researcher at [URL revealed upon acceptance]. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A last note has to be done on CuLE’s implementation, that is informed by ease of debugging, need for flexibility, and compatibility with standard DRL benchmarks. These choices put a limit on the achievable speed up factor (for instance by using emulation of the Atari 2600 console instead of direct CUDA implementations of Atari games), but the analysis and insights provided in our paper furnish indications for the design of efficient simulators for DRL. ",
+        "bbox": [
+            176,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Babaeizadeh, Iuri Frosio, Stephen Tyree, Jason Clemons, and Jan Kautz. GA3C: gpubased A3C for deep reinforcement learning. CoRR, abs/1611.06256, 2016. URL http:// arxiv.org/abs/1611.06256. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            167
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Babaeizadeh, Iuri Frosio, Stephen Tyree, Jason Clemons, and Jan Kautz. Reinforcement learning through asynchronous advantage actor-critic on a gpu. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            175,
+            821,
+            204
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "M. G. Bellemare, Y. Naddaf, J. Veness, and M. Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, jun 2013. ",
+        "bbox": [
+            169,
+            212,
+            825,
+            253
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marc G. Bellemare, Will Dabney, and Remi Munos. A distributional perspective on reinforcement ´ learning. CoRR, abs/1707.06887, 2017. URL http://arxiv.org/abs/1707.06887. ",
+        "bbox": [
+            173,
+            261,
+            825,
+            290
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016. ",
+        "bbox": [
+            173,
+            297,
+            823,
+            327
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alfredo V. Clemente, Humberto Nicolas Castej ´ on Mart ´ ´ınez, and Arjun Chandra. Efficient parallel methods for deep reinforcement learning. CoRR, abs/1705.04862, 2017. URL http://arxiv. org/abs/1705.04862. ",
+        "bbox": [
+            174,
+            333,
+            823,
+            376
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Volodymyr Mnih, Tom Ward, Yotam´ Doron, Vlad Firoiu, Tim Harley, Iain Dunning, Shane Legg, and Koray Kavukcuoglu. IMPALA: scalable distributed deep-rl with importance weighted actor-learner architectures. CoRR, abs/1802.01561, 2018. URL http://arxiv.org/abs/1802.01561. ",
+        "bbox": [
+            173,
+            383,
+            826,
+            440
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, Charles Blundell, and Shane Legg. ´ Noisy networks for exploration. CoRR, abs/1706.10295, 2017. URL http://arxiv.org/ abs/1706.10295. ",
+        "bbox": [
+            173,
+            448,
+            825,
+            503
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matteo Hessel, Joseph Modayil, Hado van Hasselt, Tom Schaul, Georg Ostrovski, Will Dabney, Daniel Horgan, Bilal Piot, Mohammad Gheshlaghi Azar, and David Silver. Rainbow: Combining improvements in deep reinforcement learning. CoRR, abs/1710.02298, 2017. URL http:// arxiv.org/abs/1710.02298. ",
+        "bbox": [
+            173,
+            511,
+            825,
+            568
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Horgan, John Quan, David Budden, Gabriel Barth-Maron, Matteo Hessel, Hado van Hasselt, and David Silver. Distributed prioritized experience replay. CoRR, abs/1803.00933, 2018. URL http://arxiv.org/abs/1803.00933. ",
+        "bbox": [
+            173,
+            575,
+            823,
+            618
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016. ",
+        "bbox": [
+            173,
+            626,
+            823,
+            667
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Timothy P. Lillicrap, Jonathan J. Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. CoRR, abs/1509.02971, 2015. URL http://arxiv.org/abs/1509.02971. ",
+        "bbox": [
+            173,
+            675,
+            823,
+            719
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marlos C. Machado, Marc G. Bellemare, Erik Talvitie, Joel Veness, Matthew J. Hausknecht, and Michael Bowling. Revisiting the arcade learning environment: Evaluation protocols and open problems for general agents. CoRR, abs/1709.06009, 2017. ",
+        "bbox": [
+            173,
+            726,
+            825,
+            768
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Piotr Mirowski, Razvan Pascanu, Fabio Viola, Hubert Soyer, Andrew J. Ballard, Andrea Banino, Misha Denil, Ross Goroshin, Laurent Sifre, Koray Kavukcuoglu, Dharshan Kumaran, and Raia Hadsell. Learning to navigate in complex environments. CoRR, abs/1611.03673, 2016. URL http://arxiv.org/abs/1611.03673. ",
+        "bbox": [
+            173,
+            776,
+            823,
+            832
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, February 2015. ISSN 00280836. URL http://dx.doi.org/10.1038/nature14236. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In Maria Florina Balcan and Kilian Q. Weinberger (eds.), Proceedings of The 33rd International Conference on Machine Learning, volume 48 of Proceedings of Machine Learning Research, pp. 1928–1937, New York, New York, USA, 20–22 Jun 2016. PMLR. URL http: //proceedings.mlr.press/v48/mniha16.html. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Arun Nair, Praveen Srinivasan, Sam Blackwell, Cagdas Alcicek, Rory Fearon, Alessandro De Maria, Vedavyas Panneershelvam, Mustafa Suleyman, Charles Beattie, Stig Petersen, Shane Legg, Volodymyr Mnih, Koray Kavukcuoglu, and David Silver. Massively parallel methods for deep reinforcement learning. CoRR, abs/1507.04296, 2015. URL http://arxiv.org/abs/ 1507.04296. ",
+        "bbox": [
+            173,
+            200,
+            825,
+            270
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "OpenAI. Openai baselines: Acktr & a2c, 2017. URL https://blog.openai.com/ baselines-acktr-a2c/. ",
+        "bbox": [
+            173,
+            285,
+            821,
+            313
+        ],
+        "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. In NIPS-W, 2017. ",
+        "bbox": [
+            176,
+            327,
+            823,
+            369
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jing Peng and Ronald J. Williams. Incremental multi-step q-learning. Machine Learning, 22(1): 283–290, Mar 1996. ISSN 1573-0565. doi: 10.1007/BF00114731. URL https://doi.org/ 10.1007/BF00114731. ",
+        "bbox": [
+            173,
+            382,
+            825,
+            425
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. CoRR, abs/1511.05952, 2015. URL http://arxiv.org/abs/1511.05952. ",
+        "bbox": [
+            173,
+            439,
+            823,
+            468
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. CoRR, abs/1707.06347, 2017. URL http://arxiv.org/abs/ 1707.06347. ",
+        "bbox": [
+            173,
+            481,
+            825,
+            523
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adam Stooke and Pieter Abbeel. Accelerated methods for deep reinforcement learning. CoRR, abs/1803.02811, 2018a. URL http://arxiv.org/abs/1803.02811. ",
+        "bbox": [
+            173,
+            537,
+            823,
+            565
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adam Stooke and Pieter Abbeel. Accelerated methods for deep reinforcement learning. CoRR, abs/1803.02811, 2018b. URL http://arxiv.org/abs/1803.02811. ",
+        "bbox": [
+            169,
+            579,
+            823,
+            608
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard S. Sutton and Andrew G. Barto. Introduction to Reinforcement Learning. MIT Press, Cambridge, MA, USA, 1st edition, 1998. ISBN 0262193981. ",
+        "bbox": [
+            173,
+            621,
+            823,
+            650
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, Timothy P. Lillicrap, and Martin A. Riedmiller. Deepmind control suite. CoRR, abs/1801.00690, 2018. URL http: //arxiv.org/abs/1801.00690. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            719
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yuandong Tian, Qucheng Gong, Wenling Shang, Yuxin Wu, and Larry Zitnick. ELF: an extensive, lightweight and flexible research platform for real-time strategy games. CoRR, abs/1707.01067, 2017. URL http://arxiv.org/abs/1707.01067. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            776
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double qlearning. CoRR, abs/1509.06461, 2015. URL http://arxiv.org/abs/1509.06461. ",
+        "bbox": [
+            171,
+            789,
+            823,
+            818
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Nando de Freitas, and Marc Lanctot. Dueling network architectures for deep reinforcement learning. CoRR, abs/1511.06581, 2015. URL http://arxiv.org/abs/1511. 06581. ",
+        "bbox": [
+            173,
+            832,
+            825,
+            873
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992. ",
+        "bbox": [
+            174,
+            887,
+            823,
+            916
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 REINFORCEMENT LEARNING, A2C AND V-TRACE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            140,
+            563,
+            155
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning In RL, an agent observes a state $s _ { t }$ at time $t$ and follows a policy $\\pi =$ $\\pi ( s _ { t } )$ to select an action $a _ { t }$ ; the agent also receives a scalar reward $r _ { t }$ from the environment. The goal of RL is to optimize $\\pi$ such that the sum of the expected rewards is maximized. ",
+        "bbox": [
+            174,
+            170,
+            825,
+            212
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In model-free policy gradient methods $\\pi ( { a } _ { t } | s _ { t } ; \\theta )$ is the output of a policy DNN with weights $\\theta$ , and represents the probability of selecting action $a _ { t }$ in the state $s _ { t }$ . Updates to the DNN are generally aligned in the direction of the gradient of $E [ R _ { t } ]$ , where $\\begin{array} { r } { R _ { t } = \\sum _ { i = 0 } ^ { \\infty ^ { \\ast } } \\gamma ^ { i } r _ { t + i } } \\end{array}$ is the discounted reward from time $t$ , with discount factor $\\gamma \\in \\left( 0 , 1 \\right]$ (see also REINFORCE Williams (1992)) The vanilla implementation updates $\\theta$ along $\\nabla _ { \\theta } \\log \\pi ( a _ { t } | s _ { t } ; \\theta ) R _ { t }$ , which is an unbiased estimator of $\\nabla _ { \\boldsymbol { \\theta } } E [ R _ { t } ]$ . The training procedure can be improved by reducing the variance of the estimator by subtracting a learned baseline $b _ { t } ( s _ { t } )$ and using the gradient $\\nabla _ { \\theta } \\mathrm { { ~ \\bar { ~ } l o g ~ } } \\pi ( a _ { t } | s _ { t } ; \\theta ) [ R _ { t } ~ - ~ b _ { t } ( s _ { t } ) ]$ . One common baseline is the value function $V ^ { \\pi } \\bar { ( s _ { t } ) } = \\bar { E } [ R _ { t } | s _ { t } ]$ , which is the expected return for the policy $\\pi$ starting from $s _ { t }$ . The policy $\\pi$ and the baseline $b _ { t }$ can be viewed as actor and critic in an actor-critic architecture Sutton & Barto (1998). ",
+        "bbox": [
+            173,
+            218,
+            825,
+            358
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A2C A2C OpenAI (2017) is the synchronous version of A3C Mnih et al. (2016), a successful actor-critic algorithm, where a single DNN outputs a softmax layer for the policy $\\pi \\left( a _ { t } | s _ { t } ; \\theta \\right)$ , and a linear layer for $V \\left( s _ { t } ; \\theta \\right)$ . In A2C, multiple agents perform simultaneous steps on a set of parallel environments, while the DNN is updated every $t _ { m a x }$ actions using the experiences collected by all the agents in the last $t _ { m a x }$ steps. This means that the variance of the critic $V \\left( s _ { t } ; \\theta \\right)$ is reduced (at the price of an increase in the bias) by $N$ -step bootstrapping, with $N = t _ { m a x }$ . The cost function for the policy is then: ",
+        "bbox": [
+            173,
+            385,
+            825,
+            483
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2bbccb63f262cf0cc9ffd8a8d6ed11386aeeb8efbc69b6bc762b56b4a6d93d19.jpg",
+        "text": "$$\n\\begin{array} { r } { \\log \\pi \\left( a _ { t } | s _ { t } ; \\theta \\right) \\left[ \\tilde { R } _ { t } - V \\left( s _ { t } ; \\theta _ { t } \\right) \\right] + \\beta H \\left[ \\pi \\left( s _ { t } ; \\theta \\right) \\right] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            494,
+            668,
+            522
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where discou $\\theta _ { t }$ are the DNN wed reward from ighto $\\theta$ timand $t$ , i $\\begin{array} { r } { \\tilde { R } _ { t } = \\sum _ { i = 0 } ^ { k - 1 } \\gamma ^ { i } r _ { t + i } + \\gamma ^ { k } V \\left( s _ { t + k } ; \\theta _ { t } \\right) } \\end{array}$ bootstrappedis an entropy $t$ $t + k$ $k$ $t _ { m a x }$ $H \\left[ \\pi \\left( \\boldsymbol { s } _ { t } ; \\boldsymbol { \\theta } \\right) \\right]$ term that favors exploration, weighted by the hyper-parameter $\\beta$ . The cost function for the estimated value function is: ",
+        "bbox": [
+            174,
+            540,
+            825,
+            599
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/59186d1564ae182de58743050164bdf0af2198963f8350b495bec437f033221a.jpg",
+        "text": "$$\n\\left[ \\tilde { R } _ { t } - V \\left( s _ { t } ; \\theta \\right) \\right] ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            609,
+            563,
+            640
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "which uses, again, the bootstrapped estimate $\\tilde { R } _ { t }$ . Gradients $\\nabla \\theta$ are collected from both of the cost functions; standard optimizers, such as Adam or RMSProp, can be used for optimization. ",
+        "bbox": [
+            173,
+            657,
+            823,
+            688
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "V-trace In the case where there is a large number of environments, such as in CuLE or IMPALA Espeholt et al. (2018), the synchronous nature of A2C become detrimental for the learning speed, as one should wait for all the environments to complete $t _ { m a x }$ steps before computing a single DNN update. Faster convergence is achieved (both in our paper and in Espeholt et al. (2018)) by desynchronizing data generation and DNN updates, which in practice means sampling a subset of experiences generated by the agents, and updating the policy using an approximate gradient, which makes the algorithm slightly off-policy. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            813
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "To correct for the off-policy nature of the data, that may lead to inefficiency or, even worse, instabilities, in the training process, V-trace is introduced in Espeholt et al. (2018). In summary, the aim of off-policy correction is to give less weight to experiences that have been generated with policy $\\mu$ , called the behaviour policy, when it differs from the target policy, $\\pi$ ; for a more principled explanation we remand the curios reader to Espeholt et al. (2018). ",
+        "bbox": [
+            174,
+            818,
+            825,
+            888
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For a set of experiences collected from time $t = t _ { 0 }$ to time $t = t _ { 0 } + N$ following some policy $\\mu$ , the $N$ -steps $\\mathrm { v } .$ -trace target for $V ( s _ { t _ { 0 } } ; \\theta )$ is defined as: ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/574cb1aec32cf61e869b644174f9d3144b031fdbc2689cffd8c7e23a3686c553.jpg",
+        "image_caption": [
+            "Figure 8: FPS as a function of the environment step, measured on System I in Table 2 for emulation only on four Atari games, 512 environments, for $\\mathrm { C u L E _ { C P U } }$ ; each panel also shows the number of resetting environments. A peak in the FPS at the beginning of the emulation period, as in the case of GPU emulation in Fig. 4, is not visible in this case. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            289,
+            106,
+            692,
+            303
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f8569f1d97f8cb3fc44cd34cd874ee44d208a63ce13dcaf45799e02594208bcc.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { v _ { t _ { 0 } } } } & { { = } } & { { V ( s _ { t _ { 0 } } ; \\theta ) + \\sum _ { t = t _ { 0 } } ^ { t _ { 0 } + N - 1 } \\gamma ^ { t - t _ { 0 } } \\Bigl ( \\prod _ { i = t _ { 0 } } ^ { t - 1 } c _ { i } \\Bigr ) \\delta _ { t } V , } } \\\\ { { \\delta _ { t } V } } & { { = } } & { { \\rho _ { t } \\bigl ( r _ { t } + \\gamma V ( s _ { t + 1 } ; \\theta ) - V ( s _ { t } ; \\theta ) \\bigr ) } } \\\\ { { \\rho _ { t } } } & { { = } } & { { \\operatorname* { m i n } \\bigl ( \\bar { \\rho } , \\frac { \\pi \\bigl ( a _ { t } | s _ { t } \\bigr ) } { \\mu \\bigl ( a _ { t } | s _ { t } \\bigr ) } \\bigr ) } } \\\\ { { c _ { i } } } & { { = } } & { { \\operatorname* { m i n } \\bigl ( \\bar { c } , \\frac { \\pi \\bigl ( a _ { i } | s _ { i } \\bigr ) } { \\mu \\bigl ( a _ { i } | s _ { i } \\bigr ) } \\bigr ) ; } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            412,
+            684,
+            534
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "$\\rho _ { t }$ and $c _ { i }$ are truncated importance sampling (IS) weights, and $\\textstyle \\prod _ { i = t 0 } ^ { t - 1 } c _ { i } = 1$ for $s = t$ , and $\\bar { \\rho } \\geq$ c¯. Notice that, when we adopt the proposed multi-batching strategy, there are multiple behaviour policies $\\mu$ that have been followed to generate the training data — e.g., $_ \\mathrm { N }$ different policies are used when $\\mathrm { S P U } { = } 1$ in Fig. 6(b). Eqs. 5-6 do not need to be changed in this case, but we have to store all the $\\mu ( a _ { i } | s _ { i } )$ in the training buffer to compute the, $\\mathrm { V } .$ -trace corrected, DNN update. In our implementation, we compute the V-trace update recursively as: ",
+        "bbox": [
+            173,
+            546,
+            825,
+            633
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/84f1116a106a201f4c66a85387bd24195262ee1fb680dd2fb116942ca00c268d.jpg",
+        "text": "$$\nv _ { t } = V ( s _ { t } ; \\theta ) + \\delta _ { t } V + \\gamma c _ { s } \\bigl ( v _ { t + 1 } - V ( s _ { t + 1 } ; \\theta ) \\bigr ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            640,
+            661,
+            660
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "At training time $t$ , we update $\\theta$ with respect to the value output, $v _ { s }$ , given by: ",
+        "bbox": [
+            174,
+            674,
+            678,
+            689
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6712c5c98640f1a03654520b222c6eb4595a28b26aa557df916107dc2ed2f341.jpg",
+        "text": "$$\n\\bigl ( v _ { t } - V ( s _ { t } ; \\theta ) \\bigr ) \\nabla _ { \\theta } V ( s _ { t } ; \\theta ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            696,
+            591,
+            717
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "whereas the policy gradient is given by: ",
+        "bbox": [
+            176,
+            723,
+            434,
+            738
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e01828927d571999a1f9ed2ba6756d0b9b1dce92c873de5444c7f519770a7087.jpg",
+        "text": "$$\n\\begin{array} { r } { \\rho _ { t } \\nabla _ { \\omega } \\log \\pi _ { \\omega } ( a _ { s } | s _ { t } ) \\big ( r _ { t } + \\gamma v _ { t + 1 } - V ( s _ { t } ; \\theta ) \\big ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            746,
+            648,
+            765
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "An entropy regularization term that favors exploration and prevents premature convergence (as in Eq. 1) is also added. ",
+        "bbox": [
+            173,
+            772,
+            826,
+            801
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.2 THREAD DIVERGENCE IS NOT PRESENT IN THE CASE OF CPU EMULATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            840,
+            730,
+            856
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We show here that thread divergence, that affects GPU-based emulation (see Fig. 4), does not affect CPU-based emulation. Fig. 8 shows the FPS on four Atari games where all the environments share the same initial state. In constrast with GPU emulation, the CPU FPS do not peak at the beginning of the emulation period, where many environments are correlated. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For sake of space, we only report (Fig. 9) the FPS measured on system I in Table 2 for three additional games, as a function of different load conditions and number of environments. ",
+        "bbox": [
+            171,
+            128,
+            821,
+            159
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/c50ce8c6a2e7a2a93217492c801d7d5dd5426e0ca5072f7c8a8d90a8c19a1859.jpg",
+        "image_caption": [
+            "Figure 9: FPS generated by different emulation engines on System I in Table 2 for different Atari games, as a function of the number of environments, and different load conditions (the main A2C OpenAI (2017) loop is run here, with N-step bootstrapping, $N = 5$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            196,
+            803,
+            296
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.4 CORRECTNESS OF THE IMPLEMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            380,
+            503,
+            393
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the correctness of our implementation, and thus that policies learned with CuLE generalize to the same game emulated by OpenAI Gym, we report in Fig. 10 the average scores achieved in testing, while training an agent with with $\\mathrm { { A 2 C + V } } .$ -trace and CuLE. The testing scores measured on $\\mathrm { C u L E _ { C P U } }$ and OpenAI Gym environments do not show any relevant statistical difference, even for the case of Ms-Pacman, where the variability of the scores is higher because of the nature of the game. ",
+        "bbox": [
+            173,
+            405,
+            825,
+            489
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/e3221fe154bd92530f5e90843f67b93bbdd016709dec3c4c5326270e8b762e83.jpg",
+        "image_caption": [
+            "Figure 10: Average testing scores measured on $1 0 \\mathrm { C u L E } _ { \\mathrm { C P U } }$ and OpenAI Gym environments, while training with $\\mathrm { { A 2 C + V } } .$ -trace and CuLE, as a function of the training frames; 250 environments are used for Ms-Pacman, given its higher variability. The shaded area represents 2 standard deviations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            511,
+            797,
+            613
+        ],
+        "page_idx": 14
+    }
+]

parse/train/HJxkvlBtwH/HJxkvlBtwH.md

@@ -0,0 +1,498 @@
+# CERTIFYING NEURAL NETWORK AUDIO CLASSIFIERS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We present the first end-to-end verifier of audio classifiers. Compared to existing methods, our approach enables analysis of both, the entire audio processing stage as well as recurrent neural network architectures (e.g., LSTM). The audio processing is verified using novel convex relaxations tailored to feature extraction operations used in audio (e.g., Fast Fourier Transform) while recurrent architectures are certified via a novel binary relaxation for the recurrent unit update. We show the verifier scales to large networks while computing significantly tighter bounds than existing methods for common audio classification benchmarks: on the challenging Google Speech Commands dataset we certify $9 5 \%$ more inputs than the interval approximation (only prior scalable method), for a perturbation of -90dB.
+
+# 1 INTRODUCTION
+
+Recent advances in deep learning have enabled replacement of traditional voice recognition systems with a single neural network trained from data (Graves et al., 2013; Hannun et al., 2014; Amodei et al., 2016). Wide adoption of these networks in consumer devices poses a threat to their safety when exposed to a malicious adversary. Indeed, it was recently shown that an adversary can inject noise unrecognizable to a human and force the network to misclassify (Szegedy et al., 2013; Goodfellow et al., 2014; Zhang et al., 2017; Carlini & Wagner, 2018; Carlini et al., 2016; Qin et al., 2019; Neekhara et al., 2019; Yang et al., 2019; Esmaeilpour et al., 2019), exposing a serious security flaw.
+
+Ideally, when deploying an automated speech recognition system we would like to guarantee that the system is robust against noise injected by an adversary. There has been substantial recent work on certifying robustness of computer vision models (Katz et al., 2017; Ehlers, 2017; Bunel et al., 2018; Ruan et al., 2018; Tjeng et al., 2019; Anderson et al., 2018; Wong et al., 2018; Dvijotham et al., 2018; Raghunathan et al., 2018; Dvijotham et al., 2019; Weng et al., 2018; Zhang et al., 2018; Salman et al., 2019; Gehr et al., 2018; Singh et al., 2018; 2019a; Wang et al., 2018; Singh et al., 2019b). However, the audio domain poses unique challenges not addressed by prior certification work for vision.
+
+Differences between audio and vision models Concretely, while an input to a vision model is a raw image, audio models typically come with a complex preprocessing stage (that involves non-trivial non-linear operations such as logarithm) which extracts relevant features from the signal. Additionally, audio systems typically use recurrent architectures (Chiu et al., 2017) which computer vision verifiers do not handle as they focus on fully-connected, convolutional and residual architectures.
+
+This work We address both of these challenges and propose an end-to-end verification method for neural network based audio classifiers and an implementation of this method in a system called DAC (Deep Audio Certifier). Our threat model assumes an attacker can introduce a noise-based perturbation to the raw audio input signal. The goal then is to certify that, for any signal that the attacker can produce, the neural network classifies the signal to the correct label. We perform verification of this property using the framework of abstract interpretation (Gehr et al., 2018). At a high level, the idea is to maintain an abstraction capturing all possible behaviors of both the audio processing stage and the neural network. The flow of DAC is shown in Fig. 1 where all abstractions are dark blue shapes.
+
+![](images/3e67f30d8b6abd76ed64c80d26de44ec490d8ab5b9dcd404f3443463b1fa573f.jpg)  
+Figure 1: End-to-End Audio Certification Flow using DAC.
+
+Here, all possible signals an attacker can obtain are captured using an abstraction $\mathbf { \boldsymbol { s } } ^ { ( i ) }$ (a convex relaxation). This abstraction is then propagated through the audio processing stage (shown in green boxes). The key components of this step are abstract transformers. For each audio processing operation (e.g. FFT) we create an abstract transformer which receives an abstraction representing an approximation of all possible inputs to the operation and outputs a new abstraction which approximates all possible outputs of the operation. The result of the audio processing stage is the abstraction $\pmb { x } ^ { ( i ) }$ .
+
+The shape $\mathbf { \boldsymbol { x } } ^ { ( i ) }$ is then used as input to the recurrent LSTM unit (light blue) which maintains an abstraction of a hidden state $\pmb { h } ^ { ( i - \bar { 1 } ) }$ . LSTM consists of multiple operations and we create a custom abstract transformer for each of those. The result of the transformers in LSTM is a new hidden state $\mathbf { \Sigma } _ { h } ( i )$ . If this was the last frame in the signal (meaning $i = T$ ), then hidden state ${ \pmb h } ^ { ( T ) }$ is passed through the fully connected layer of the neural network and, again using the abstract transformer, the final abstract shape $^ { a }$ is obtained at the output (at the right of Fig. 1). Finally, to certify the property we check if each concrete output in the abstraction $\textbf { \em a }$ classifies to the correct label (this is typically easy). If this is true, the output of the network is correct for all inputs that the attacker can create.
+
+Related work on RNN certification The work of (Ko et al., 2019) proposes the POPQORN verifier for recurrent neural networks (RNN). We note that POPQORN does not handle the audio preprocessing pipeline. Even though POPQORN cannot directly verify audio classifiers, their approximations for LSTM non-linearities can be integrated in DAC. This results in $\approx 2 0 0 \times$ slowdown with small decrease in the volume of the approximation. The massive slowdown makes their approximations unsuitable for certifying audio classifiers. In contrast, using our custom abstract transformers for LSTM non-linearities, DAC can precisely certify end-to-end robustness of challenging audio classifiers in few minutes.
+
+Our main contributions are:
+
+1. A novel and efficient method to certify robustness of neural network audio classifiers to noise-based perturbations. The method is based on new abstract transformers which handle non-linear operations used in both audio processing and recurrent architectures. 2. An implementation of both verification and provably robust training in a system called DAC. We evaluated DAC on common audio classification benchmarks, showing it scales to realistic networks and is far more precise $9 7 \%$ to $2 \%$ ) than the next best scalable method.
+
+# 2 BACKGROUND
+
+We first define a threat model that we work with and then present all operations that are part of the verification procedure, including audio processing (MFCC) and LSTM updates. We also discuss the type of verification method we employ.
+
+Threat model We follow the same attacker threat model as Carlini & Wagner (2018). The assumption is that the attacker can add noise $\pmb { \delta }$ to the original signal $\pmb { s }$ so to obtain a perturbed signal ${ \pmb s } ^ { \prime } = { \pmb s } + { \pmb \delta }$ . The measure of signal distortion are decibels (dB) defined as:
+
+$$
+d B ( \pmb { s } ) = \operatorname* { m a x } _ { i } 2 0 \cdot \log _ { 1 0 } ( \lvert \mathscr { s } _ { i } \rvert ) ; d B _ { s } ( \pmb { \delta } ) = d B ( \pmb { \delta } ) - d B ( \pmb { s } )
+$$
+
+Note that the quieter the noise is, the smaller the decibel of perturbation $d B _ { s } ( \pmb { \delta } )$ (it is usually a negative value as it is quieter than the signal). We assume the attacker can generate noise $\delta$ such that $d B _ { s } ( \pmb { \delta } ) < \epsilon$ where $\epsilon$ is a constant defined by the threat model. Our goal is to verify whether the neural network classifies $s ^ { \prime }$ correctly for each small perturbation $\delta$ (as constrained above).
+
+Mel-Frequency Cepstral Coefficients (MFCC) Though there have been number of works which operate directly on the raw signal (Pascual et al., 2017; Sainath et al., 2015), Mel-Frequency Cepstrum (MFC) is traditionally preferred for audio preprocessing in speech recognition systems e.g., DeepSpeech (Hannun et al., 2014). The idea of MFC is to model non-linear human acoustic perception as power spectrum filters based on certain frequencies, called Mel-frequencies. The final result of the transformation is a vector of coefficients whose elements contain log-scaled values of filtered spectra, one for every Mel-frequency. This resulting vector is a feature representation of the original signal and can now be used in a downstream task such as audio classification.
+
+Sahidullah & Saha (2012) presented an approach to represent MFCC computation using several matrix operations which we integrate with our verification framework. Given $T$ frames of audio signals of the length $N = 2 ^ { k }$ , represented as matrix $\pmb { S } = [ \pmb { s } ^ { ( 1 ) } \ \cdots \ \pmb { s } ^ { ( T ) } ] ^ { t r } \in \mathbb { R } ^ { T \times N }$ ( $_ { t r }$ for transpose), audio preprocessing with MFCC is calculated using the following steps:
+
+1. Pre-emphasizing and Windowing: $Y = S ( I _ { N } - c _ { p e } I _ { N } ^ { + 1 } ) \odot H$ Transform the signal with the pre-emphasizing and applying the Hamming window. Here, $I _ { N } ^ { + 1 } \in \mathbb { R } ^ { N \times N }$ is the shifted diagonal identity matrix $\dot { \langle I _ { i , j } ^ { \mp 1 } = 1 }$ if $i + 1 = j$ , otherwise 0), $\pmb { H } \in \mathbb { R } ^ { T \times N }$ is the Hamming window, and $c _ { p e }$ is the pre-emphasizing constant.   
+2. Power Spectrum of Fast Fourier Transform (FFT): $\Theta = \left( Y W \right) \odot \left( Y W \right)$ Perform FFT on the windowed data and square it to get the real-value spectrum. We can denote FFT on discrete domain (DFT) with the multiplication of $\mathbf { Y }$ and $\bar { W } \in \mathbb { C } ^ { N \times N / 2 }$ .   
+3. Filter Bank Log Energy: $\Psi = \log ( \Theta \Lambda )$ Apply the Mel frequency filter bank to the power spectrum and get the log value of them. $\bar { \mathbf { \Lambda } } \bar { \mathbf { \Lambda } } \in \bar { \mathbb { R } } ^ { N / 2 \times p }$ is the filter bank given the number of filters $p$ , and $\log$ is applied entry-wise.   
+4. DCT(Discrete Cosine Transformation): $X = \Psi D$ Perform DCT on the previous result. Again, this can be formulated using matrix multiplication. We use the resulting $\pmb { X } = [ \pmb { x } ^ { ( 1 ) } \cdots \pmb { x } ^ { ( T ) } ] ^ { t r }$ as the input for the neural network.
+
+Long-Short Term Memory (LSTM) LSTM architectures (Hochreiter & Schmidhuber, 1997) are a key part in modern state-of-the-art speech recognition systems (Hannun et al., 2014; Amodei et al., 2016). In our work, we consider the following definitions of updates in the LSTM unit.
+
+$$
+\begin{array} { r l r l } & { f _ { 0 } ^ { ( t ) } = [ { \pmb x } ^ { ( t ) } , h ^ { ( t - 1 ) } ] { \pmb W } _ { f } + b _ { f } \ } & & { o _ { 0 } ^ { ( t ) } = [ { \pmb x } ^ { ( t ) } , h ^ { ( t - 1 ) } ] { \pmb W } _ { o } + b _ { o } } \\ & { i _ { 0 } ^ { ( t ) } = [ { \pmb x } ^ { ( t ) } , h ^ { ( t - 1 ) } ] { \pmb W } _ { i } + b _ { i } \ } & & { \tilde { c } _ { 0 } ^ { ( t ) } = [ { \pmb x } ^ { ( t ) } , h ^ { ( t - 1 ) } ] { \pmb W } _ { \tilde { c } } + b _ { \tilde { c } } } \\ & { { \pmb c } ^ { ( t ) } = \sigma ( f _ { 0 } ^ { ( t ) } ) \odot { \pmb c } ^ { ( t - 1 ) } + \sigma ( i _ { 0 } ^ { ( t ) } ) \odot \mathrm { t a n h } ( \tilde { c } _ { 0 } ^ { ( t ) } ) \ } & & { h ^ { ( t ) } = \sigma ( o _ { 0 } ^ { ( t ) } ) \odot \mathrm { t a n h } ( { \pmb c } ^ { ( t ) } ) } \end{array}
+$$
+
+where $[ \cdot , \cdot ]$ is the horizontal concatenation two row vectors, $W .$ · and $^ { b }$ · are kernel and bias of the cell, respectively. At timestep $t$ , vectors $\pmb { f } _ { 0 } ^ { ( t ) } , i _ { 0 } ^ { ( t ) } , \pmb { o } _ { 0 } ^ { ( t ) } , \tilde { \pmb { c } } _ { 0 } ^ { ( t ) }$ represent pre-activations of the forget, input, and output gate, respectively, and the pre-calculation of cell state. Cell state $\mathbf { c } ^ { ( t ) }$ and hidden state $\mathbf { \delta } _ { h } ( t )$ computed at timestep $t$ are propagated to the LSTM unit at the next timestep, thus allowing it to maintain states. This recurrent architecture allows inputs with arbitrary length, making it especially suited for audio inputs.
+
+Robustness certification In this work, our goal will be to certify the robustness of an audio classification pipeline (including the LSTM) to noise perturbations of the input. To build such a verifier, we leverage the general method of abstract interpretation suggested by Cousot & Cousot (1977), successfully employed by some of the most recent state-of-the-art verifiers of neural networks (Gehr et al., 2018; Singh et al., 2019a). The basic idea here will be to propagate the possible perturbations (captured by a convex region) through the operations of the entire audio pipeline and to then use the final output region to certify the robustness property. The most challenging step of this approach is defining efficient yet precise approximations of the non-linear operations (called abstract transformers) used in the audio pipeline. In this work, we will introduce a number of such new abstract transformers that handle the non-linear operations used in audio processing. Specifically, our over-approximations will be expressed in the recent DEEPPOLY abstraction (Singh et al., 2019a) (a restricted form of convex polyhedra) which aims to balance efficiency and precision. That is, the abstract transformer of a non-linear function will take as input a convex polyhedra element expressible in DEEPPOLY and output another polyhedra which over-approximates the behavior of the non-linear operation when invoked with any concrete point inside the original polyhedra.
+
+# 3 OVERVIEW OF VERIFICATION PROCESS
+
+We now explain the workings of our verifier on a (toy) example from the point where sound enters the processing stage to where the output of the classifier is certified as robust under any allowed perturbation of the threat model. Our goal is to provide an intuitive understanding, formal details are provided later.
+
+Audio preprocessing Unlike in standard computer vision tasks where the input is fed directly to the neural network, audio models typically first perform MFCC preprocessing to extract useful features from the signal. We represent all preprocessing operations as green boxes in Fig. 2. The calculation follows steps described formally in Section 2, using the same notation for resulting vectors.
+
+![](images/6b7a943b6c2afcb4ad4b7c81061141f3ae1c0830a8775a0980eab7da45fd41a9.jpg)  
+Figure 2: Robustness verification illustrated on a toy example. Each box shows the constraints computed by the verifier after processing a given operation (shown on edges). Green color denotes elements of the MFCC audio processing stage: the Fast Fourier Transform (FFT), the Filterbank Transform (FB), and the Discrete Cosine Transform (DCT). Blue color denotes components of the network: ReLU layer, LSTM and Fully Connected layer. Approximations computed with this work are shown in the bottom row. The operations which the abstract transformers handle are shown next to the downward edges. Edges without labels represent affine transforms.
+
+Fast Fourier transform The first operation is Fast Fourier Transform (FFT) of the pre-emphasized input signal. It is a two-step process shown in dashed boxes in Fig. 2. We decompose it into affine and square operations which transform signal $\mathbf { \boldsymbol { s } } ^ { ( t ) }$ into an intermediate representation $\pmb \theta ^ { ( t ) }$ . Using our novel and optimal abstract transformer for the square operation, formally defined in Section 4 and visualized in Fig. 3b, we obtain linear bounds on $\mathbf { \bar { \theta } } _ { \theta ^ { ( t ) } }$ .
+
+Filterbank transform The next operation is Filterbank transform (FB) which consists of affine and logarithm operations, shown in solid boxes in Fig. 2. Note that if the approximations from the square transformer allows negative values, then the entire analysis will fail as the logarithm operation is undefined for negative inputs. Our transformers are carefully designed to avoid this scenario. To obtain bounds on the output of the logarithm we apply our novel and optimal logarithm transformer, also formally described in Section 4 and visualized in Fig. 3a, and obtain linear upper and lower bounds on the log energy of the filtered power spectrum, $\psi ^ { ( t ) }$ . Logarithm operation is followed by Discrete Cosine Transform (DCT) resulting in a vector $\tilde { \mathbf { \ b { x } } } ^ { ( t ) }$ which is then used as an input to the fully connected layer of the neural network followed by a ReLU. Our analysis (detailed calculation in Appendix C) produces $\tilde { \pmb { x } } _ { 1 } ^ { ( t ) } \in [ 0 . 8 7 , 5 . 5 6$ ], $\tilde { \mathbf { x } } _ { 2 } ^ { ( t ) } \in [ 0 . 1 7 , 1 2 . 8$ ]. Since all the values are positive, the following ReLU has no effect on its input and thus we set $\mathbf { \boldsymbol { x } } ^ { ( t ) } = \tilde { \mathbf { \boldsymbol { x } } } ^ { ( t ) }$ . Using the back-substitution technique we describe later, we derive $\bar { x _ { 1 } ^ { ( t ) } } \in [ 0 . 8 7 , 5 . 5 6 ]$ , $x _ { 2 } ^ { ( t ) } \in [ 0 . 1 7 , 1 2 . 8 3 ]$ . In the next paragraph we describe bound propagation through LSTM in more detail.
+
+LSTM bound propagation Here we provide a technical overview of our LSTM transformer, formalized in Section 5 and visualized in Fig. 4, by calculating the result of the transformation on the first neuron of the LSTM hidden layer. We provide detailed mathematical basis of this process in Appendix D. For our toy example, let the gates be updated as $f _ { 1 } ^ { ( t ) } = x _ { 1 } ^ { ( t ) } / 4$ , input gate $i _ { 1 } ^ { ( t ) } \stackrel { } { = } 2 h _ { 2 } ^ { ( t - 1 ) }$ output gate $o _ { 1 } ^ { ( t ) } = h _ { 1 } ^ { ( t - 1 ) }$ and cell state $\tilde { c } ^ { ( t ) } = h _ { 1 } ^ { ( t - 1 ) } - x _ { 2 } ^ { ( t ) } / 4$ 1 1 2. Also, assume the previous states are bounded by: $\bar { h _ { 1 } ^ { ( t - 1 ) } } , \bar { h _ { 2 } ^ { ( t - 1 ) } } , c _ { 1 } ^ { ( t - 1 ) } , c _ { 2 } ^ { ( t - 1 ) } \in [ \bar { 0 . 9 0 } , 1 . 0 0 ]$ . We now apply our $\sigma ( x ) \cdot \operatorname { t a n h } ( y )$ and $\sigma ( x ) \cdot y$ transformers to get bounds of the cell state $c _ { 1 } ^ { ( t ) } = \mathcal { \bar { \sigma } } ( f _ { 1 } ^ { ( t ) } ) \cdot c _ { 1 } ^ { ( t - 1 ) } + \sigma ( i _ { 1 } ^ { ( t ) } ) \cdot \operatorname { t a n h } ( \tilde { c } _ { 1 } ^ { ( t ) } )$ .
+
+$$
+\begin{array} { r l } & { 0 . 1 8 f _ { 1 } ^ { ( t ) } + 0 . 4 5 \le \sigma ( f _ { 1 } ^ { ( t ) } ) \cdot c _ { 1 } ^ { ( t - 1 ) } \le 0 . 1 6 f _ { 1 } ^ { ( t ) } + 0 . 5 8 } \\ & { 0 . 0 3 \tilde { c } _ { 1 } ^ { ( t ) } - 0 . 7 8 \le \sigma ( i _ { 1 } ^ { ( t ) } ) \cdot \operatorname { t a n h } ( \tilde { c } _ { 1 } ^ { ( t ) } ) \le 0 . 3 9 \tilde { c } _ { 1 } ^ { ( t ) } + 0 . 2 8 } \end{array}
+$$
+
+Summing up the inequalities above results in $c _ { 1 } ^ { ( t ) } \in [ - 0 . 3 6 , 1 . 4 6 ]$ . For the hidden state $h _ { 1 } ^ { ( t ) } =$ $\sigma ( o _ { 1 } ^ { ( t ) } ) \cdot \operatorname { t a n h } ( c _ { 1 } ^ { ( t ) } )$ , we again apply our abstract transformer and obtain
+
+$$
+0 . 4 8 c _ { 1 } ^ { ( t ) } - 0 . 0 8 \leq \sigma ( o _ { 1 } ^ { ( t ) } ) \cdot \operatorname { t a n h } ( c _ { 1 } ^ { ( t ) } ) \leq 0 . 1 4 c _ { 1 } ^ { ( t ) } + 0 . 4 5
+$$
+
+![](images/22078196fefc938e78b7a45663d0aa79766c898ea8c00c6f1f7c7e841938c2ac.jpg)  
+Figure 3: Our DeepPoly approximations of (a) the natural logarithm and (b) the square function. Blue lines represent the valid (in case of square, non-negative) upper and lower bounds which minimize the area between the planes under the given domain $[ l _ { x } , u _ { x } ]$ . The red bound on (b) grants smaller area, but contains the negative value, which occurs the analysis failure in the audio processing pipeline.
+
+i.e., $h _ { 1 } ^ { ( t ) } \in [ - 0 . 2 5 , 0 . 6 5 ]$ . An analogous computation is performed for $h _ { 2 } ^ { ( t ) }$ . For this example, we assume the computation results in $h _ { 2 } ^ { ( t ) } = 0$ .
+
+Robustness certification using DeepPoly The hidden states in the LSTM at the final timestep are passed through a fully connected layer without activation. In our example we assume that logits after the layer are obtained with the following formula: $l _ { 1 } = h _ { 1 } ^ { ( t ) } + 0 . 2 4$ and $l _ { 2 } = h _ { 2 } ^ { ( t ) }$ . These are shown in the final box of Fig. 2. To certify that the neural network classifies the input to class 1, we need to prove that $l _ { 1 } - l _ { 2 } > 0$ . We now apply the back-substitution technique as in Singh et al. (2019a) upto the input to the LSTM:
+
+$$
+\begin{array} { r l } & { l _ { 1 } - l _ { 2 } = h _ { 1 } ^ { ( t ) } - h _ { 2 } ^ { ( t ) } + 0 . 2 4 \geq 0 . 4 8 ( 0 . 1 8 f _ { 1 } ^ { ( t ) } + 0 . 0 3 \tilde { c } _ { 1 } ^ { ( t ) } - 0 . 3 3 ) - 0 . 0 8 + 0 . 2 4 } \\ & { \qquad = 0 . 0 9 f _ { 1 } ^ { ( t ) } + 0 . 0 1 \tilde { c } _ { 1 } ^ { ( t ) } + 0 . 0 1 = 0 . 0 9 ( x _ { 1 } ^ { ( t ) } / 4 ) + 0 . 0 1 ( h _ { 1 } ^ { ( t - 1 ) } - x _ { 2 } ^ { ( t ) } / 4 ) + 0 . 0 1 \geq 0 . 0 0 6 } \end{array}
+$$
+
+As this value is greater than 0, robustness is established. The process above, of replacing a variable with its constraints, is called back-substitution. Here, we replaced $l _ { 1 }$ with $h _ { 1 } ^ { ( t ) } + 0 . 2 4$ , then $h _ { 1 } ^ { ( t ) }$ with $0 . 1 8 f _ { 1 } ^ { ( t ) } + 0 . 0 3 \tilde { c } _ { 1 } ^ { ( t ) } - 0 . 3 3$ and so on. In Appendix C we show more detailed calculations to obtain tighter bound 0.0375 by also back-substituting in the preprocessing pipeline. For our experiments in Section 6, we tune the number of back-substitution steps to achieve a good tradeoff between speed and precision. Note that robustness cannot be proved if one concretizes the expression above to an interval, instead of performing back-substitution of linear bounds. For instance, if we concretize $h _ { 1 } ^ { ( t ) }$ to $[ - 0 . 2 5 , 0 . 6 5 ]$ , we obtain $l _ { 1 } - l _ { 2 } \ge h _ { 1 } ^ { ( t ) } - h _ { 2 } ^ { ( t ) } + 0 . 2 4 \ge - 0 . 0 1$ which is imprecise and fails to certify robustness. Note that if $t$ is not the last timestep, the hidden state and the cell state are passed to the next analysis timestep instead of computing the final output.
+
+# 4 AUDIO PROCESSING TRANSFORMERS
+
+As illustrated earlier, the first part of the verification process involves handling of the audio processing stage (performed using MFCC). Here, most matrix multiplication parts can be captured exactly by our abstraction, but MFCC also includes the square operation in the FFT and the logarithm operation in the computation of energy from filterbanks. Thus, to handle these non-linear operations, we need to create new abstract transformers, which we present next. To ensure a minimal loss of precision, our abstract transformers minimize the area between the lower and upper bounds in the input-output plane. This approach of minimizing the area has been used before for other transformers and has been shown to be practically effective in Singh et al. (2018; 2019a).
+
+We denote the set of all variables in the analysis as $\mathcal { X }$ . For an element $x \in \mathcal { X }$ , we denote the functions corresponding to its linear lower and upper bound as $x ^ { l }$ and $x ^ { u }$ , respectively. These are scalar functions defined on $\mathbb { R } ^ { k }$ where $k$ is the number of other variables used to compute $x$ . For every element, we also maintain interval bounds, $x \in [ l _ { x } , u _ { x } ]$ . For ease of explanation, we introduce the log transformer followed by the square transformer.
+
+Log abstract transformer The logarithm operation is an assignment $y : = \log ( x )$ where $x , y \in { \mathcal { X } }$ . The output of this operation cannot be captured exactly and we need to carefully introduce an approximation. Here, we first compute the minimum $l _ { y } = \log ( l _ { x } )$ and the maximum $u _ { y } = \log ( u _ { x } )$ , which we use as interval approximation. We define linear lower and upper bound functions $y ^ { l } , y ^ { u } :$ $\mathbb { R } \to \mathbb { R }$ . Using concavity of the logarithm on any subset of the domain, the lower bound function is a line connecting the points $( l _ { x } , \log ( l _ { x } ) )$ and $( u _ { x } , \log ( u _ { x } ) )$ . The upper bound function is chosen as the tangent line to the function minimizing the area between the lower and the upper bound. As a result, we obtain the following bounds as depicted in Fig. 3a:
+
+$$
+y ^ { l } ( x ) = \log l _ { x } + { \frac { x - l _ { x } } { u _ { x } - l _ { x } } } \log { \frac { u _ { x } } { l _ { x } } } \qquad y ^ { u } ( x ) = { \frac { 2 x } { u _ { x } + l _ { x } } } - 1 + \log { \frac { u _ { x } + l _ { x } } { 2 } }
+$$
+
+Note that if $l _ { x } \leq 0$ , $y ^ { l } ( x ) = - \infty$ since the function is not defined on that domain. We make an exception when $u _ { x } - l _ { x } < 1 0 ^ { - 4 }$ to use interval bound for $y ^ { l }$ for avoiding the unstable floating point calculation caused by large denominator of $x$ coefficient.
+
+Square abstract transformer The square operation is an assignment $y : = x ^ { 2 }$ where $x , y \in { \mathcal { X } }$ . Similar to logarithm, this operation is non-linear and cannot be captured exactly in the abstraction. We first compute the interval bounds of the output $l _ { y }$ and $u _ { y }$ , and set the minimum value $l _ { y }$ to 0 when $0 \in [ l _ { x } , u _ { x } ]$ and $\operatorname* { m i n } ( l _ { x } ^ { 2 } , u _ { x } ^ { 2 } )$ otherwise. The maximum value $u _ { y }$ is simply $\operatorname* { m a x } ( l _ { x } ^ { 2 } , u _ { x } ^ { 2 } )$ .
+
+Next, we define linear lower and upper bound functions $y ^ { l } , y ^ { u } : \mathbb { R }  \mathbb { R }$ . Using the convexity of the square function, we set the upper bound function $y ^ { u }$ to the linear function connecting $( l _ { x } , l _ { x } ^ { 2 } )$ and $( \bar { u } _ { x } , u _ { x } ^ { 2 } )$ . For the lower bound function $y ^ { l }$ , we have to be delicate: since $x ^ { 2 } : \mathbb { R }  \mathbb { R } ^ { \geq \breve { 0 } }$ , our $y ^ { l }$ should also be greater or equal than 0 within any domain. With the principle of minimizing the area between the bounds, we obtain the following bounds for cases as shown in Fig. 3b:
+
+$$
+y ^ { l } ( x ) = \left\{ \begin{array} { l l } { 4 l _ { x } x - 4 l _ { x } ^ { 2 } } & { 0 \leq l _ { x } < u _ { x } / 3 } \\ { 4 u _ { x } x - 4 u _ { x } ^ { 2 } } & { 0 \geq 3 u _ { x } > l _ { x } } \\ { 0 } & { l _ { x } \leq 0 \leq u _ { x } } \\ { \left( u _ { x } + l _ { x } \right) x - \left( \left( u _ { x } + l _ { x } \right) / 2 \right) ^ { 2 } } & { o t h e r w i s e } \end{array} \right. \qquad y ^ { u } ( x )  &  = \left( u _ { x } + l _ { x } \right) x - u _ { x } l _ { x }
+$$
+
+# 5 LSTM TRANSFORMERS
+
+Most prior work on verification of neural networks focuses on feed-forward or convolutional architectures whose operations consist of a sequence of affine transforms and activation functions. However, to perform verification of recurrent architectures, one needs to handle the updates of the recurrent unit. Following the equations updating the LSTM presented in Section 2, we can observe that pre-activations of gates are affine transforms which can be captured exactly in our abstraction. However, the operations updating the cell and hidden states are non-linear and require approximation.
+
+Overall, we have three elementwise products – two are between a sigmoid and a tanh and one between a sigmoid and the identity. A straightforward approach to handling such transforms would be to concretize the polyhedra DeepPoly element to an interval and perform the multiplication using intervals. However, this approach would lose all relations between inputs and incur precision loss in future operations of the analysis. Instead, we design custom binary approximation transformers specifically tailored to handle the elementwise product in the update of the recurrent unit.
+
+Sigmoid $\odot$ Tanh abstract transformer We define elementwise multiplication between sigmoid and tanh as an assignment $z : = \sigma ( x ) \operatorname { t a n h } ( y )$ , where $x , y , z \in { \mathcal { X } }$ . As before, our aim is to construct linear bounds $\bar { z ^ { l } } , z ^ { u }$ . Unlike the previously defined DeepPoly transformers which take as input a single abstract element, this transformer is the first which receives two abstract elements as operands. Hence, the bound functions have the form $z ^ { l } , z ^ { u } : \mathbb { R } ^ { 2 }  \mathbb { R }$ .
+
+Let $z = f ( x , y ) = \sigma ( x ) \cdot \operatorname { t a n h } ( y )$ . Our goal is to bound this function between two planes such that the volume between the planes is as small as possible (following our previous heuristic). We first divide the computation into 3 cases based on the signs of $l _ { y }$ and $u _ { y }$ . To simplify notation, we introduce the variable assignment in Table 1 so that we can reuse notation across all cases. We first define an anchor point $^ { a }$ : a point in the box $[ l _ { x } , u _ { x } ] \times [ l _ { y } , u _ { y } ]$ where function $f$ attains the max/min value defined upon the case. Also we need reference point $\mathbfit { \Delta } \mathbf { r }$ whereas the plane would meet first among the four corners if it is tilted in given direction, other than the anchor. Our transformer computes two candidates planes for the upper bound $( z _ { x } ^ { u } , z _ { y } ^ { u } )$ and two for the lower bound $( z _ { x } ^ { l } , z _ { y } ^ { l } )$ as:
+
+Table 1: Variable reference for the $\sigma ( x ) \cdot \operatorname { t a n h } ( y )$ approximation.   
+
+<table><tr><td colspan="3">2</td><td>2</td><td>2</td><td>2</td></tr><tr><td rowspan="3">ly≥0</td><td>Φ</td><td>min</td><td>min</td><td>min</td><td>min</td></tr><tr><td>a</td><td>ux,uy</td><td>ux,uy</td><td>l，ly</td><td>la,ly</td></tr><tr><td>r</td><td>la,uy</td><td>u，ly</td><td>uxly</td><td>la,uy</td></tr><tr><td rowspan="3">ly&lt;0≤uy</td><td>重</td><td>min</td><td>min</td><td>max</td><td>min</td></tr><tr><td>a</td><td>ux,uy</td><td>u，uy</td><td>ua,ly</td><td>ux,ly</td></tr><tr><td>r</td><td>l,uy</td><td>laly</td><td>laly</td><td>l,uy</td></tr><tr><td rowspan="3">uy&lt;0</td><td>Φ</td><td>max</td><td>min</td><td>max</td><td>min</td></tr><tr><td>a</td><td>l,uy</td><td>l,uy</td><td>ux,ly</td><td>ux,ly</td></tr><tr><td>r</td><td>ux,uy</td><td>la，ly</td><td>l，y</td><td>uy，uy</td></tr></table>
+
+![](images/7c720e647ed71e3f3c937c346d7a7ddca4410e0deb12ed2e3be983cef2826bac.jpg)  
+Figure 4: Visualization of the bounding planes and $\sigma ( x ) \cdot \operatorname { t a n h } ( y )$ curve.
+
+$$
+\begin{array} { l } { { ( z ^ { u } | z ^ { l } ) _ { x } = \Phi \left( D _ { i } f ( { \bf { a } } ) , \displaystyle { \frac { f ( { \bf { a } } ) - f ( r ) } { a _ { x } - r _ { x } } } \right) ( x - a _ { x } ) + f ( { \bf { a } } ) } } \\ { { ( z ^ { u } | z ^ { l } ) _ { y } = \Phi \left( D _ { j } f ( { \bf { a } } ) , \displaystyle { \frac { f ( { \bf { a } } ) - f ( r ) } { a _ { y } - r _ { y } } } \right) ( y - a _ { y } ) + f ( { \bf { a } } ) } } \end{array}
+$$
+
+where $\begin{array} { r } { D _ { i } f = \frac { \partial f } { \partial x } } \end{array}$ ∂ f , D j f = , and $\Phi , a , r$ are chosen from Table 1. Finally, we choose bounds from two candidates which minimize the volume between the planes. Fig. 4 is the visualization of this result. We note that Sigmoid $\odot$ Identity transformer is handled in the same manner (we can directly apply the same transformer by replacing $f ( x , y )$ with $\sigma ( x ) \cdot y )$ .
+
+Theorem 1. Our Sigmoid $\odot$ Tanh transformer is optimal (it minimizes the volume between the lower and upper plane) under the assumptions: $( l )$ bounding planes are tangent to the curve at the respective anchor points, (2) bounding planes are parallel to either x or y axis. Planes computed using our transformer result in a volume strictly smaller than those computed using interval analysis.
+
+We show the proof in Appendix B. Our assumptions are based on the following reasoning. The first assumption is need so that our transformer produces bounds strictly better than interval analysis. Unless $z ^ { u }$ passes through the point $( u _ { x } , u _ { y } )$ , the concrete upper bound would be larger than $\sigma ( u _ { x } )$ · $\operatorname { t a n h } ( u _ { y } )$ , making it worse than an interval bound(analogously for the lower bound). The second assumption enables computation of optimal planes in $O ( 1 )$ while without this assumption one needs to solve a non-convex optimization problem which is not feasible at the scale of networks we consider.
+
+# 6 EXPERIMENTS
+
+We now evaluate the effectiveness of DAC on several datasets and neural architectures. All our transformers are implemented in C (for performance) and exposed to the verifier using a Python interface. We will publicly release the datasets, trained networks and source code of DAC. Verification is performed on a Intel(R) Core(TM) i9-9900K CPU $@$ 3.60GHz using 6 cores for each instance.
+
+Experimental setup We evaluate on audio classification benchmarks: Free Spoken Digit Dataset (FSDD) (Jackson, 2019) and Google Speech Commands (GSC) (Warden, 2018). FSDD contains 2,000 samples of spoken digits while GSC is a more complex dataset containing 65,000 utterances of 30 short words spoken by thousands of different people. State-of-the-art accuracy on GSC is $9 6 . 9 \%$ by de Andrade et al. (2018) using attention RNN, while our verified model achieves $89 \%$ .
+
+Robustness evaluation Following Singh et al. (2019b), we define success rate of verification as the ratio between certified samples and correctly predicted ones. We randomly shuffled the test data and then, for every experiment, inferred labels one by one until the number of correctly classified samples reached 100. We report the number of provably correct samples out of these 100 as our provability. As a baseline, we consider a verification method based on interval analysis, which only derives neuronwise lower and upper bounds using the previous layer’s bounds. We used networks with $h = 4 0$ hidden neurons and $p = 1 0$ filters for both FSDD and GSC. Our results are shown in Fig. 5. They suggest that DAC substantially outperforms interval analysis due to better approximations of key functions in both audio preprocessing and neural network stages.
+
+![](images/982f3b784ec9da863fc1184c138ed5a131d2f9084c2f12aaa6406ef99fddf4a5.jpg)  
+Figure 5: Robustness evaluation on FSDD and GSC datasets, using DAC and Interval analysis.
+
+Effect of back-substitution depth In this experiment, we vary the depth of back-substitution used in DAC and study its effect on our performance. We run this experiment on an FSDD network and report the results in Table 2. We observe that increasing the back-substitution depth increases the provability. This is due to the fact that we benefit from cancellation of common terms in the propagated expressions, as demonstrated in our example in Section 3. However, this comes at a cost of exponential increase in runtime. Thus, we choose to use depth 3 in order to get high verification rate while still having reasonable verification speed.
+
+Table 2: Effect of back-substitution depth on the performance.   
+
+<table><tr><td>Depth</td><td>Provability(%)</td><td>Run Time(s)</td></tr><tr><td>0</td><td>27</td><td>8.33</td></tr><tr><td>1</td><td>35</td><td>18.95</td></tr><tr><td>2</td><td>37</td><td>40.83</td></tr><tr><td>3</td><td>39</td><td>87.92</td></tr><tr><td>4</td><td>40</td><td>166.19</td></tr><tr><td>5</td><td>41</td><td>328.92</td></tr></table>
+
+# Provable defense for audio classifiers We also for the first
+
+time trained audio classifiers to be provably robust against noise-based perturbations. Our training follows Mirman et al. (2018); Gowal et al. (2018) – we perturb the input signal and propagate interval bounds through the audio processing and LSTM stages. To train, we combine standard loss with the worst case loss obtained using interval propagation. The resulting network shown in Fig. 5b achieves $80 \%$ of provability for -80 dB even with the imprecise intervals, outperforming the undefended network. Even though this network was specifically trained to be verifiable using intervals, DAC still outperforms intervals and proves significantly more robustness properties. Also note that defended network has lower accuracy of $9 5 \%$ , compared to the $98 \%$ accuracy of the baseline.
+
+Experimental comparison with prior work POPQORN (Ko et al., 2019) also proposes a method to certify recurrent neural networks by propagating linear bounds. One of the key differences with our work is the approximation of $\sigma ( x ) \cdot \operatorname { t a n h } ( y )$ using linear bounds. We found that, in practice, optimization approach used by POPQORN produces approximations of slightly smaller volume than our LSTM transformer (although non-comparable). However, this smaller volume comes at a high cost in runtime. We tried to integrate POPQORN bounds into our verification framework, however we found it not feasible for our audio tasks as it increased our end-to-end runtime $2 0 0 \times$ on one of the smaller networks. In contrast, DAC takes only 1-2 minutes on average to verify a single example containing multiple frames. Indeed, our observation is consistent with the evaluation of POPQORN in the paper where it takes hours on a GPU for verifying NLP and vision tasks only for a single frame.
+
+# 7 CONCLUSION
+
+We presented the first verifier for certifying audio classifiers. The key idea was to create abstract transformers for non-linear operations used in the audio processing stage and the recurrent network. These transformers compute an optimal (area-wise) approximation under assumptions representable in the underlying convex relaxation and enable sound handling of the entire pipeline. Our evaluation shows that DAC is practically effective and achieves high verification rates on different datasets.
+
+# REFERENCES
+
+Dario Amodei, Sundaram Ananthanarayanan, Rishita Anubhai, Jingliang Bai, Eric Battenberg, Carl Case, Jared Casper, Bryan Catanzaro, Qiang Cheng, Guoliang Chen, et al. Deep speech 2: End-toend speech recognition in english and mandarin. In International conference on machine learning, pp. 173–182, 2016.
+
+Ross Anderson, Joey Huchette, Will Ma, Christian Tjand raatmadja, and Juan Pablo Vielma. Strong mixed-integer programming formulations for trained neural networks. arXiv e-prints, pp. arXiv:1811.01988, 2018.
+
+Rudy Bunel, Ilker Turkaslan, Philip H.S. Torr, Pushmeet Kohli, and M. Pawan Kumar. A unified view of piecewise linear neural network verification. In Proc. Advances in Neural Information Processing Systems (NeurIPS), pp. 4795–4804, 2018.
+
+Nicholas Carlini and David Wagner. Audio adversarial examples: Targeted attacks on speech-to-text. In 2018 IEEE Security and Privacy Workshops (SPW), pp. 1–7. IEEE, 2018.
+
+Nicholas Carlini, Pratyush Mishra, Tavish Vaidya, Yuankai Zhang, Micah Sherr, Clay Shields, David Wagner, and Wenchao Zhou. Hidden voice commands. In 25th {USENIX} Security Symposium ({USENIX} Security 16), pp. 513–530, 2016.
+
+Chung-Cheng Chiu, Tara N. Sainath, Yonghui Wu, Rohit Prabhavalkar, Patrick Nguyen, Zhifeng Chen, Anjuli Kannan, Ron J. Weiss, Kanishka Rao, Katya Gonina, Navdeep Jaitly, Bo Li, Jan Chorowski, and Michiel Bacchiani. State-of-the-art speech recognition with sequence-to-sequence models. CoRR, abs/1712.01769, 2017. URL http://arxiv.org/abs/1712.01769.
+
+Patrick Cousot and Radhia Cousot. Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints. In Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages, pp. 238–252. ACM, 1977.
+
+Douglas Coimbra de Andrade, Sabato Leo, Martin Loesener Da Silva Viana, and Christoph Bernkopf. A neural attention model for speech command recognition. arXiv preprint arXiv:1808.08929, 2018.
+
+Krishnamurthy Dvijotham, Robert Stanforth, Sven Gowal, Timothy Mann, and Pushmeet Kohli. A dual approach to scalable verification of deep networks. In Proc. Uncertainty in Artificial Intelligence (UAI), pp. 162–171, 2018.
+
+Krishnamurthy (Dj) Dvijotham, Robert Stanforth, Sven Gowal, Chongli Qin, Soham De, and Pushmeet Kohli. Efficient neural network verification with exactness characterization. In Proc. Uncertainty in Artificial Intelligence, UAI, pp. 164, 2019.
+
+Rüdiger Ehlers. Formal verification of piece-wise linear feed-forward neural networks. In Automated Technology for Verification and Analysis (ATVA), 2017.
+
+Mohammad Esmaeilpour, Patrick Cardinal, and Alessandro Lameiras Koerich. A robust approach for securing audio classification against adversarial attacks. arXiv preprint arXiv:1904.10990, 2019.
+
+Timon Gehr, Matthew Mirman, Dana Drachsler-Cohen, Petar Tsankov, Swarat Chaudhuri, and Martin Vechev. Ai2: Safety and robustness certification of neural networks with abstract interpretation. In 2018 IEEE Symposium on Security and Privacy (SP), pp. 3–18. IEEE, 2018.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Sven Gowal, Krishnamurthy Dvijotham, Robert Stanforth, Rudy Bunel, Chongli Qin, Jonathan Uesato, Timothy Mann, and Pushmeet Kohli. On the effectiveness of interval bound propagation for training verifiably robust models. arXiv preprint arXiv:1810.12715, 2018.
+
+Alex Graves, Abdel-rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In 2013 IEEE international conference on acoustics, speech and signal processing, pp. 6645–6649. IEEE, 2013.
+
+Awni Hannun, Carl Case, Jared Casper, Bryan Catanzaro, Greg Diamos, Erich Elsen, Ryan Prenger, Sanjeev Satheesh, Shubho Sengupta, Adam Coates, et al. Deep speech: Scaling up end-to-end speech recognition. arXiv preprint arXiv:1412.5567, 2014.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural Comput., 9(8):1735– 1780, November 1997. ISSN 0899-7667. doi: 10.1162/neco.1997.9.8.1735. URL http://dx. doi.org/10.1162/neco.1997.9.8.1735.
+
+Zohar Jackson. Free spoken digit dataset. https://github.com/Jakobovski/ free-spoken-digit-dataset, 2019.
+
+Guy Katz, Clark Barrett, David L Dill, Kyle Julian, and Mykel J Kochenderfer. Reluplex: An efficient smt solver for verifying deep neural networks. In International Conference on Computer Aided Verification, pp. 97–117. Springer, 2017.
+
+CY Ko, Z Lyu, TW Weng, L Daniel, N Wong, and D Lin. Popqorn: Certifying robustness of recurrent neural networks. In International Conference on Machine Learning (ICML), 2019.
+
+Matthew Mirman, Timon Gehr, and Martin Vechev. Differentiable abstract interpretation for provably robust neural networks. In International Conference on Machine Learning, pp. 3575–3583, 2018.
+
+Paarth Neekhara, Shehzeen Hussain, Prakhar Pandey, Shlomo Dubnov, Julian McAuley, and Farinaz Koushanfar. Universal adversarial perturbations for speech recognition systems. arXiv preprint arXiv:1905.03828, 2019.
+
+Santiago Pascual, Antonio Bonafonte, and Joan Serra. Segan: Speech enhancement generative adversarial network. arXiv preprint arXiv:1703.09452, 2017.
+
+Yao Qin, Nicholas Carlini, Ian Goodfellow, Garrison Cottrell, and Colin Raffel. Imperceptible, robust, and targeted adversarial examples for automatic speech recognition. In International Conference on Machine Learning (ICML), 2019.
+
+Aditi Raghunathan, Jacob Steinhardt, and Percy S Liang. Semidefinite relaxations for certifying robustness to adversarial examples. In Advances in Neural Information Processing Systems (NeurIPS), pp. 10877–10887. 2018.
+
+Wenjie Ruan, Xiaowei Huang, and Marta Kwiatkowska. Reachability analysis of deep neural networks with provable guarantees. In Proc. International Joint Conference on Artificial Intelligence, IJCAI, pp. 2651–2659, 2018.
+
+Md Sahidullah and Goutam Saha. Design, analysis and experimental evaluation of block based transformation in mfcc computation for speaker recognition. Speech Communication, 54(4): 543–565, 2012.
+
+Tara N Sainath, Ron J Weiss, Andrew Senior, Kevin W Wilson, and Oriol Vinyals. Learning the speech front-end with raw waveform cldnns. In Sixteenth Annual Conference of the International Speech Communication Association, 2015.
+
+Hadi Salman, Greg Yang, Huan Zhang, Cho-Jui Hsieh, and Pengchuan Zhang. A convex relaxation barrier to tight robustness verification of neural networks. CoRR, abs/1902.08722, 2019.
+
+Gagandeep Singh, Timon Gehr, Matthew Mirman, Markus Püschel, and Martin Vechev. Fast and effective robustness certification. In Advances in Neural Information Processing Systems, pp. 10802–10813, 2018.
+
+Gagandeep Singh, Timon Gehr, Markus Püschel, and Martin Vechev. An abstract domain for certifying neural networks. Proceedings of the ACM on Programming Languages, 3(POPL):41, 2019a.
+
+Gagandeep Singh, Timon Gehr, Markus Püschel, and Martin Vechev. Boosting robustness certification of neural networks. In International Conference on Learning Representations, 2019b.
+
+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.
+
+Vincent Tjeng, Kai Y. Xiao, and Russ Tedrake. Evaluating robustness of neural networks with mixed integer programming. In International Conference on Learning Representations, (ICLR), 2019.
+
+Shiqi Wang, Kexin Pei, Justin Whitehouse, Junfeng Yang, and Suman Jana. Efficient formal safety analysis of neural networks. In Advances in Neural Information Processing Systems, pp. 6367– 6377, 2018.
+
+Pete Warden. Speech commands: A dataset for limited-vocabulary speech recognition. arXiv preprint arXiv:1804.03209, 2018.
+
+Lily Weng, Huan Zhang, Hongge Chen, Zhao Song, Cho-Jui Hsieh, Luca Daniel, Duane Boning, and Inderjit Dhillon. Towards fast computation of certified robustness for ReLU networks. In Proc. International Conference on Machine Learning (ICML), volume 80, pp. 5276–5285, 2018.
+
+Eric Wong, Frank R. Schmidt, Jan Hendrik Metzen, and J. Zico Kolter. Scaling provable adversarial defenses. In Proc. Neural Information Processing Systems (NeurIPS), pp. 8410–8419, 2018.
+
+Zhuolin Yang, Bo Li, Pin-Yu Chen, and Dawn Song. Characterizing audio adversarial examples using temporal dependency. 2019.
+
+Guoming Zhang, Chen Yan, Xiaoyu Ji, Tianchen Zhang, Taimin Zhang, and Wenyuan Xu. Dolphinattack: Inaudible voice commands. In Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security, pp. 103–117. ACM, 2017.
+
+Huan Zhang, Tsui-Wei Weng, Pin-Yu Chen, Cho-Jui Hsieh, and Luca Daniel. Efficient neural network robustness certification with general activation functions. In Advances in Neural Information Processing Systems, pp. 4939–4948, 2018.
+
+# A SOUNDNESS PROOF OF SIGMOID $\odot$ TANH ABSTRACT TRANSFORMER
+
+Suppose $x$ and $y$ are the abstract variable bounded by $[ l _ { x } , u _ { x } ] , [ l _ { y } , u _ { y } ]$ respectively. This suggested transformer finds the bounding planes of the function $f ( x , y ) = \sigma ( x ) \operatorname { t a n h } ( y )$ . Let $\begin{array} { r } { D _ { i } f = \frac { \partial f } { \partial x } } \end{array}$ and $\begin{array} { r } { D _ { j } f = \frac { \partial f } { \partial y } } \end{array}$ .
+
+1. $l _ { y } \geq 0$ Choose the upper bound of the function between $z _ { x } ^ { u }$ and $z _ { y } ^ { u }$ , where
+
+$$
+\begin{array} { r l } & { z _ { x } ^ { u } ( x , y ) = \operatorname* { m i n } \left( D _ { i } f ( u _ { x } , u _ { y } ) , \frac { f ( u _ { x } , u _ { y } ) - f ( l _ { x } , u _ { y } ) } { u _ { x } - l _ { x } } \right) ( x - u _ { x } ) - f ( u _ { x } , u _ { y } ) } \\ & { z _ { y } ^ { u } ( x , y ) = \operatorname* { m i n } \left( D _ { j } f ( u _ { x } , u _ { y } ) , \frac { f ( u _ { x } , u _ { y } ) - f ( u _ { x } , l _ { y } ) } { u _ { y } - l _ { y } } \right) ( y - u _ { y } ) - f ( u _ { x } , u _ { y } ) } \end{array}
+$$
+
+by the smaller volume under the each plane.
+
+Claim 1: $z _ { x } ^ { u } ( x , y ) \geq f ( x , y )$ in $( x , y ) \in [ l _ { x } , u _ { x } ] \times [ l _ { y } , u _ { y } ]$ .   
+Let $x _ { 1 } < x _ { 2 } \in [ l _ { x } , u _ { x } ]$ and $y _ { 1 } < y _ { 2 } \in [ l _ { y } , u _ { y } ]$ . Then for any $x , y , f ( x , y _ { 1 } ) < f ( x , y _ { 2 } )$ and $f ( x _ { 1 } , y ) \ < \ f ( x _ { 2 } , y )$ . Thus, since $z _ { x } ^ { u }$ is independent to $y$ , it is sufficient to show $z _ { x } ^ { u } ( x , \cdot ) \geq f ( x , u _ { y } )$ .
+
+We can easily know that $f ( x , u _ { y } )$ is concave at $x \ge 0$ and convex at $x \leq 0$ by the second derivation of $f$ .
+
+(a) Consider the case of $u _ { x } > 0$ . Let $x _ { 0 }$ be the $\mathbf { X }$ coordinate of the crossing of $f ( x , u _ { y } )$ and $g ( x ) = D _ { i } f ( u _ { x } , u _ { y } ) ( x - u _ { x } ) - f ( u _ { x } , u _ { y } )$ . From the convexity of $f ( x , u _ { y } )$ in $x < 0$ , $g ( 0 ) > f ( 0 , u _ { y } )$ , and $g ^ { \prime } ( x ) > 0$ , there exists a single $x _ { 0 } < 0$ . If $l _ { x } > x _ { 0 }$ , the slope of $z _ { x } ^ { u } ( x , \cdot )$ becomes $D _ { i } f ( u _ { x } , u _ { y } )$ , and $z _ { x } ^ { u }$ and $g$ become identical. Hence, $f ( x , u _ { y } ) \leq$ $g ( x ) = z _ { x } ^ { u } ( x , \cdot )$ . If  a p $l _ { x } \le x _ { 0 }$ thebut pe of has s $z _ { x } ^ { u } ( x , \cdot )$ becomope, so $\frac { f ( u _ { x } , u _ { y } ) - f ( l _ { x } , u _ { y } ) } { u _ { x } - l _ { x } }$ $z _ { x } ^ { u }$ $g$ $u _ { x }$ $z _ { x } ^ { u }$ $g ( x ) \leq z _ { x } ^ { u } ( x , \cdot )$ $[ l _ { x } , u _ { x } ]$ Also from $f ( l _ { x } , u _ { y } ) = z _ { x } ^ { u } ( l _ { x } , \cdot )$ and $f ( 0 , u _ { y } ) < z _ { x } ^ { u } ( 0 , \cdot )$ , $f ( x , u _ { y } ) \leq z _ { x } ^ { u } ( x , \cdot )$ . Thus, the claim holds when $u _ { x } > 0$ .   
+(b) Another case of $u _ { x } \leq 0$ , $\mathbf { X }$ coefficient of $z _ { x } ^ { u }$ will always be $\frac { f ( u _ { x } , u _ { y } ) - f ( l _ { x } , u _ { y } ) } { u _ { x } - l _ { x } }$ . Again, by convexity of $f ( x , u _ { y } )$ , $z _ { x } ^ { u } ( x , \cdot ) \geq f ( x , u _ { y } )$ .
+
+Hence $z _ { x } ^ { u } ( x , \cdot ) \geq f ( x , u _ { y } ) \geq f ( x , y )$ holds in $( x , y ) \in [ l _ { x } , u _ { x } ] \times [ l _ { y } , u _ { y } ]$ . Claim proved. With analogous steps, $z _ { y } ^ { u }$ can be shown to cover above the curve. Choosing the plane with smaller volume underneath it allows to minimize the expected difference between the true curve and the upper bound plane under the randomly chosen domain.
+
+For the lower bound, choose the upper bound of the function between $z _ { x } ^ { l }$ and $z _ { y } ^ { l }$ , where
+
+$$
+\begin{array} { l } { z _ { x } ^ { l } ( x , y ) = \operatorname* { m i n } \left( D _ { i } f ( l _ { x } , l _ { y } ) , \frac { f ( l _ { x } , l _ { y } ) - f ( u _ { x } , l _ { y } ) } { l _ { x } - u _ { x } } \right) ( x - l _ { x } ) - f ( l _ { x } , l _ { y } ) } \\ { z _ { y } ^ { l } ( x , y ) = \operatorname* { m i n } \left( D _ { j } f ( l _ { x } , l _ { y } ) , \frac { f ( l _ { x } , l _ { y } ) - f ( l _ { x } , u _ { y } ) } { l _ { y } - u _ { y } } \right) ( y - l _ { y } ) - f ( l _ { x } , l _ { y } ) } \end{array}
+$$
+
+by the larger volume under the each plane.
+
+Claim 2: $z _ { x } ^ { l } ( x , y ) \leq f ( x , y )$ in $( x , y ) \in [ l _ { x } , u _ { x } ] \times [ l _ { y } , u _ { y } ]$ .
+
+It is sufficient to show $z _ { x } ^ { l } ( x , \cdot ) \geq f ( x , l _ { y } )$ since $f ( x , y _ { 1 } ) \leq f ( x , y _ { 2 } )$ for $y _ { 1 } \le y _ { 2 }$ .
+
+(a) Consider the case of $l _ { x } < 0$ . Let $x _ { 0 }$ be the $\mathbf { X }$ coordinate of the crossing of $f ( x , l _ { y } )$ and $g ( x ) = D _ { i } f ( l _ { x } , l _ { y } ) ( x - l _ { x } ) - f ( l _ { x } , l _ { y } )$ . From the concavity of $f ( x , l _ { y } )$ in $x > 0$ , $g ( 0 ) < f ( 0 , l _ { y } )$ , and $g ^ { \prime } ( x ) > 0$ , there exists a single $x _ { 0 } > 0$ . If $l _ { x } < x _ { 0 }$ , the slope of $z _ { x } ^ { l } ( x , \cdot )$ becomes $D _ { i } f ( l _ { x } , l _ { y } )$ , and $z _ { x } ^ { l }$ and $g$ become identical. Hence, $f ( x , l _ { y } ) \leq$ $g ( x ) = z _ { x } ^ { l } ( x , \cdot )$ . If $l _ { x } \geq x _ { 0 }$ , the slope of $z _ { x } ^ { l } ( x , \cdot )$ becomes $\frac { f ( l _ { x } , l _ { y } ) - f ( u _ { x } , l _ { y } ) } { l _ { x } - u _ { x } }$ . Then $z _ { x } ^ { l }$ and $g$ shares a point of $l _ { x }$ but $z _ { x } ^ { l }$ has smaller slope, so $g ( x ) \geq z _ { x } ^ { l } ( x , \cdot )$ in $[ l _ { x } , u _ { x } ]$ . Also from $f ( u _ { x } , \bar { l _ { y } } ) = z _ { x } ^ { l } ( u _ { x } , \cdot )$ and $f ( 0 , l _ { y } ) > z _ { x } ^ { l } \mathrm { \bar { ( 0 , \cdot ) } }$ , $f ( x , l _ { y } ) \ge z _ { x } ^ { l } ( x , \cdot )$ . Thus, the claim holds when $u _ { x } < 0$ .
+
+(b) Another case of $l _ { x } \geq 0$ , x coefficient of $z _ { x } ^ { l }$ will always be $\frac { f ( l _ { x } , l _ { y } ) - f ( u _ { x } , l _ { y } ) } { l _ { x } - u _ { x } }$ . Again, by convexity of $f ( x , l _ { y } )$ , $z _ { x } ^ { l } ( x , \cdot ) \leq f ( x , l _ { y } )$ .
+
+Hence $z _ { x } ^ { l } ( x , \cdot ) \leq f ( x , l _ { y } ) \geq f ( x , y )$ holds in $( x , y ) \in [ l _ { x } , u _ { x } ] \times [ l _ { y } , u _ { y } ]$ . Claim proved.
+
+With analogous steps, $z _ { y } ^ { l }$ can be shown to lie under the curve. Choosing the plane with larger volume underneath it allows to minimize the expected difference between the true curve and the lower bound plane under the randomly chosen domain.
+
+The proof of upper bounds will follow the same steps with the first case. $z _ { x } ^ { u }$ in this case is exactly same as before, but since $f ( x , y )$ goes below 0 when $y < 0$ , $z _ { y } ^ { u }$ has to anchor at $( l _ { x } , l _ { y } )$ instead of $( u _ { x } , l _ { y } )$ since $f ( l _ { x } , l _ { y } ) \geq f ( u _ { x } , l _ { y } )$ and convexity of $f$ in the region. The proof steps do not differ much from the previous proofs.
+
+Again, the proof for lower bound is similar as before, but note that $z _ { x } ^ { l }$ needs to choose maximum between the two slopes. This is due to the sign of the values. Since $f ( u _ { x } , l _ { y } ) < 0$ is the minimum in the region and it grows along $x$ gets smaller, both $D _ { \mathbf { i } } f ( u _ { x } , l _ { y } )$ and f(ux,ly)−f(lx,ly) are less than zero.
+
+3. $0 \geq u _ { y }$
+
+We will not provide the proof since this case is symmetric to the first case.
+
+# B PROOF OF THEOREM 1
+
+Theorem 1. (copied) Our Sigmoid $\odot$ Tanh transformer is optimal (it minimizes the volume between the lower and upper plane) under the assumptions: $( l )$ bounding planes are tangent to the curve at the respective anchor points, (2) bounding planes are parallel to either x or y axis. Planes computed using our transformer result in a volume strictly smaller than those computed using interval analysis.
+
+Proof. First note that zux , zuy , zlx, zly are sound bounds by Appendix A. Assume $z _ { x } ^ { u }$ is chosen as the upper bound. W.l.o.g., suppose there exists another sound candidate upper bound $\zeta _ { x } ^ { u }$ , satisfying (1) and (2), with smaller volume underneath it than $z _ { x } ^ { u }$ . Then $\zeta _ { x } ^ { u }$ would have larger absolute slope on $x$ than $z _ { x } ^ { u }$ . However, the slope of $z _ { x } ^ { u }$ is chosen as stiff as possible while remaining the soundness (Appendix A to see in detail). Hence, $\zeta _ { x } ^ { u }$ would not be sound anymore with larger absolute coefficient. Contradict to the existence of sound $\zeta _ { x } ^ { u }$ . Other cases can be proved with similar logic as well. □
+
+# C VERIFICATION BY EXAMPLE
+
+We assume the last sound frame $\mathbf { \boldsymbol { s } } ^ { ( t ) }$ consists of two elements $s _ { 1 } ^ { ( t ) }$ and $s _ { 2 } ^ { ( t ) }$ such that: $s _ { 1 } ^ { ( t ) } \in [ 0 , 1 ]$ and $s _ { 2 } ^ { ( t ) } \in [ - 2 , - 1 ]$ . These constraints capture a noise perturbation of the sound and are depicted in the white box in the left part of Fig. 2. We describe analysis only at the last timestep $t$ (the same process is repeated for every timestep).
+
+We note that the DeepPoly abstraction (which we build on in this work) maintains four constraints for every element: a lower and upper constraints which are linear in terms of the previous elements as well as two interval constraints. This abstraction is exact for affine transformations, however, to handle non-linear operations, one has to create new abstract transformers. In our work we introduce such transformers and formally describe their operation in the next sections. In what follows, we show their effect on our running example. For the presentation below, our figure shows the linear constraints obtained by the verifier, but to avoid visual clutter, we do not show the two interval constraints (however, we do list them in the text).
+
+Fast Fourier Transform The first operation in the audio processing stage is the Fast Fourier Transform (FFT) of the pre-emphasized input signal. It is a two-step process shown in dashed boxes in Fig. 2. The preemphasis is in fact an affine transform so we perform it jointly with the affine transform in the FFT. As the composition of two affine transforms is again affine, this amounts to a single affine transform on the input. In our example, the composed affine transform is $y _ { 1 } ^ { ( t ) } = s _ { 1 } ^ { ( t ) } - s _ { 2 } ^ { ( t ) }$ and y(t2 (t) ) = 2 s ( t )2 . Affine transforms can be capturee also obtain the interval bounds d he and $s _ { 1 } ^ { ( t ) } - s _ { 2 } ^ { ( t ) } \leq y _ { 1 } ^ { ( t ) } \leq s _ { 1 } ^ { ( t ) } - s _ { 2 } ^ { ( t ) }$ . $y _ { 1 } ^ { ( t ) } \in [ 1 , 3 ]$ $y _ { 2 } ^ { ( t ) } \in [ - 4 , - 2 ]$
+
+The next step in the computation of FFT is elementwise square of $\mathbf { \boldsymbol { y } } ^ { ( t ) }$ . We denote this operation as $\theta _ { 1 } ^ { ( t ) } = ( y _ { 1 } ^ { ( t ) } ) ^ { 2 }$ and $\theta _ { 2 } ^ { ( t ) } = ( y _ { 2 } ^ { ( t ) } ) ^ { 2 }$ . The square operation is non-linear and cannot be captured exactly which means that we need to decide how to lose precision. Here, we apply our new square abstract transformer (formally defined in Section 4) which provides an optimal linear lower and upper bounds of the square function in terms of area. After applying this transformer, we obtain the bounds:
+
+$$
+4 y _ { 1 } ^ { ( t ) } - 4 \leq \theta _ { 1 } ^ { ( t ) } \leq 4 y _ { 1 } ^ { ( t ) } - 3 \qquad - 6 y _ { 2 } ^ { ( t ) } - 9 \leq \theta _ { 2 } ^ { ( t ) } \leq - 6 y _ { 2 } ^ { ( t ) } - 8
+$$
+
+The interval bounds are calculated by:
+
+$$
+\begin{array} { r l } & { \theta _ { 1 } ^ { ( t ) } \geq 4 y _ { 1 } ^ { ( t ) } - 4 = 4 ( s _ { 1 } ^ { ( t ) } - s _ { 2 } ^ { ( t ) } ) - 4 \geq 4 ( 0 - ( - 1 ) ) - 4 = 0 } \\ & { \theta _ { 1 } ^ { ( t ) } \leq 4 y _ { 1 } ^ { ( t ) } - 3 = 4 ( s _ { 1 } ^ { ( t ) } - s _ { 2 } ^ { ( t ) } ) - 3 \leq 4 ( 1 - ( - 2 ) ) - 3 = 9 } \\ & { \theta _ { 2 } ^ { ( t ) } \geq - 6 y _ { 2 } ^ { ( t ) } - 9 = - 6 ( 2 s _ { 2 } ^ { ( t ) } ) - 9 \geq - 6 ( 2 \cdot ( - 1 ) ) - 9 = 3 } \\ & { \theta _ { 2 } ^ { ( t ) } \leq - 6 y _ { 2 } ^ { ( t ) } - 8 = - 6 ( 2 s _ { 2 } ^ { ( t ) } ) - 8 \leq - 6 ( 2 \cdot ( - 2 ) ) - 8 = 1 6 } \end{array}
+$$
+
+Hence, $\theta _ { 1 } ^ { ( t ) } \in [ 0 , 9 ]$ and $\theta _ { 2 } ^ { ( t ) } \in [ 3 , 1 6 ]$ . Note those bounds are not exact but sound; even $y _ { 1 } ^ { ( t ) } \in [ 1 , 3 ]$ and $y _ { 2 } ^ { ( t ) } \in [ - 4 , - 2 ]$ , DAC calculates the concrete lower and upper bound with the expression to be consistent with other transformers, so the bounds might not be exact as [1, 9] and [4, 16]. In practice, FFT is followed by another affine transform which adds together the real and complex component of each element, but we omit this for clarity as it is captured as before, without loss of precision.
+
+Filterbanks Transform Our analysis continues with the computation of filter banks of the input, shown in solid boxes in Fig. 2. The first step is an affine transform and in our example we use: $\tilde { \psi } _ { 1 } ^ { ( t ) } =$ $2 \theta _ { 1 } ^ { ( t ) } + \theta _ { 2 } ^ { ( t ) }$ and $\tilde { \psi } _ { 2 } ^ { ( t ) } = \theta _ { 1 } ^ { ( t ) } + 3 \theta _ { 2 } ^ { ( t ) }$ . Our abstraction is again exact here and additionally computes interval bounds $\tilde { \psi } _ { 1 } ^ { ( t ) } \in [ 3 , 3 4 ]$ and $\tilde { \psi } _ { 2 } ^ { ( t ) } \in$ [9, 57]. The final step in this transform is the elementwise logarithm of the input. We denote the operation as $\psi _ { 1 } ^ { ( t ) } = \log ( \tilde { \psi } _ { 1 } ^ { ( t ) } )$ and $\psi _ { 2 } ^ { ( t ) } = \log ( \tilde { \psi } _ { 2 } ^ { ( t ) } )$ . As this is again a non-linear operation, we apply our new log transformer so to obtain:
+
+$$
+\begin{array} { r l } & { 0 . 0 7 8 3 \tilde { \psi } _ { 1 } ^ { ( t ) } + 0 . 8 6 3 7 \leq \psi _ { 1 } ^ { ( t ) } \leq 0 . 0 5 4 1 \tilde { \psi } _ { 1 } ^ { ( t ) } + 1 . 9 1 7 8 } \\ & { 0 . 0 3 8 4 \tilde { \psi } _ { 2 } ^ { ( t ) } + 1 . 8 5 1 1 \leq \psi _ { 2 } ^ { ( t ) } \leq 0 . 0 3 0 3 \tilde { \psi } _ { 2 } ^ { ( t ) } + 2 . 4 9 6 5 } \end{array}
+$$
+
+The interval bounds are calculated by:
+
+$$
+\begin{array} { r l } & { \psi _ { 1 } ^ { ( t ) } \geq 0 . 0 7 8 3 \tilde { \psi } _ { 1 } ^ { ( t ) } + 0 . 8 6 3 7 = 0 . 0 7 8 3 ( 2 \theta _ { 1 } ^ { ( t ) } + \theta _ { 2 } ^ { ( t ) } ) + 0 . 8 6 3 7 } \\ & { \qquad \geq 0 . 0 7 8 3 ( 2 ( 4 y _ { 1 } ^ { ( t ) } - 4 ) + ( - 6 y _ { 2 } ^ { ( t ) } - 9 ) ) + 0 . 8 6 3 7 } \\ & { \qquad = 0 . 0 7 8 3 ( 2 ( 4 ( s _ { 1 } ^ { ( t ) } - s _ { 2 } ^ { ( t ) } ) - 4 ) + ( - 6 ( 2 s _ { 2 } ^ { ( t ) } ) - 9 ) + 0 . 8 6 3 7 } \\ & { \qquad = 0 . 6 2 6 4 s _ { 1 } ^ { ( t ) } - 1 . 5 6 6 s _ { 2 } ^ { ( t ) } - 0 . 4 6 7 4 \geq 1 . 0 9 8 6 } \end{array}
+$$
+
+$$
+\psi _ { 1 } ^ { ( t ) } \leq 0 . 0 5 4 1 \tilde { \psi } _ { 1 } ^ { ( t ) } + 1 . 9 1 7 8 = 0 . 0 5 4 1 ( 2 \theta _ { 1 } ^ { ( t ) } + \theta _ { 2 } ^ { ( t ) } ) + 1 . 9 1 7 8
+$$
+
+$$
+= 0 . 0 5 4 1 ( 2 ( 4 ( s _ { 1 } ^ { ( t ) } - s _ { 2 } ^ { ( t ) } ) - 3 ) + ( - 6 ( 2 s _ { 2 } ^ { ( t ) } ) - 8 ) ) + 1 . 9 1 7 8
+$$
+
+$$
+= 0 . 4 3 2 8 s _ { 1 } ^ { ( t ) } - 1 . 0 8 2 s _ { 2 } ^ { ( t ) } + 1 . 1 6 0 4 \leq 3 . 7 5 7 2
+$$
+
+$$
+\begin{array} { r l } & { \psi _ { 2 } ^ { ( t ) } \geq 0 . 0 3 8 4 \tilde { \psi } _ { 2 } ^ { ( t ) } + 1 . 8 5 1 1 = 0 . 0 3 8 4 ( \theta _ { 1 } ^ { ( t ) } + 3 \theta _ { 2 } ^ { ( t ) } ) + 1 . 8 5 1 1 } \\ & { \qquad \geq 0 . 0 3 8 4 ( ( 4 \psi _ { 1 } ^ { ( t ) } - 4 ) + 3 ( - 6 \psi _ { 2 } ^ { ( t ) } - 9 ) ) + 1 . 8 5 1 1 } \\ & { \qquad = 0 . 0 3 8 4 ( ( 4 ( s _ { 1 } ^ { ( t ) } - s _ { 2 } ^ { ( t ) } ) - 4 ) + 3 ( - 6 ( 2 s _ { 2 } ^ { ( t ) } ) - 9 ) ) + 1 . 8 5 1 1 } \\ & { \qquad = 0 . 1 5 3 6 s _ { 1 } ^ { ( t ) } - 1 . 5 3 6 s _ { 2 } ^ { ( t ) } + 0 . 6 6 0 7 \geq 2 . 1 9 6 7 } \\ & { \psi _ { 2 } ^ { ( t ) } \leq 0 . 0 3 0 3 \tilde { \psi } _ { 2 } ^ { ( t ) } + 2 . 4 9 6 5 = 0 . 0 3 0 3 ( \theta _ { 1 } ^ { ( t ) } + 3 \theta _ { 2 } ^ { ( t ) } ) + 2 . 4 9 6 5 } \\ & { \qquad \leq 0 . 0 3 0 3 ( ( 4 \psi _ { 1 } ^ { ( t ) } - 3 ) + 3 ( - 6 \psi _ { 2 } ^ { ( t ) } - 8 ) ) + 2 . 4 9 6 5 } \\ & { \qquad = 0 . 0 3 0 3 3 ( ( 4 ( s _ { 1 } ^ { ( t ) } - s _ { 2 } ^ { ( t ) } ) - 3 ) + 3 ( - 6 ( 2 s _ { 2 } ^ { ( t ) } ) - 8 ) ) + 2 . 4 9 6 5 } \\ & { \qquad = 0 . 1 2 1 2 s _ { 1 } ^ { ( t ) } - 1 . 2 1 2 s _ { 2 } ^ { ( t ) } + 1 . 6 7 8 4 \leq 4 . 2 2 3 6 } \end{array}
+$$
+
+In other words, $\psi _ { 1 } ^ { ( t ) } \in [ 1 . 0 9 8 6 , 3 . 7 5 7 2 ]$ and $\psi _ { 2 } ^ { ( t ) } \in [ 2 . 1 9 6 7 , 4 . 2 2 3 6 ]$ . Again, these bounds are sound since $[ \log 3 , \log 3 4 ] \subset [ 1 . 0 9 8 6 , 3 . 7 5 7 2 ]$ , $[ \log 9 , \log 5 7 ] \subset [ 2 . 1 9 6 7 , 4 . 2 2 3 6 ]$ .
+
+Discrete Cosine Transform and ReLU After the Filterbanks Transform, the input is passed through the Discrete Cosine Transform (DCT) followed by a Lifting operation. The analysis result of these steps is then provided as an input to a fully connected (FC) layer followed by a ReLU activation. To ease presentation, in our example we combine DCT, Lifting and FC layer in a single affine transform: $\bar { x _ { 1 } ^ { ( t ) } } = \psi _ { 1 } ^ { ( t ) } - \psi _ { 2 } ^ { ( t ) } + 4$ and $\tilde { x } _ { 2 } ^ { ( t ) } = 4 \psi _ { 1 } ^ { ( t ) } - \psi _ { 2 } ^ { ( t ) }$ We show this transform in a dotted box in Fig. 2. This is again captured exactly in our abstraction along with interval bounds $\tilde { x } _ { 1 } ^ { ( t ) } \in [ 0 . 8 7 5 , 5 . 5 6 0 5$ ], $\tilde { x } _ { 2 } ^ { ( t ) } \in \ [ 0 . 1 7 0 8 , 1 2 . 8 3 2 1 ]$ . The affine transform is followed by a ReLU activation $x _ { 1 } ^ { ( t ) } = \operatorname* { m a x } ( 0 , \tilde { x } _ { 1 } ^ { ( t ) } )$ , $x _ { 2 } ^ { ( t ) } = \operatorname* { m a x } ( 0 , \tilde { x } _ { 2 } ^ { ( t ) } )$ . In general, we use the ReLU transformer 1 1 2 2defined in Singh et al. (2019a), which for this example produces: $x _ { 1 } ^ { ( t ) } = \tilde { x } _ { 1 } ^ { ( t ) }$ and $x _ { 2 } ^ { ( t ) } = \tilde { x } _ { 2 } ^ { ( t ) }$ .
+
+LSTM analysis After the verifier completes the audio processing stage, its output is passed as input to the LSTM cell. This cell also receives a hidden state and a cell state from the previous timestep (shown as a blue box in Fig. 2). In our example, we assume these are given as: h(t−1), h (t−1)2 , c(t−1)1 , c(t−1)2 ∈ [0.9, 1]. We note that these elements usually have different interval bounds, but for simplicity in our example we use the same intervals. We focus on the first neuron in the LSTM and compute pre-activations in our example for the forget gate $f _ { 1 } ^ { ( t ) } = x _ { 1 } ^ { ( t ) } / 4$ , input gate $i _ { 1 } ^ { ( t ) } = 2 h _ { 2 } ^ { ( t - 1 ) }$ , output gate $o _ { 1 } ^ { ( t ) } = h _ { 1 } ^ { ( t - 1 ) }$ and cell state $\tilde { c } ^ { ( t ) } = h _ { 1 } ^ { ( t - 1 ) } - x _ { 2 } ^ { ( t ) } \bar { / 4 }$ .
+
+In order to update the cell state, we need to compute: $c _ { 1 } ^ { ( t ) } = \sigma ( f _ { 1 } ^ { ( t ) } ) \cdot c _ { 1 } ^ { ( t - 1 ) } + \sigma ( i _ { 1 } ^ { ( t ) } ) \cdot \operatorname { t a n h } ( \tilde { c } _ { 1 } ^ { ( t ) } )$ . The left and right summands are computed using our new binary abstract transformers for $\sigma ( x ) \cdot y$ and $\sigma ( x ) \cdot \operatorname { t a n h } ( y )$ expressions, respectively. Applying our abstract transformers on the summands produces the following bounds:
+
+$$
+\begin{array} { r } { 0 . 1 8 9 1 f _ { 1 } ^ { ( t ) } + 0 . 4 5 7 6 \leq \sigma ( f _ { 1 } ^ { ( t ) } ) \cdot c _ { 1 } ^ { ( t - 1 ) } \leq 0 . 1 5 9 6 f _ { 1 } ^ { ( t ) } + 0 . 5 7 8 7 } \\ { 0 . 0 3 4 1 \tilde { c } _ { 1 } ^ { ( t ) } - 0 . 7 8 4 7 \leq \sigma ( i _ { 1 } ^ { ( t ) } ) \cdot \operatorname { t a n h } ( \tilde { c } _ { 1 } ^ { ( t ) } ) \leq 0 . 3 9 4 5 \tilde { c } _ { 1 } ^ { ( t ) } + 0 . 2 7 6 9 } \end{array}
+$$
+
+Summing up the above inequalities grants the upper and lower bounds of c(t)1 in terms of x(t), h(t−1), and c(t−1):
+
+$$
+\begin{array} { r l } & { c _ { 1 } ^ { ( t ) } \geq 0 . 1 8 9 1 f _ { 1 } ^ { ( t ) } + 0 . 0 3 4 1 \tilde { c } _ { 1 } ^ { ( t ) } - 0 . 3 2 7 1 } \\ & { \qquad = 0 . 1 8 9 1 ( x _ { 1 } ^ { ( t ) } / 4 ) + 0 . 0 3 4 1 ( h _ { 1 } ^ { ( t - 1 ) } - x _ { 2 } ^ { ( t ) } / 4 ) - 0 . 3 2 7 1 } \\ & { \qquad \geq - 0 . 3 6 4 4 } \\ & { c _ { 1 } ^ { ( t ) } \leq 0 . 1 5 9 6 f _ { 1 } ^ { ( t ) } + 0 . 3 9 4 5 \tilde { c } _ { 1 } ^ { ( t ) } + 0 . 8 5 5 6 } \\ & { \qquad = 0 . 1 5 9 6 ( x _ { 1 } ^ { ( t ) } / 4 ) + 0 . 3 9 4 5 ( h _ { 1 } ^ { ( t - 1 ) } - x _ { 2 } ^ { ( t ) } / 4 ) + 0 . 8 5 5 6 } \\ & { \qquad \leq 1 . 4 5 5 1 } \end{array}
+$$
+
+and get $c _ { 1 } ^ { ( t ) } \in [ - 0 . 3 6 4 4 , 1 . 4 5 5 1 ]$ ]. We omit the back-substitution steps since we do not lose precision over the affine transformations from $\mathbf { \boldsymbol { x } } ^ { ( t ) }$ , and note that this calculation is based on the assumption
+
+that the bounds of $\mathbf { \delta } _ { h } ( t )$ and $c ^ { ( t - 1 ) }$ are given constant. In practice, we recursively apply the process for those vectors to express the bounds in terms of ${ \pmb x } ^ { ( t ) } , \bar { { \pmb x } ^ { ( t - 1 ) } } , \cdot \cdot \cdot$
+
+The next hidden state is computed as $h _ { 1 } ^ { ( t ) } = \sigma ( o _ { 1 } ^ { ( t ) } ) \cdot \operatorname { t a n h } ( c _ { 1 } ^ { ( t ) } )$ . We apply our abstract transformer for the $\sigma ( x ) \cdot \operatorname { t a n h } ( y )$ expression, we obtain:
+
+$$
+\begin{array} { r l } & { h _ { 1 } ^ { ( t ) } \geq 0 . 4 9 0 6 c _ { 1 } ^ { ( t ) } - 0 . 0 7 6 4 } \\ & { \qquad \geq 0 . 4 9 0 6 ( 0 . 1 8 9 1 f _ { 1 } ^ { ( t ) } + 0 . 0 3 4 1 \tilde { c } _ { 1 } ^ { ( t ) } - 0 . 3 2 7 1 ) - 0 . 0 7 6 4 } \\ & { \qquad \geq - 0 . 2 5 5 1 } \\ & { h _ { 1 } ^ { ( t ) } \leq 0 . 1 4 3 3 c _ { 1 } ^ { ( t ) } + 0 . 4 4 7 1 } \\ & { \qquad \leq 0 . 1 4 3 3 ( 0 . 1 5 9 6 f _ { 1 } ^ { ( t ) } + 0 . 3 9 4 5 \tilde { c } _ { 1 } ^ { ( t ) } + 0 . 8 5 5 6 ) + 0 . 4 4 7 1 } \\ & { \qquad \leq 0 . 6 5 5 6 } \end{array}
+$$
+
+i.e., $h _ { 1 } ^ { ( t ) } \in [ - 0 . 2 5 5 1 , 0 . 6 5 5 6 ]$ . An analogous computation is performed for $h _ { 2 } ^ { ( t ) }$ . In this example we will assume $h _ { 2 } ^ { ( t ) } = 0$ concretely.
+
+Robustness certification using DeepPoly The hidden states in the LSTM at the final timestep are passed through a fully connected layer without activation. In our example we assume that logits after the layer are obtained with the following formula: $l _ { 1 } = h _ { 1 } ^ { ( t ) } + 0 . 2 4$ and $l _ { 2 } = h _ { 2 } ^ { ( t ) }$ . These are shown in the final box of Fig. 2. To certify that the neural network classifies the input to class 1, we need to prove that $l _ { 1 } - l _ { 2 } > 0$ . We now apply the same back-substitution technique as Singh et al. (2019a):
+
+$$
+\begin{array} { r l } & { l _ { 1 } - l _ { 2 } = h _ { 1 } ^ { ( t ) } - h _ { 2 } ^ { ( t ) } + 0 . 2 4 } \\ & { \qquad \geq 0 . 4 4 9 0 6 ( 0 . 1 8 9 1 f _ { 1 } ^ { ( t ) } + 0 . 0 3 4 1 \tilde { c } _ { 1 } ^ { ( t ) } - 0 . 3 2 7 1 ) - 0 . 0 7 6 4 + 0 . 2 4 } \\ & { \qquad \quad = 0 . 0 9 2 7 1 f _ { 1 } ^ { ( t ) } + 0 . 0 1 6 \tilde { c } _ { 1 } ^ { ( t ) } + 0 . 0 0 3 1 } \\ & { \qquad \quad = 0 . 0 9 2 7 ( x _ { 1 } ^ { ( t ) } / 4 ) + 0 . 0 1 6 7 ( h _ { 1 } ^ { ( t - 1 ) } - x _ { 2 } ^ { ( t ) } / 4 ) + 0 . 0 0 3 1 } \\ & { \qquad \quad = 0 . 0 2 3 1 x _ { 1 } ^ { ( t ) } - 0 . 0 0 4 2 x _ { 2 } ^ { ( t ) } + 0 . 0 1 8 1 } \\ & { \qquad \quad = 0 . 0 2 3 1 ( \psi _ { 1 } ^ { ( t ) } - \psi _ { 2 } ^ { ( t ) } + 4 ) - 0 . 0 0 4 2 ( 4 \psi _ { 1 } ^ { ( t ) } - \psi _ { 2 } ^ { ( t ) } ) + 0 . 0 1 8 1 } \\ & { \qquad \quad = 0 . 0 0 6 3 \psi _ { 1 } ^ { ( t ) } - 0 . 0 1 8 9 \psi _ { 2 } ^ { ( t ) } + 0 . 1 1 0 5 } \\ & { \qquad \quad = 0 . 0 0 6 3 \cdot 1 . 0 9 8 6 - 0 . 0 1 8 9 \cdot 4 . 2 2 3 6 + 0 . 1 1 0 5 } \\ & { \qquad \quad > 0 . 0 0 6 3 \cdot 1 . 0 9 8 6 - 0 . 0 1 8 9 \cdot 4 . 2 2 3 6 + 0 . 1 1 0 5 } \\ & { \qquad \quad > 0 . 0 3 7 5 } \end{array}
+$$
+
+For the purpose of demonstration, we stop here and plug in previously obtained interval bounds for $\psi ^ { ( t ) }$ . As this value is greater than 0, robustness is established.
+
+# D MATHEMATICAL DERIVATION OF LSTM TRANSFORMER
+
+LSTM cell receives not only the resulting neurons from the pre-processing stage but a hidden state and a cell state from the previous timestep. To incorporate with all those incoming values, we extend the scope of the LSTM equations defined in Section 2. Let $d$ be the dimension of the input and $h$ be the dimension of states of the cell. To standardize the operations performed within the LSTM cell, we append $\mathbf { 0 } _ { d \times d } = [ 0 ] _ { d \times d }$ and $\mathbf { 0 } _ { d } = [ 0 ] _ { d }$ below to each kernel and bias respectively to express the formula as
+
+$$
+\begin{array} { r l } & { \pmb { f } _ { 0 } ^ { ( t ) } = [ \pmb { x } ^ { ( t ) } , \pmb { h } ^ { ( t - 1 ) } , \pmb { c } ^ { ( t - 1 ) } ] \pmb { W } _ { f } ^ { \prime } + \pmb { b } _ { f } ^ { \prime } \qquad \pmb { o } _ { 0 } ^ { ( t ) } = [ \pmb { x } ^ { ( t ) } , \pmb { h } ^ { ( t - 1 ) } , \pmb { c } ^ { ( t - 1 ) } ] \pmb { W } _ { o } ^ { \prime } + \pmb { b } _ { o } ^ { \prime } } \\ & { \pmb { i } _ { 0 } ^ { ( t ) } = [ \pmb { x } ^ { ( t ) } , \pmb { h } ^ { ( t - 1 ) } , \pmb { c } ^ { ( t - 1 ) } ] \pmb { W } _ { i } ^ { \prime } + \pmb { b } _ { i } ^ { \prime } \qquad \tilde { \pmb { c } } _ { 0 } ^ { ( t ) } = [ \pmb { x } ^ { ( t ) } , \pmb { h } ^ { ( t - 1 ) } , \pmb { c } ^ { ( t - 1 ) } ] \pmb { W } _ { \tilde { c } } ^ { \prime } + \pmb { b } _ { \tilde { c } } ^ { \prime } } \end{array}
+$$
+
+![](images/cc9de91fc14d93e00a578bfb6cb774149506ce13d7d1ad5d79698d422c1b57cc.jpg)  
+Figure 6: $\sigma ( x ) \cdot \operatorname { t a n h } ( y )$ boundings on $[ - 3 0 . 7 , 1 0 7 ] \times [ - 9 . 8 7 , - 0 . 0 2 ]$ . Orange plane is obtained from POPQORN and blue plane is from DAC.
+
+Then the cell state and hidden state computations can be rewritten as
+
+$$
+\begin{array} { r l } & { \qquad \mathbf { c } ^ { ( t ) } = \sigma ( f _ { 0 } ^ { ( t ) } ) \odot \mathbf { c } ^ { ( t - 1 ) } + \sigma ( i _ { 0 } ^ { ( t ) } ) \odot \mathrm { t a n h } ( \tilde { \mathbf { c } } _ { 0 } ^ { ( t ) } ) } \\ & { \qquad = \sigma \big ( [ \mathbf { x } ^ { ( t ) } , h ^ { ( t - 1 ) } , \mathbf { c } ^ { ( t - 1 ) } ] W _ { f } ^ { \prime } + b _ { f } ^ { \prime } \big ) \odot ( [ \mathbf { x } ^ { ( t ) } , h ^ { ( t - 1 ) } , \mathbf { c } ^ { ( t - 1 ) } ] [ \mathbf { 0 } _ { h \times ( d + h ) } , \mathbf { I } _ { h } ] ^ { T } ) } \\ & { \qquad + \sigma \big ( [ \mathbf { x } ^ { ( t ) } , h ^ { ( t - 1 ) } , \mathbf { c } ^ { ( t - 1 ) } ] W _ { i } ^ { \prime } + b _ { i } ^ { \prime } \big ) \odot \mathrm { t a n h } ( [ \mathbf { x } ^ { ( t ) } , h ^ { ( t - 1 ) } , \mathbf { c } ^ { ( t - 1 ) } ] W _ { \tilde { c } } ^ { \prime } + b _ { \tilde { c } } ^ { \prime } ) } \\ & { \qquad h ^ { ( t ) } = \sigma \big ( o _ { 0 } ^ { ( t ) } \big ) \odot \mathrm { t a n h } ( \mathbf { c } ^ { ( t ) } ) } \\ & { \qquad = \sigma \big ( [ \mathbf { x } ^ { ( t ) } , h ^ { ( t - 1 ) } , \mathbf { c } ^ { ( t - 1 ) } ] W _ { o } ^ { \prime } + b _ { o } ^ { \prime } \big ) \odot \mathrm { t a n h } ( \mathbf { c } ^ { ( t ) } ) } \end{array}
+$$
+
+As is described in detail in Section 5, $f ( x , y ) = \sigma ( x ) \cdot \operatorname { t a n h } ( y )$ and $g ( x , y ) = \sigma ( x ) \cdot y$ can be bounded with two planes regarding the operands’ lower and upper bounds. In other words, for any given two real values, $x , y \in \bar { \mathbb { R } } , x \mathrm { \bar { \in } } [ l _ { x } , \bar { u } _ { x } ] , y \in [ l _ { y } , u _ { y } ] .$ , our finding guarantees the planar bounds of $f$ and $g$ with the coefficients built by linear combination of $l _ { x } , u _ { x } , l _ { y } , u _ { y }$ . For a single neuron $c _ { j } ^ { ( t ) }$ in $\mathbf { \boldsymbol { c } } ^ { ( t ) }$ , the upper bound can be expressed from Eq. (2):
+
+$$
+\begin{array} { r l } { \mathbf { \Phi } _ { j } ^ { ( t ) } = \sigma ( [ \mathbf { x } ^ { ( t ) } , \mathbf { h } ^ { ( t - 1 ) } , c ^ { ( t - 1 ) } ] [ W _ { f } ^ { \prime } ] _ { : , j } + [ \mathbf { b } _ { f } ^ { \prime } ] _ { j } ) \cdot ( [ \mathbf { x } ^ { ( t ) } , \mathbf { h } ^ { ( t - 1 ) } , c ^ { ( t - 1 ) } ] [ \mathbf { 0 } _ { d + h } , [ I _ { h } ] _ { j } ; ] ^ { T } ) } & { } \\ { \mathbf { \Phi } } & { \qquad + \sigma ( [ \mathbf { x } ^ { ( t ) } , h ^ { ( t - 1 ) } , c ^ { ( t - 1 ) } ] [ W _ { i } ^ { \prime } ] _ { : , j } + [ \mathbf { b } _ { i } ^ { \prime } ] _ { j } ) \cdot \operatorname { t a n h } ( [ \mathbf { x } ^ { ( t ) } , \mathbf { h } ^ { ( t - 1 ) } , c ^ { ( t - 1 ) } ] [ W _ { c } ^ { \prime } ] _ { : , j } + [ \mathbf { b } _ { c } ^ { \prime } ] _ { j } ) } \\ { \leq \ A _ { u } ( [ \mathbf { x } ^ { ( t ) } , \mathbf { h } ^ { ( t - 1 ) } , c ^ { ( t - 1 ) } ] [ W _ { f } ^ { \prime } ] _ { : , j } + [ \mathbf { b } _ { i } ^ { \prime } ] _ { j } ) + B _ { u } ( [ \mathbf { x } ^ { ( t ) } , \mathbf { h } ^ { ( t - 1 ) } , c ^ { ( t - 1 ) } ] [ \mathbf { 0 } _ { d + h } , [ I _ { h } ] _ { j ; , 1 } ] ^ { T } ) + C _ { u } } & { } \\ { \mathbf { \Phi } } & { \qquad + D _ { u } ( [ \mathbf { x } ^ { ( t ) } , h ^ { ( t - 1 ) } , c ^ { ( t - 1 ) } ] [ W _ { i } ^ { \prime } ] _ { : , j } + [ \mathbf { b } _ { i } ^ { \prime } ] _ { j } ) + E _ { u } \big ( [ \mathbf { x } ^ { ( t ) } , h ^ { ( t - 1 ) } , c ^ { ( t - 1 ) } ] [ W _ { c } ^ { \prime } ] _ { : , j } + [ \mathbf { b } _ { c } ^ { \prime } ] _ { j } ) + F _ { u } } \\  = \mathbf { x } ^ { ( t ) } w _ { x } + h ^ { ( t - 1 ) } w _ { h } + c ^ { ( t - 1 ) } w \end{array}
+$$
+
+where $A _ { u } , \cdots , F _ { u }$ are calculated real values by Section 5, and $\textbf { \em w }$ · and $b$ are the simplified linear coefficients of each vector and bias term, respectively. We also can get the upper bound of ${ h } _ { j } ^ { ( t ) }$ by plugging Eq. (4) in Eq. (3), and similarly for the lower bounds of those states.
+
+Note these linear bounds makes possible to recursively apply this step to get desired bounds, and can be branched in any depth for the trade-off between the precision and the complexity.
+
+# E COMPARISON BETWEEN DAC AND POPQORN
+
+In this subsection we provide in-depth comparison between our approach and POPQORN (Ko et al., 2019) which provides another way to bound $\sigma ( x ) \cdot \operatorname { t a n h } ( y )$ and $\sigma ( x ) \cdot y$ non-linearities. Before the experiments, we discuss comparability between three methods to bound the non-linearities: interval, DAC and POPQORN. Then, we perform three different experiments. First, we compare volume of bounds produced by both POPQORN and DAC on a set of synthetic test cases. As these test cases do not reflect the actual test cases which occur during the verification of audio benchmarks, in the second set of experiments we compare the methods on a set of test cases from one of our benchmarks. Finally, in the third experiment we plug in POPQORN bounds into our framework and show its certification performance on the audio benchmarks.
+
+![](images/b9fa9505ba708b85452d0fc34e4d34661c1bb4a7cf4bbeed568e76c7b822b7f1.jpg)  
+Figure 7: Volume comparison with interval bounds with synthesized data. Excluded outliers.
+
+![](images/6abd2d8db2a008d65492d334e5d7c7607ff176b56eeb0b63644a8c21ff8b19d8.jpg)  
+Figure 8: Volume comparison with interval bounds with data from the working pipeline. Excluded outliers.
+
+Comparability of different bounding methods We say that methods A and B are pairwise noncomparable if there exists an input for which method A produces tighter bound than method B, and vice versa. Given this definition, POPQORN is non-comparable with our method. To demonstrate this, in Fig. 6 we show a case where this behavior is manifested. Here, for $y \le - 1$ POPQORN (shown as orange plane) produces tighter bound than DAC (shown as blue plane). However, for the other entire range of inputs where $- 1 0 \le y \le - 2$ , POPQORN bounds are substantially worse than our bounds. Further, those bounds are even worse than interval bounds and the overapproximation error is not bounded. Contrary to POPQORN, our bounds are always strictly better than interval bounds (this is proven in Theorem 1) and distance between the function and our planes is bounded.
+
+Comparison on synthetic test cases In this experiment, we compare bounds produced by POPQORN and DAC on a set of synthetic test cases, unrelated to the certification of audio classifiers. Both methods take $l _ { x } , u _ { x }$ and $l _ { y } , u _ { y }$ as bounds for the input to the sigmoid and tanh, respectively. We sample those inputs uniformly from $[ - 2 , 2 ] \times [ - 2 , 2 ]$ and compared the volume between the curve $\sigma ( x ) \cdot \operatorname { t a n h } ( y )$ and bounding planes produced by both DAC and POPQORN. The volume was computed using 1000 Monde Carlo samples in the set $[ l _ { x } , u _ { x } ] \times [ l _ { y } , u _ { y } ]$ . Since there are two $\sigma ( x ) \cdot \operatorname { t a n h } ( y )$ and one $\sigma ( x ) \cdot y$ calculation appearing in a single LSTM cell, we run the experiment with such portion of data. In other words, in $67 \%$ of experiments we bound $\sigma ( x ) \cdot \operatorname { t a n h } ( y )$ , and in $33 \%$ we bound $\sigma ( x ) \cdot y$ . We sampled 100 such inputs and compared the volumes obtained by POPQORN and DAC with the volume obtained using interval.
+
+The distribution of volumes is shown in Fig. 7. Here, 1 stands for the same volume as interval bounds and values less than 1 indicate performance better than intervals. We conclude that, for this experiment, POPQORN bounds produces smaller volume than our method - 0.2 compared to 0.37. In terms of runtime, POPQORN takes 14.37 seconds on average while the bound calculation of DAC finishes in few milliseconds.
+
+Direct comparison on test cases from audio benchmarks The previous experiment may not reflect the actual performance on audio benchmarks that we consider in this work. We uniformly sampled the arguments $l _ { x } , u _ { x } , l _ { y } , u _ { y }$ that our transformer for $\sigma ( x ) \cdot \operatorname { t a n h } ( y )$ and $\sigma ( x ) \cdot y$ was invoked with. We distinguish between test cases corresponding to different perturbation ranges and then further split it into certified and uncertified samples. For each of the cases, Fig. 8 shows the box plot of the distributions of volumes produced by both POPQORN and DAC.
+
+![](images/6e57bc93d50f8e77319b7759c803f2597f15a19dc4b9dd74bf63133f93b6e92c.jpg)  
+Figure 9: Robustness evaluation on FSDD with error bars.
+
+We found that, while overall POPQORN bounds work well in practice, they frequently produce bounds less precise than interval bounds. The reason of this malfunctioning comes from the limitation of gradient descent approach employed by POPQORN. The gradient of the function, which POPQORN uses to search for the optimal bounds, is large when the inputs are distributed near 0. However, if the inputs are far from the origin or are too close to each other, the function curve becomes almost flat, gradients are close to zero and gradient descent has problems converging. Also, in other cases, gradient descent is not guaranteed to find the bounds with minimum volume. Fig. 6 shows one of the examples where POPQORN fails to find lower planar bound which produces minimum volume. On the contrary, the resulting value of $\sigma ( x ) \cdot \operatorname { t a n h } ( y )$ is within $[ - 1 , 1 ]$ regardless of the magnitude of arguments which means that the error produced by intervals is bounded. As our planar bounds are strictly better than intervals, regardless of input conditions, our error is also bounded.
+
+Plugging in POPQORN bounds into DAC We also experimented with using POPQORN bounds instead of our bounds in the pipeline and compared the final adversarial regions with those resulting from DAC. As POPQORN is relatively slow (108 minutes per sample), we performed this experiment only on the first 10 inputs with $- 8 0 d B$ perturbation. Using their bounds results in 0 verified samples, while DAC verifies 4 samples. We believe the reason here is the existence of many pathological cases as described in the previous point where gradient descent used by POPQORN converges to suboptimal solution which ends up being worse than interval bounds. These errors are further propagated through each frame and resulting output can not be certified.
+
+# F SENSITIVITY OF PROVABILITY METRIC
+
+In our experiments, we followed the convention of provability measurement from Singh et al. (2019b). Here, we also provide the result with error bars from 10 independent repetitions with randomly permuted test set. For each repetition, we randomly permute the test set with the different seed and collect the first 100 samples with the correct prediction under zero perturbation from the ordered set. We then count the number of certified inputs from those samples to represent the provability under the given constant . Fig. 9 shows that provabilities do not differ much from the reported results for multiple experiments.
+
+# G TRAINING WITH PROVABLE DEFENSE WITH IBP
+
+Here we give more details on our training procedure for provably defended network which follows Mirman et al. (2018); Gowal et al. (2018). Let $z ^ { L B } ( \epsilon )$ and $z ^ { U B } ( \epsilon )$ be the resulting lower and upper bounds for the final logit $z \in \mathbb { R } ^ { d }$ under the perturbation size $\epsilon$ , with the true label $j \bar { \in } \{ 0 , \cdot \cdot \cdot , d - 1 \}$ . We define the worst-case logits $\hat { z } ( \epsilon )$ as
+
+$$
+\hat { z } _ { i } ( \epsilon ) = \left\{ { z } _ { i } ^ { L B } ( \epsilon ) \begin{array} { l l } { i = j } \\ { z _ { i } ^ { U B } ( \epsilon ) } & { i \ne j } \end{array} \right.
+$$
+
+which corresponds to the worst concrete logits under the given input with the predefined perturbation amount. Recall that we say the input is certified when this worst-case logits satisfy $j = \arg \operatorname* { m a x } _ { i } \hat { z } _ { i }$ .
+
+![](images/cc6ab09c4837b5a96b480426b27236530d4676cef6c2859391015bce23e1232e.jpg)  
+Figure 10: defended GSC, $82 \%$ .
+
+Table 3: Model parameters used in the experiments.   
+
+<table><tr><td>params</td><td>FSDD</td><td>GSC</td></tr><tr><td>Frame size N</td><td>256</td><td>512</td></tr><tr><td>Frame step s</td><td>200</td><td>400</td></tr><tr><td>Number of flters p Hidden neurons h</td><td>10 40</td><td>10 40</td></tr><tr><td></td><td></td><td></td></tr><tr><td>Learning rate Batch size</td><td>0.001</td><td>0.001</td></tr><tr><td></td><td>5</td><td>50</td></tr></table>
+
+Training loss $L$ is a linear combination of the standard cross-entropy loss $l ( z , e ^ { ( j ) } )$ and the worst-case cross-entropy loss $l ( \hat { z } , e ^ { ( j ) } )$ where $e ^ { ( j ) }$ is target one-hot vector, i.e.,
+
+$$
+L ( t ^ { \prime } ) = \kappa ( t ^ { \prime } ) l ( z , \pmb { e } ^ { ( j ) } ) + ( 1 - \kappa ( t ^ { \prime } ) ) l ( \hat { z } ( \epsilon ( t ^ { \prime } ) ) , \pmb { e } ^ { ( j ) } )
+$$
+
+Note that we set up the $\kappa$ and $\epsilon$ as the function of $t ^ { \prime }$ . As in Gowal et al. (2018), gradual increase/decrease of these parameters during the training was essential to get desired performance. We set these functions with respect to the number of training epochs $E$ as
+
+$$
+\begin{array}{c} \begin{array} { l c l } { \kappa ( t ) = \left\{ 1 - t / E \right.} & { t < E / 2 } \\ { 1 / 2 } & { o t h e r w i s e } \\ { \epsilon ( t ) = - 7 0 - ( 2 0 0 - 7 0 ) ^ { 1 - t / E } . } \end{array}   \end{array}
+$$
+
+Also, to track the training speed, we increase one by one $t ^ { \prime }$ only if we are achieving $85 \%$ of standard accuracy and $80 \%$ provability at the current setting. The models were built under the $E = 6 0$ .
+
+We also attach the missing result of defended GSC with $82 \%$ concrete accuracy in Fig. 10.
+
+# H MODEL PARAMETERS USED IN THE EXPERIMENTS
+
+We perform the experiments with the same architecture with different model parameters for FSDD and GSC. Table 3 shows the parameters of the models we use. Both defended and undefended networks share the same parameters for each dataset.

parse/train/c0O9vBVSvIl/c0O9vBVSvIl.md

@@ -0,0 +1,358 @@
+# Variational Model Inversion Attacks
+
+Kuan-Chieh Wang1,2,† Yan Fu1 Ke Li3 Ashish Khisti1 Richard Zemel1,2 Alireza Makhzani1,2,§ University of Toronto1, Vector Institute2, Simon Fraser University3 †wangkua1@cs.toronto.edu, §makhzani@vectorinstitute.ai
+
+# Abstract
+
+Given the ubiquity of deep neural networks, it is important that these models do not reveal information about sensitive data that they have been trained on. In model inversion attacks, a malicious user attempts to recover the private dataset used to train a supervised neural network. A successful model inversion attack should generate realistic and diverse samples that accurately describe each of the classes in the private dataset. In this work, we provide a probabilistic interpretation of model inversion attacks, and formulate a variational objective that accounts for both diversity and accuracy. In order to optimize this variational objective, we choose a variational family defined in the code space of a deep generative model, trained on a public auxiliary dataset that shares some structural similarity with the target dataset. Empirically, our method substantially improves performance in terms of target attack accuracy, sample realism, and diversity on datasets of faces and chest $\mathrm { X }$ -ray images.
+
+# 1 Introduction
+
+Thanks to recent advances, deep neural networks are now widely used in applications including facial recognition [Parkhi et al., 2015], intelligent automated assistants, and personalized medicine [Consortium, 2009; Sconce et al., 2005]. Powerful deep neural networks are trained on large datasets that could contain sensitive information about individuals. Publishers release only the trained models (e.g., on TensorFlow Hub [TensorFlow]), but not the original dataset to protect the privacy of individuals whose information is in the training set. Regrettably, the published model can leak information about the original training set [Geiping et al., 2020; Nasr et al., 2019; Shokri et al., 2017]. Attacks that exploit such properties of machine learning models are privacy attacks [Rigaki and Garcia, 2020]. Other real-world scenarios where an attacker can access models trained on private datasets include interaction with APIs (e.g., Amazon Rekognition [AWS]), or in the growing paradigm of federated learning [Bonawitz et al., 2019; Yang et al., 2019a], where a malicious insider can try to steal data from other data centers [Hitaj et al., 2017]. Kaissis et al. [2020] provides an overview of how these privacy concerns are hindering the widespread application of deep learning in the medical domain.
+
+This paper focuses on the model inversion (MI) attack, a type of privacy attack that tries to recover the training set given access only to a trained classifier [Chen et al., 2020; Fredrikson et al., 2015, 2014; Hidano et al., 2017; Khosravy et al., 2020; Yang et al., 2019b; Zhang et al., 2020]. The classifier under attack is referred to as the “target classifier” (see Figure 1). An important relevant application concerns identity recognition from face images, since facial recognition is a common approach to biometric identification [Galbally et al., 2014; Rathgeb and Uhl, 2011]. Once an attacker successfully reconstructs images of the faces of individuals in the private training set, they can use the stolen identity to break into otherwise secure systems.
+
+Early studies of MI attacks focused on attacking classifiers whose inputs are tabular data [Fredrikson et al., 2015, 2014; Hidano et al., 2017] by directly performing inference in the input space. However, the same methods fail when the target classifier processes high-dimensional inputs, e.g., in the above example of a face recognizer. Recent methods cope with this high-dimensional search space by performing the attack in the latent space of a neural network generator [Khosravy et al., 2020; Yang et al., 2019b; Zhang et al., 2020]. Introducing a generator works well in practice, but this success is not theoretically understood. In this paper, we frame MI attacks as a variational inference (VI) [Blei et al., 2017; Jordan et al., 1999; Kingma and Welling, 2013] problem, and derive a practical objective. This view allows us to justify existing approaches based on a deep generative model, and identify missing ingredients in them. Empirically, we find that our proposed objective leads to significant improvements: more accurate and diverse attack images, which are quantified using standard sample quality metrics (i.e., FID [Heusel et al., 2017], precision, and recall [Kynkäänniemi et al., 2019; Naeem et al., 2020]).
+
+![](images/854832cd91e0cbc7ed962ec78589eaa388141fda1ee3b8752003cba533466cb0.jpg)  
+Figure 1: In model inversion attacks, the attacker tries to recover the original dataset used to train a classifier with access to only the trained classifier. In the two figures on the right, each row corresponds to a private identity – an individual whose images are not available to the attacker. The first five identities (not cherry-picked) were visualized. On the left are real data samples, and on the right are generated samples from our proposed method.
+
+In summary, our contributions and findings are:
+
+• We view the model inversion (MI) attack problem as a variational inference (VI) problem. This view allows us to derive a practical objective based on a statistical divergence, and provides a unified framework for analyzing existing methods.   
+• We provide an implementation of our framework using a set of deep normalizing flows [Dinh et al., 2014, 2016; Kingma and Dhariwal, 2018] in the extended latent space of a StyleGAN [Karras et al., 2020]. This implementation can leverage the hierarchy of learned representations, and perform targeted attacks while preserving diversity.   
+• Empirically, on the CelebA [Liu et al., 2015], and ChestX-ray [Wang et al., 2017] datasets, our method results in higher attack accuracy, and more diverse generation compared to existing methods. We provide thorough comparative experiments to understand which components contribute to improved target accuracy, sample realism, and sample diversity, and detail the benefits of the VI perspective.
+
+Code can be found at https://github.com/wangkua1/vmi.
+
+# 2 Problem Setup: Model Inversion Attack
+
+In the problem of model inversion (MI) attack, the attacker has access to a “target classifier”:
+
+$$
+\overline { { p } } _ { \mathtt { T A R } } ( y | \mathbf { x } ) : \mathbb { R } ^ { d } \to \Delta ^ { C - 1 }
+$$
+
+where $\Delta ^ { C - 1 }$ to denote the $( C - 1 )$ -simplex, representing the $C$ -dimensional probability where $C$ is the number of classes. This target classifier is trained on the private target dataset, $\mathcal { D } _ { \mathrm { T A R } } = \{ { \bf x } _ { i } , y _ { i } \} _ { i = 1 } ^ { N _ { \mathrm { T A R } } }$ where $\mathbf { x } \in \mathbb { R } ^ { d }$ and $y \in \{ 1 , 2 , . . . , C \}$ . We use $\overline { { p } } _ { \mathrm { T A R } } ( y | \mathbf { x } )$ to denote the given target classifier, which is an approximation of the true conditional probability $p _ { \mathrm { T A R } } ( y | \mathbf { x } )$ of the underlying data generating distribution.
+
+Goal. Given a target classifier $\overline { { p } } _ { \mathrm { T A R } } ( y | \mathbf { x } )$ , we wish to approximate the class conditional distribution $p _ { \mathrm { T A R } } ( \mathbf { x } | y )$ without having access to the private training set $\mathcal { D } _ { \mathrm { T A R } }$ .
+
+A good model inversion attack should approximate the Bayes posterior $p _ { \mathtt { T A R } } ( \mathbf { x } | y ) \propto p _ { \mathtt { T A R } } ( y | \mathbf { x } ) p _ { \mathtt { T A R } } ( \mathbf { x } )$ well, and allow the attacker to generate realistic, accurate, and diverse samples. Notice, our goal shifts slightly from recovering the exact instances in the training set to recovering the data generating distribution of the training data. Let’s consider a scenario where the attacker intends to fake a victim’s identity. A good security system might test the realism of a sequence of inputs [Holland and Komogortsev, 2013]. More generally, faking someone’s identity requires passing a two-sample test [Holland and Komogortsev, 2013; Lehmann and Romano, 2006], which means the ability to generate samples from $p _ { \mathrm { T A R } } ( \mathbf { x } | y )$ is necessary. Another scenario can be an attacker trying to steal private/proprietary information. For example, a malicious insider in a federated learning setting can try to steal information from another datacenter by accessing the shared model [Hitaj et al., 2017]. In such a scenario, a good $p _ { \mathrm { T A R } } ( \mathbf { x } | y )$ model can reveal not only the distinguishing features of the data, but also its variations.
+
+# 3 Related Work
+
+In this section, we first discuss related model inversion attack studies, and then discuss applications of inverting a classifier outside of the privacy attack setting. Lastly, since our attack method relies on using a pretrained generator, we discuss existing studies that used a pretrained generator for improving other applications.
+
+Model inversion attacks. MI attacks are one type of privacy attack where the attacker tries to reconstruct the training examples given access only to a target classifier. Other privacy attacks include membership attacks, attribute inference, and model extraction attacks (see Rigaki and Garcia [2020] for a general discussion). Fredrikson et al. [Fredrikson et al., 2015, 2014] were the first to study the MI attack and demonstrated successful attacks on low-capacity models (e.g., logistic regression, and a shallow MLP network) when partial input information was available to the attacker. The setting where partial input information was not available was studied by Hidano et al. [2017]. They termed performing gradient ascent w.r.t. the target classifier in the input space a General Model Inversion attack. Though effective on tabular data, this approach failed on deep image classifiers. It is well-known that directly performing gradient ascent in the image space results in imperceptible and unnatural changes [Szegedy et al., 2013].
+
+To handle high-dimensional observations such as images, MI attacks based on deep generators were proposed [Chen et al., 2020; Yang et al., 2019b; Zhang et al., 2020]. By training a deep generator on an auxiliary dataset, these methods effectively reduce the search space to only the manifold of relevant images. For example, if the target classifier is a facial recognition system, then an auxiliary dataset of generic faces can be easily obtained. Zhang et al. [2020] pretrain a Generative Adversarial Network (GAN) [Goodfellow et al., 2014] on the auxiliary dataset and performed gradient-based attack in the latent space of the generator. Yang et al. [2019b] trained a generator that inverts the prediction of the target classifier, using the architecture of an autoencoder.
+
+Other applications of classifier inversion. Inverting the predictions and activations of a classifier has been studied for applications such as model explanation, and model distillation. Motivated by using saliency maps to explain the decision of a classifier [Simonyan et al., 2013], Mahendran and Vedaldi [2015] proposed to maximize the activation of a target neuron in a classifier for synthesizing images that best explain that neuron. Their method is based on gradient ascent in the pixel-space. The same idea was recently extended to enable knowledge distillation in a setting where the original dataset was too large to be transferred [Yin et al., 2020]. Methods above have the advantage of not requiring the original dataset, but the generated images still appear unnatural. One effective way to improve the realism of the generated images is to optimize in the latent code space of a deep generator [Nguyen et al., 2015, 2017].
+
+Pretrained generators. Pretrained generators from GANs have other applications. Image inpainting/restoration was one of the early successful applications of using a pretrained GAN as image prior. Yeh et al. [2017] optimized the latent code of GANs to minimize the reconstruction error of a partially occluded image for realistic inpainting. The same method formed the basis of AnoGAN, a popular technique for anomaly detection in medical images [Schlegl et al., 2017]. A combination of reconstruction error and discriminator loss was used as the anomaly score. A potential future direction is to apply our proposed method to these adjacent applications.
+
+# 4 Model Inversion Attack as Variational Inference
+
+In this section, we derive our Variational Model Inversion (VMI) learning objective. For each class label $y$ , we wish to approximate the true target posterior with a variational distribution $q ( \mathbf { x } ) \in \mathcal { Q } _ { \mathbf { x } }$ , where $\mathcal { Q } _ { \bf x }$ is the variational family. This can be achieved by the optimizing the following objectives
+
+$$
+\begin{array} { r l } & { q ^ { * } ( \mathbf { x } ) = \underset { q \in \mathcal { Q } _ { \mathbf { x } } } { \arg \operatorname* { m i n } } \left. D _ { \mathrm { K L } } ( q ( \mathbf { x } ) | | p _ { \mathrm { r a R } } ( \mathbf { x } | y ) ) \right. } \\ & { \qquad = \underset { q \in \mathcal { Q } _ { \mathbf { x } } } { \arg \operatorname* { m i n } } \left. \mathbb { E } _ { q ( \mathbf { x } ) } [ - \log p _ { \mathrm { r a R } } ( y | \mathbf { x } ) ] + D _ { \mathrm { K L } } ( q ( \mathbf { x } ) | | p _ { \mathrm { r a R } } ( \mathbf { x } ) ) + \log p _ { \mathrm { r a R } } ( y ) \right. } \\ & { \qquad = \underset { q \in \mathcal { Q } _ { \mathbf { x } } } { \arg \operatorname* { m i n } } \left. \mathbb { E } _ { q ( \mathbf { x } ) } [ - \log p _ { \mathrm { r a R } } ( y | \mathbf { x } ) ] + D _ { \mathrm { K L } } ( q ( \mathbf { x } ) | | p _ { \mathrm { r a R } } ( \mathbf { x } ) ) \right. . } \end{array}
+$$
+
+where in Equation 1 we have used the fact that $\log p _ { \mathrm { T A R } } ( y )$ is independent of $q ( \mathbf { x } )$ , and thus can be dropped in the optimization.
+
+Auxiliary Image Prior. In order to minimize Eq. (1), we need to compute $D _ { \mathrm { K L } } ( q ( \mathbf { x } ) | | p _ { \mathrm { T A R } } ( \mathbf { x } ) )$ , which requires evaluating the true image prior $p _ { \mathrm { T A R } } ( \mathbf { x } )$ , that is not accessible. Similar to recent works on MI attacks [Khosravy et al., 2020; Yang et al., 2019b; Zhang et al., 2020], we assume that a public auxiliary dataset ${ \mathcal { D } } _ { \mathrm { A U X } }$ , which shares structural similarity with the target dataset, is available to learn an auxiliary image prior $p _ { \mathrm { A U X } } ( \mathbf { x } )$ . This auxiliary image prior $p _ { \mathrm { A U X } } ( \mathbf { x } )$ is learned using a generative adversarial network (GAN) $p _ { \mathrm { A U X } } ( \mathbf { x } ) = \mathbb { E } _ { p _ { \mathrm { A U X } } ( \mathbf { \bar { z } } ) } [ p _ { \mathrm { G } } ( \mathbf { \bar { x } } | \mathbf { \bar { z } } ) ]$ , where $p _ { \mathrm { A U X } } ( \mathbf { z } ) = \mathcal { N } ( 0 , I )$ is the GAN prior, and $p _ { \mathrm { G } } ( \mathbf { x } | \mathbf { z } )$ is the GAN generator that is parameterized by a deep neural network $G ( \mathbf { z } )$ , and a Gaussian observation noise with small standard deviation $\sigma \colon p _ { \mathtt { G } } ( \mathbf { x } | \mathbf { z } ) = { \mathcal { N } } { \big ( } G ( \mathbf { z } ) , \sigma ^ { 2 } I { \big ) }$ , or equivalently
+
+$$
+\begin{array} { r } { \mathbf { x } = G ( \mathbf { z } ) + \sigma \epsilon , \quad \epsilon \sim \mathcal { N } ( 0 , I ) . } \end{array}
+$$
+
+The learned generator $p _ { \mathrm { G } } ( \mathbf { x } | \mathbf { z } )$ defines a low dimensional manifold in the observation space $\mathbf { x }$ , when $\mathbf { z }$ is chosen to have fewer dimensions than $\mathbf { x }$ . We now make the following assumption about the structural similarity of $p _ { \mathrm { A U X } } ( \mathbf { x } )$ and $p _ { \mathrm { T A R } } ( \mathbf { x } )$ .
+
+Assumption 1 (Common Generator). We assume $p _ { \mathrm { T A R } } ( \mathbf { x } )$ is concentrated close to the low dimensional manifold of $p _ { \mathrm { G } } ( \mathbf { x } | \mathbf { z } )$ , learned from the auxiliary dataset $\mathcal { D } _ { \mathrm { A U X } }$ . In other words, we assume there exists a target prior $p _ { \mathrm { T A R } } ( \mathbf { z } )$ , possibly different from $p _ { \mathrm { A U X } } ( \mathbf { z } )$ , such that $p _ { \mathtt { T A R } } ( \mathbf { x } ) \approx \mathbb { E } _ { p _ { \mathtt { T A R } } ( \mathbf { z } ) } [ p _ { \mathtt { G } } ( \mathbf { x } | \mathbf { z } ) ]$ . We refer to $p _ { \mathrm { G } } ( \mathbf { x } | \mathbf { z } )$ as the “common generator”.
+
+The name “common generator” is inspired by recent progress in theoretical analyses of few-shot and transfer learning, where assumptions about an underlying shared representation have been used to provide error bounds. In these works, this shared representation is referred to as the “common representation” [Du et al., 2020; Tripuraneni et al., 2020]. Assumption 1 usually holds in the context of model inversion attacks. For example, $p _ { \mathrm { A U X } } ( \mathbf { x } )$ could be the distribution of all human faces, while $p _ { \mathrm { T A R } } ( \mathbf { x } )$ could be the distribution of the celebrity faces; or $p _ { \mathrm { A U X } } ( \mathbf { x } )$ could be the distribution of natural images, while $p _ { \mathrm { T A R } } ( \mathbf { x } )$ could be the distribution of different breeds of dogs. In these examples, both $p _ { \mathrm { A U X } } ( \mathbf { x } )$ and $p _ { \mathrm { T A R } } ( \mathbf { x } )$ approximately live close to the same low dimensional manifold, but the distribution on this shared manifold could be different, i.e., $p _ { \mathtt { T A R } } ( \mathbf { z } ) \neq p _ { \mathtt { A U X } } ( \mathbf { z } )$ .
+
+Variational Family. We further consider our variational family $\mathcal { Q } _ { \bf x }$ to be all distributions that lie on this manifold by assuming that $q ( \mathbf { x } )$ is of the form $q ( \mathbf { x } ) = \mathbb { E } _ { q ( \mathbf { z } ) } [ p _ { \mathrm { G } } ( \mathbf { x } | \mathbf { z } ) ]$ , $q ( \mathbf { z } ) \in \mathcal { Q } _ { \mathbf { z } }$ , where $\mathcal { Q } _ { \mathbf { z } }$ is a variational family in the code space. In the next section, we further restrict $\mathcal { Q } _ { \mathbf { z } }$ to be either Gaussian distributions or normalizing flows.
+
+Proposition 1. We have $D _ { \mathrm { K L } } \big ( q ( \mathbf { z } ) | | p _ { \mathrm { T A R } } ( \mathbf { z } ) \big ) \geq D _ { \mathrm { K L } } \big ( \mathbb { E } _ { q ( \mathbf { z } ) } [ p _ { \mathrm { G } } ( \mathbf { x } | \mathbf { z } ) ] | | \mathbb { E } _ { p _ { \mathrm { T A R } } ( \mathbf { z } ) } [ p _ { \mathrm { G } } ( \mathbf { x } | \mathbf { z } ) ] \big ) .$
+
+See Appendix A for the proof. Using Assumption 1, we can approximate the objective of Equation 1 with
+
+$$
+\mathbf { \Sigma } ^ { * } ( \mathbf { z } ) = \underset { q \in \mathcal { Q } _ { \infty } } { \operatorname { a r g m i n } } \left. \mathbb { E } _ { \mathbf { z } \sim q ( \mathbf { z } ) , \epsilon \sim \mathcal { N } ( 0 , I ) } [ - \log p _ { \mathrm { r a g } } ( y | G ( \mathbf { z } ) + \sigma \epsilon ) ] + D _ { \mathrm { K L } } \big ( \mathbb { E } _ { q ( \mathbf { z } ) } [ p _ { \mathrm { o } } ( \mathbf { x } | \mathbf { z } ) ] | | \mathbb { E } _ { p _ { \mathrm { r a g } } ( \mathbf { z } ) } [ p _ { \mathrm { o } } ( \mathbf { x } | \mathbf { z } ) ] \big ) \right. ,
+$$
+
+where this objective is now defined in terms of $q ( \mathbf { z } ) \in \mathcal { Q } _ { \mathbf { z } }$ in the latent space of the GAN. Now using the Proposition 1, we can obtain the following upper bound on the objective of Equation 2 (assuming $\sigma = 0$ )
+
+$$
+\begin{array} { r } { q ^ { * } ( \mathbf { z } ) = \underset { q \in \mathcal { Q } _ { \mathbf { z } } } { \arg \operatorname* { m i n } } \left\{ \mathbb { E } _ { \mathbf { z } \sim q ( \mathbf { z } ) } [ - \log p _ { \mathrm { T A R } } ( y | G ( \mathbf { z } ) ) ] + D _ { \mathrm { K L } } ( q ( \mathbf { z } ) | | p _ { \mathrm { T A R } } ( \mathbf { z } ) ) \right\} . } \end{array}
+$$
+
+Power Posteriors. We now consider the optimization of Equation 3. Since we do not have access to $p _ { \mathrm { T A R } } ( \mathbf { z } )$ , we propose to replace it with $p _ { \mathrm { A U X } } ( \mathbf { z } )$ , noting that, as argued above, $p _ { \mathrm { A U X } } ( \mathbf { z } )$ may not accurately represent $p _ { \mathrm { T A R } } ( \mathbf { z } )$ . We also propose to replace the unknown likelihood $p _ { \mathrm { T A R } } ( y | G ( \mathbf { z } ) )$ with the $\overline { { p } } _ { \mathrm { T A R } } ( y | G ( \mathbf { z } ) )$ defined by the target classifier, noting that this likelihood could be miscalibrated. Miscalibration is a known problem in neural network classifiers [Guo et al., 2017]; namely, the classifier predictions can be over- or under-confident. In order to account for these issues, instead of the standard Bayes posterior $q _ { \mathtt { B A Y E S } } ( \mathbf { z } ) \propto p _ { \mathrm { A U X } } ( \mathbf { z } ) \overline { { p } } _ { \mathtt { T A R } } ( y | G ( \mathbf { z } ) )$ as the solution of Equation 3, we consider the family of “power posterior” 1 [Bissiri et al., 2016; Holmes and Walker, 2017; Knoblauch et al., 2019; Miller and Dunson, 2018], which raise the likelihood function to a power $\frac { 1 } { \gamma }$
+
+$$
+q _ { \gamma } ^ { * } ( \mathbf { z } ) \propto p _ { \mathrm { A U X } } ( \mathbf { z } ) \overline { { p } } _ { \mathrm { T A R } } ^ { \frac { 1 } { \gamma } } ( y | G ( \mathbf { z } ) ) ,
+$$
+
+and can be characterized as the solution of the following optimization problem:
+
+$$
+\begin{array} { r } { \begin{array} { r l } & { q _ { \gamma } ^ { * } ( \mathbf { z } ) = \underset { q \in \mathcal { Q } _ { \mathbf { z } } } { \arg \operatorname* { m i n } } \mathcal { L } _ { \mathrm { v u r } } ^ { \gamma } ( q ) , } \\ & { \mathcal { L } _ { \mathrm { v M I } } ^ { \gamma } ( q ) : = \mathbb { E } _ { \mathbf { z } \sim q ( \mathbf { z } ) } [ - \log \overline { { p } } _ { \mathrm { T A R } } ( y | G ( \mathbf { z } ) ) ] + \gamma D _ { \mathrm { K L } } ( q ( \mathbf { z } ) | | p _ { \mathrm { A U X } } ( \mathbf { z } ) ) . } \end{array} } \end{array}
+$$
+
+See Appendix A for the proof. If the prior $p _ { \mathrm { A U X } } ( \mathbf { z } )$ is not reliable, by decreasing $\gamma$ , we can reduce the importance of the prior. Similarly, by adjusting $\gamma$ , we can reduce or increase the importance of overor under-confident likelihood predictions $\overline { { p } } _ { \mathrm { T A R } } ( y | G ( \mathbf { z } ) )$ .
+
+Accuracy vs. Diversity Tradeoff. In the context of model inversion attack, the Bayes posterior $q _ { \mathrm { B A Y E S } } ( \mathbf { z } )$ can only achieve a particular tradeoff between the accuracy and diversity of the generated samples. However, the family of power posteriors enables us to achieve an arbitrary desired tradeoff between accuracy and diversity by tuning $\gamma$ . If $\gamma = 0$ , then ${ q } _ { \gamma = 0 } ^ { * } ( \mathbf { z } ) = \delta ( \mathbf { z } - \mathbf { z } ^ { * } )$ , and the model essentially ignores the image prior and diversity, and finds a single point estimate $\mathbf { z } ^ { \ast }$ on the manifold which maximizes the accuracy $\overline { { p } } _ { \mathrm { T A R } } ( y | G ( \mathbf { z } ) )$ . As we increase $\gamma$ , the the model achieves larger diversity at the cost of smaller average accuracy. When $\gamma = 1$ , we recover the Bayes posterior $q _ { \gamma = 1 } ^ { * } ( \mathbf { z } ) \propto p _ { \mathrm { A U X } } ( \mathbf { z } ) \overline { { p } } _ { \mathrm { T A R } } ( y | G ( \mathbf { z } ) )$ . In the limit of $\gamma \to \infty$ , we have $q _ { \infty } ^ { * } ( \mathbf { z } ) \ = \ p _ { \mathrm { A U X } } ( \mathbf { z } )$ . In this case, the model ignores the classifier and accuracy, and sample unconditionally from the auxiliary distribution (maximum diversity). We empirically study the effect of $\gamma$ in Section 5.
+
+# 4.1 The Common Generator
+
+In the previous section, we derived a practical MI objective from the perspective of variational inference. Similar to previous works [Chen et al., 2020; Zhang et al., 2020] VMI requires a common generator that is trained on a relevant auxiliary dataset. In this subsection, we first provide a brief description of the most common choice, DCGAN. Then, we introduce StyleGAN, which has an architecture that allows for fine-grained control. Finally, we describe how to adapt our VMI objective to leverage this architecture by using a layer-wise approximate distribution.
+
+For the common generator $G$ we use a GAN due to their ability to synthesize high quality samples [Abdal et al., 2019; Bau et al., 2018; Karras et al., 2019; Shen et al., 2020]. The generator is trained on the auxiliary dataset. A common choice is the DCGAN architecture [Radford et al., 2015]. Though optimizing in the latent space results in more realistic samples, this search space is also more restrictive. Early investigation showed that optimizing at some intermediate layers of a pretrained generator was better than either optimizing in the code space, or the pixel space. This motivated the use of a generator architecture where activations of intermediate layers can be manipulated.
+
+StyleGAN. A framework that naturally allows for optimization in the intermediate layers is the $S$ yleGAN [Karras et al., 2019]. It consists of a mapping network . The synthesis network takes as input one w at each layer, $f : \mathbf { z } \mapsto \mathbf { w }$ $\dot { S } : \{ \mathbf { w } _ { l } \} _ { l = 1 } ^ { L } \mapsto \mathbf { x }$ ynthesis, where $L$ etworkis the number of layers in $S$ . During training of a StyleGAN, the output from the mapping network is copied $L$ times, $\{ \mathbf { w } \} _ { l = 1 } ^ { L } = \mathrm { c o p y } ( \mathbf { w } , L )$ before being fed to the synthesis network. This input space of the synthesis network $S$ has been referred to as the “extended w space” [Abdal et al., 2019]. The full generator is $G _ { \mathrm { { s T Y L E } } } ( \mathbf { z } ) = S \Big ( \mathrm { { c o p Y } } \big ( f ( \mathbf { z } ) , L \big ) \Big )$ .
+
+![](images/12ec27e7922d22da99dc0038a4dad4044670322e1e61a5df1a47bb3f6890abcf.jpg)  
+Figure 2: Visualizing the factors of variations in each layer of the StyleGAN [Karras et al., 2019] using style mixing. Each image is generated by mixing the the corresponding image in the topmost row, and the image in the leftmost column. The topmost row image provides the features for the indicated set of layers, and the leftmost column image provides features for the remaining layers. We can see that in general, the earlier features contribute more to the facial features, while the later features contribute more to the low-level images statistics such as lighting and general shading. Given this learned layer-wise disentanglement, our VMI attack can adaptively discover layers that contribute the most to the face identity (layers $1 , 2 , 4 , 5 , 6$ ), and only manipulates the corresponding features (see Figure 7). This is not facilitated by the generator of a DCGAN, as found in existing MI attack methods [Chen et al., 2020; Zhang et al., 2020].
+
+StyleGAN is known for its surprising ability to perform “style mixing”. Namely, the synthesis network can generate a “mixed” image, when being fed a mixture of two w’s in the extended w space, i.e., $S ( [ \{ \mathbf { w } _ { 1 } \} _ { l = 1 } ^ { L _ { 0 } } ; \{ \mathbf { w } _ { 2 } \} _ { l = L _ { 0 } + 1 } ^ { L } ] )$ , where $[ \cdot ; \cdot ]$ denotes concatenation, and $L _ { 0 }$ is some intermediate layer. Figure 2 visualizes the effect of manipulating different layers of the synthesis network. Performing an attack in this extended w space allows us to achieve the desired effect of optimizing the intermediate layers. Because of the lack of a explicit prior for w, we instead optimize the extended $\mathbf { z }$ space (Figure 3).
+
+Suppose $q ( \mathbf { z } _ { 1 } , \ldots , \mathbf { z } _ { L } )$ is the joint density over
+
+![](images/910cdcdabf56a3637cb3e8d21ef8fd25417c343f6fdd544fe4629c8f3d804149.jpg)  
+Figure 3: Utilizing the StyleGAN architecture, our VMI attack tends to focus on layers whose representation are relevant for the attack, such as the layer for “face shape”.
+
+$\mathbf { z } _ { 1 } , \ldots , \mathbf { z } _ { L }$ , and $q _ { l } ( { \bf z } _ { l } )$ is the marginal density over $\mathbf { z } _ { l }$ . We consider the following objective for the VMI with the StyleGAN generator:
+
+$$
+\mathcal { L } _ { \mathrm { s - v M } } ^ { \gamma } ( q ) : = \mathbb { E } _ { q ( \mathbf { z } _ { 1 } , \ldots , \mathbf { z } _ { L } ) } \Big [ - \log \overline { { p } } _ { \mathrm { r a R } } \Big ( y \Big | S \big ( \{ f ( \mathbf { z } _ { l } ) \} _ { l = 1 } ^ { L } \big ) \Big ) \Big ] + \frac { \gamma } { L } \sum _ { l = 1 } ^ { L } D _ { \mathrm { K L } } ( q _ { l } ( \mathbf { z } _ { l } ) | | p _ { \mathrm { A U X } } ( \mathbf { z } _ { l } ) ) .
+$$
+
+# 4.2 Code Space Variational Family $\mathcal { Q } _ { \mathbf { z } }$
+
+In the VMI formulations (Equation 4 and 5), the approximate distribution $q ( \mathbf { z } )$ can be seen as a generator, or “miner” network [Wang et al., 2020] for the latent space of the common generator. It must belong to a distribution family $\mathcal { Q } _ { \mathbf { z } }$ , whose distribution can be sampled from, and can be evaluated in order to optimize the KL-divergence. In this work, we experiment with a powerful class of tractable generative models: deep flow models. When optimizing $\mathcal { L } _ { \mathrm { s - V M I } } ^ { \gamma } ( q )$ (Equation 5), we use $L$ such models, one for each layer in the synthesis network. In our experiments, we used an architecture similar to that of Glow [Kingma and Dhariwal, 2018], where we treated the latent vector as 1x1 images. We removed the original squeezing layers that reduced the image size to account for this change. We also experimented with using a Gaussian variational family for $q ( \mathbf { z } )$ .
+
+# 4.3 Relationships with Existing Methods
+
+VMI provides a unified framework that encompasses existing attack methods. Through the lens of VMI, we can obtain insights on the conceptual differences between the existing methods and their pros and cons. “General MI” attack [Hidano et al., 2017] performs the following optimization:
+
+$$
+\mathbf { x } ^ { * } = \mathop { \underset { \mathbf { x } } { \operatorname { \arg m a x } } } \log \overline { { p } } _ { \mathrm { T A R } } ( y | \mathbf { x } ) .
+$$
+
+![](images/cae78751cba9824787ffb9a601e25fa880d387b8d686ce87669135e18f333f05.jpg)  
+Figure 4: Visualization of real samples for all 3 tasks: MNIST, CelebA, and ChestX-ray. For the target datasets, each row corresponds to one class/identity. Best viewed zoomed in.
+
+Note that this objective can be viewed as special case of VMI, where the code space is the same as the data space, and we have $\gamma = 0$ in the objective: $\mathcal { L } _ { \mathrm { v M } } ^ { \gamma = 0 } ( q )$ . In this case, as discussed in the previous section, the $q ( \mathbf { x } )$ distribution collapses to a point estimate at which $\overline { { p } } _ { \mathrm { T A R } } ( y | \mathbf { x } )$ is maximized. As we will see in the experiment section, since the optimization is in the data space, the solution does not live close the manifold of images, and thus generally does not structurally looks like natural images.
+
+“Generative MI” attack [Zhang et al., 2020] also uses a generator trained on an “auxiliary” dataset. The attack optimizes the following objective:
+
+$$
+\mathbf { z } ^ { * } = \underset { \mathbf { z } } { \arg \operatorname* { m i n } } \left\{ - \lambda \log \overline { { p } } _ { \mathrm { T A R } } ( y | ( G ( \mathbf { z } ) ) - \log \sigma \big ( D ( G ( \mathbf { z } ) ) \big ) \right\}
+$$
+
+where $G , D$ denotes the generator and discriminator respectively, and $\sigma ( \cdot )$ is the sigmoid function. Note that this objective can be viewed as special case of VMI, with $\begin{array} { r } { \gamma = \frac { 1 } { \lambda } } \end{array}$ , and with the prior $p ( \mathbf { z } ) \propto \sigma \big ( D ( G ( \mathbf { z } ) \big )$ , and a point estimate for $\mathbf { z }$ , instead of optimizing over distributions $q ( \mathbf { z } )$ . As a result of this point-wise optimization, the Generative MI attack requires re-running the optimization procedure for every new samples. In contrast, VMI learns a distribution $q ( \mathbf { z } )$ using expressive normalizing flows, which allows us to draw multiple attack samples after a single optimization procedure. Recently, Chen et al. [2020] proposed extending Generative MI by considering a Gaussian variational family in the latent space of the pretrained generator in Equation 7. However, we note this method still theoretically results in collapsing the Gaussian variational distributions to a point estimate. VMI prevents this by penalizing the entropy of the variational distribution with the KL-divergence term. From the implementation perspective, Chen et al. [2020] uses DCGAN while we use StyleGAN which helps us to achieve better disentanglement. Furthermore, we use a more expressive variational family such as normalizing flows.
+
+# 5 Experiments
+
+In this section, we demonstrate the effectiveness of the proposed VMI attack method on three separate tasks. We will refer to each task by their target dataset: MNIST [LeCun et al., 2010], CelebA [Liu et al., 2015], and ChestX-ray (CXR) [Wang et al., 2017]. Then, we showcase the robustness of the VMI attack to different target classifiers on CelebA. More experimental details can be found in Appendix B.
+
+Data. For the MNIST task, we used the ‘letters’ split (i.e., handwritten English alphabets) of the EMNIST [Cohen et al., 2017] dataset as the auxiliary dataset. For CelebA, we used the 1000 most frequent identities as the target dataset, and the rest as the auxiliary dataset. For ChestX-ray, we used the 8 diseases outlined by Wang et al. [2017] as the target dataset, and randomly selected 50,000 images from the remaining as the auxiliary dataset. Real samples from these six datasets are visualized in Figure 4.
+
+Target classifiers. The target classifiers used in all tasks were ResNets trained using SGD with momentum. Optimization hyperparameters were selected to maximize accuracy on a validation set of the private data.
+
+Evaluation metrics. An ideal evaluation protocol should measure different aspects of the attack samples such as target accuracy, sample realism, and sample diversity.
+
+Target Accuracy: To automate the process of judging the accuracy of an attack, we use an “evaluation” classifier. This metrics measures how well the generated samples resemble the target class/identity. Given a target identity $i$ , an attack produces a set of samples $\{ \mathbf { x } _ { n } ^ { \prime } \} _ { n = 1 } ^ { N }$ . Each sample is assigned a predicted label by the evaluation classifier, and then the top-1 accuracy is computed.
+
+$$
+\begin{array} { l } { { \bf { \sigma } } _ { \mathrm { { G e n e r a l } ~ M I ~ [ H i d a n o ~ e t a l . ~ 2 0 1 7 ] } } ^ { \bf { A c c u r a c y \dagger } } } & { { \bf { \sigma } } _ { \mathrm { { K L } } } ^ { \mathrm { { F I D } } } . } \\ { { \bf { \sigma } } _ { \mathrm { { G e n e r a l } ~ M I ~ [ H i d a n o ~ e t a l . ~ 2 0 1 7 ] } } ^ { \bf { C } } } & { { \bf { \sigma } } _ { \mathrm { { G e l e b a } } } ^ { \mathrm { { G e l e b A } } } } & { { \bf { \sigma } } _ { \mathrm { { X } } } { \bf { R } } } \\ { { \bf { \sigma } } _ { \mathrm { { G e n e r a l } ~ M I ~ [ H i d a n o ~ e t a l . ~ 2 0 1 7 ] } } ^ { \bf { G e n d } } } & { { \bf { \sigma } } _ { \mathrm { { 0 } } + \mathrm { { 0 } } , \mathrm { { 0 } } + \mathrm { { 0 } } , \mathrm { { 0 } } + \mathrm { { 0 } } , \mathrm { { 2 } } 3 + \mathrm { { 0 } } , \mathrm { { 2 } } 3 + \mathrm { { 0 } } , \mathrm { { 2 } } 5 / \mathrm { { 6 } } , { 7 } 4 \mathrm { { 0 } } , \mathrm { { 2 } } 1 . 2 1 \mathrm { { \sigma } } _ { \mathrm { { { 0 } } } , \mathrm { { 3 } } } } } & { { \mathrm { { 4 9 } } 2 . 5 4 \mathrm { { \sigma } } _ { \mathrm { { 0 } } 6 , \mathrm { { 3 } } } } } \\  { \frac { { \bf { G e n e r a t i v e ~ M I ~ [ Z h a n g ~ e t a l . ~ 2 0 2 0 ] } } } { \bf { \sigma } } _ { \mathrm { { S } } } } & { { \bf { 0 } . 9 2 \pm \mathrm { { 0 } } \mathrm { { 0 } } 2 } } &  { 0 . 0 7 \pm \mathrm { { 0 } } \mathrm { { 2 } } \mathrm { { 0 } } \mathrm { { 2 } } \mathrm { { 0 } } \mathrm { { 2 } } \mathrm { { 0 } } \mathrm { { 2 } } \mathrm { { 8 } } \mathrm { { 2 } } 0 . 3 \mathrm { { \sigma } } _ { \mathrm { { 0 } } } } &  { \bf { 0 } . 9 1 \mathrm { { \sigma } } _ { \mathrm { { 0 } } \mathrm { { 3 } } } } &   \bf { 2 } 6 \mathrm { 5 } , \mathrm { { 1 } } 4 \mathrm { { 0 } } \mathrm    \end{array}
+$$
+
+Table 1: MI attack comparison across tasks. Both VMI methods here used the Flow model for $q ( \mathbf { z } )$ . Best values are in bold, and values within the $9 5 \%$ confidence interval $( \pm )$ of the best are underlined. The numbers in the braces in the FID columns are FIDs of the pre-trained generators. Our VMI attack results in better accuracy and FID compared to baselines on all three tasks.
+
+If a good evaluation classifier only generalized to realistic inputs, then this metric would also penalize unrealistic attack samples. To some extent, this was the case in our experiments as evidenced by the extremely low accuracy assigned to the General MI attack baseline in Table 1. In Figure 5, the General MI attack samples were clearly unrealistic. To ensure a fair and informative evaluation, the evaluation classifier should be as accurate and generalizable as possible (details in Appendix B.3).
+
+Sample Realism: We used FID [Heusel et al., 2017] to directly measure the overall sample quality. To compute FID, we aggregated attack samples across classes and compared them to aggregated real images. Following standard practice, the feature extractor used for computing FID was the pretrained Inception network [Szegedy et al., 2015].
+
+Sample Diversity: Though FID captures realism and overall diversity, it is known to neglect properties such as intra-class diversity, which is an important feature of a good MI attack. To overcome this limitation, we computed the improved precision & recall [Kynkäänniemi et al., 2019], coverage & density [Naeem et al., 2020] on a per class basis, capturing the intra-class diversity of the generated samples. The same Inception network was used as the feature extractor. Recall proposed in Kynkäänniemi et al. [2019] can be problematic when the generated samples contain outliers. Coverage proposed in Naeem et al. [2020] is less susceptible to outliers, but also less sensitive. For convenience of comparison, we take the average of the two quantities and call the resulting metric “diversity”.
+
+Generators. Two generator models were considered: DCGAN [Radford et al., 2015], and StyleGAN [Karras et al., 2019]. For StyleGAN, we used the original implementations.2 There were 10 and 12 layers in the synthesis networks for the $6 4 \mathrm { x } 6 4$ CelebA data and 128x128 ChestX-ray data respectively. We do not use StyleGAN for the MNIST task since the images are simple.
+
+# 5.1 Results
+
+Comparison with Baselines. Across all three tasks, our VMI formulations outperformed baselines in terms of target accuracy and sample realism (see Table 1), even when using the same generator architecture (DCGAN). Using a flow model for $q ( \mathbf { z } )$ led to improvements in terms of accuracy. Using the formulation in Equation 5 and a StyleGAN further improved performance on all metrics. VMI also improved the overall sample qualities as evidenced by the lower FIDs. The full VMI (Equation 5) was able to improve FID over pre-trained generators on CelebA. In general, MI attack methods including VMI sacrificed sample quality to achieve higher accuracy, suggesting there is still room for improvements for methods that can retain full realism. Detailed evaluation using sample diversity metrics are reported in Table 2. In general, increasing $\gamma$ increased diversity and realism while sacrificing accuracy. Our VMI attack outperformed the baseline on all metrics at multiple settings. The reported improvements in the quantitative metrics can be verified qualitatively in Figure 5. Detailed results for MNIST and ChestX-ray (Table 4, and 5) can be found in the Appendix C. Using StyleGAN with a Gaussian $q ( \mathbf { z } )$ resulted in a slightly lower accuracy, but better diversity.
+
+Our reported results for our baseline [Zhang et al., 2020] are obtained using our own implementation since the reproduction code was not publicly available. The discrepancy with the original result can come from a number of factors: dataset split, target classifier checkpoint, and the hyperparameters involved in the method. We used the task setup described in this paper, and tuned the hyperparameters over a reasonable grid of values.
+
+![](images/c5ffe07dfee50c65f58a077439d23dda82903f11731394e686f7f51bbee81cc9.jpg)  
+Figure 5: MI attack samples on the first ten identities of CelebA and MNIST. Each row corresponds to a different identity/digit. Qualitative differences are best viewed zoomed in.
+
+Table 2: Detailed comparison between attack methods on CelebA.   
+
+<table><tr><td></td><td></td><td colspan="9">VMI (ours)</td></tr><tr><td></td><td>Generative MI</td><td colspan="3">DCGAN</td><td colspan="6">StyleGAN</td></tr><tr><td></td><td>[Zhang et al., 2020]</td><td>q(z) = Gaussian =0</td><td>Flow le-3</td><td>le-1</td><td>0</td><td>Gaussian le-3</td><td>le-1</td><td>0</td><td>Flow 1e-3</td><td>le-1</td></tr><tr><td>Accuracy</td><td>0.07± 0.02</td><td>0.24± 0.05</td><td>0</td><td></td><td>0.57±0.06</td><td></td><td></td><td></td><td>0.55±0.06</td><td>0.39±0.07</td></tr><tr><td>Precision</td><td>0.51± 0.04</td><td>0.64±0.05</td><td>10.33± 0.09 0.37±0.07 0.13± 0.03 0.48±0.08 0.52±0.06</td><td>0.40±0.06</td><td>0.87±0.02</td><td>0.56±0.05 0.88±0.02</td><td>0.23±0.03 0.82±0.02</td><td>0.58± 0.06 0.87±0.03</td><td>0.87±0.03</td><td>0.89± 0.03</td></tr><tr><td>Density</td><td>0.41± 0.04</td><td>0.67± 0.08</td><td>0.49± 0.11</td><td>0.52± 0.08 0.38± 0.06</td><td>1.26± 0.07</td><td>1.28± 0.07</td><td>1.14± 0.06</td><td>1.22± 0.08</td><td>1.22± 0.08</td><td>1.31± 0.10</td></tr><tr><td></td><td></td><td>0.03± 0.01</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Recall Coverage</td><td>0.21± 0.04 0.83± 0.03</td><td>0.79±0.04</td><td>[0.00±0.00 0.01± 0.01 0.37±0.06 0.67± 0.06</td><td>0.13±0.03 0.70± 0.06</td><td>0.22± 0.03 0.98± 0.01</td><td>0.25± 0.03 0.98±0.01</td><td>0.42±0.03 0.98±0.01</td><td>|0.11 ± 0.02 0.96± 0.02</td><td>0.15± 0.03 0.97± 0.02</td><td>0.21±0.04 0.98±0.02</td></tr><tr><td>Diversity</td><td>0.52± 0.05</td><td>0.41± 0.04</td><td>0.19±0.06 0.34± 0.06</td><td>0.41± 0.07</td><td>0.60± 0.03</td><td>0.61± 0.03</td><td>0.70± 0.03</td><td>0.54± 0.02</td><td>0.56±0.04</td><td>0.59±0.05</td></tr><tr><td>FID</td><td>43.21</td><td>28.98</td><td>58.39 40.89</td><td>40.74</td><td>16.69</td><td>16.11</td><td>13.49</td><td>17.28</td><td>17.41</td><td>21.35</td></tr></table>
+
+Attacking Different Target Classifiers. After establishing the effectiveness of our VMI attack on different datasets, we conducted experiments to test the effectiveness of our VMI attack against different target classifiers. We further tested two target classifier on CelebA: a VGG network [Simonyan and Zisserman, 2014] trained from scratch on our target dataset, and an adapted ArcFace classifier [Deng et al., 2019], which we denote as ArcFace-NC. The ArcFace is a specialized face identity recognizer pretrained on a large collection of datasets. We adapt it by using the pretrained network as a feature encoder,3 and adding a nearest cluster classifier in the feature space. This approach of adapting a powerful feature extractor is popular and effective in few-shot classification [Chen et al., 2019; Snell et al., 2017]. The resulting accuracy on held-out test examples in the target dataset were $6 2 . 1 \%$ (VGG) and $9 6 . 1 \%$ (ArcFace-NC). Results in Table 3 show that the same observations hold.
+
+Accuracy vs. Diversity Tradeoff. Figure 6 shows the accuracy vs. diversity tradeoff in VMI attacks on CelebA. The VMI attacks that used the StyleGAN generally achieved a better accuracy vs. diversity tradeoff than the ones used the DCGAN. We conjecture this is because of the better layer-wise disentanglement that the StyleGAN achieves.
+
+Effect of Individual Layers. As motivated in Section 4.1, the extended latent space in Equation 5 allowed our attack to modify each layer which controlled different aspects of an image. Figure 7 shows values for the KL-divergence and entropy for $q _ { l } ( \mathbf { z } )$ at all layers after VMI optimization in CelebA and ChestX-ray datasets. We can see a general downward trend in KL divergences and an upward trend in entropies of $q ( \mathbf { z } )$ with respect to layers. This shows that in general the $q ( \mathbf { z } )$ of the earlier layers were modified more by the optimization than the $q ( \mathbf { z } )$ of the later layers. This is consistent with our observation in Figure 2 that the earlier layers have more control over features relevant to the identity of a face.
+
+![](images/ca235ae6f3d57011a238b7ee7e6fda724f542ea618fa0e38b2d7479819facc65.jpg)  
+Figure 6: Accuracy and diversity tradeoff on CelebA.
+
+Table 3: Detailed comparison on CelebA for two other target classifiers: VGG, and ArcFace-NC. $\mathrm { F I D ^ { \ast } }$ reported here was computed over 20 identities instead of 100, so the values can not be directly compared with those in Table 2.   
+
+<table><tr><td rowspan="3"></td><td colspan="5">VGG</td><td colspan="5">ArcFace-NC</td></tr><tr><td rowspan="2">Generative MI</td><td colspan="4">VMI (ours)</td><td rowspan="2">Generative MI</td><td colspan="4">VMI (ours)</td></tr><tr><td>DCGAN Gaussian</td><td>Flow</td><td>StyleGAN Gaussian</td><td>Flow</td><td>Gaussian</td><td>DCGAN Flow</td><td>StyleGAN Gaussian</td><td>Flow</td></tr><tr><td>Accuracy</td><td>[Zhang et al., 2020] 0.04±0.03</td><td>0.16± 0.09</td><td></td><td></td><td></td><td>[Zhang et al., 2020]</td><td></td><td></td><td></td><td></td></tr><tr><td>Precision</td><td>0.51± 0.09</td><td>0.60± 0.10</td><td>0.12±0.08 0.74±0.07</td><td>0.17±0.10 0.80±0.08</td><td>0.33±0.18 0.79± 0.11</td><td>0.21±0.08 0.59±0.09</td><td>0.63± 0.17 0.52±0.13</td><td>0.55±0.18</td><td>0.52± 0.13 0.86±0.04</td><td>0.90±0.07 0.84±0.07</td></tr><tr><td>Density</td><td>0.42± 0.1</td><td>0.63± 0.16</td><td>0.76±0.20</td><td>1.04± 0.19</td><td>1.02±0.24</td><td>0.46± 0.13</td><td>0.55±0.18</td><td>0.53± 0.14 0.64± 0.21</td><td>1.26± 0.21</td><td>1.26± 0.23</td></tr><tr><td></td><td>0.23±0.10</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Recall Coverage</td><td>0.79±0.13</td><td>0.09±0.04 0.75±0.13</td><td>0.02± 0.02 0.77±0.12</td><td>0.28±0.06 0.93±0.08</td><td>0.04±0.03 0.88±0.10</td><td>0.11± 0.04 0.81± 0.07</td><td>0.01± 0.01 0.69±0.11</td><td>0.00± 0.01 0.69±0.12</td><td>0.23±0.07 0.98± 0.03</td><td>0.04±0.03 0.96±0.05</td></tr><tr><td>Diversity</td><td>0.51± 0.16</td><td>0.42± 0.13</td><td>0.39± 0.12</td><td>0.61± 0.10</td><td>0.46±0.11</td><td>0.46±0.08</td><td>0.35± 0.12</td><td>0.35±0.12</td><td>0.60±0.08</td><td>0.50± 0.05</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>FID*</td><td>59.27</td><td>53.85</td><td>57.88</td><td>32.51</td><td>46.13</td><td>63.63</td><td>59.23</td><td>63.37</td><td>32.94</td><td>40.22</td></tr></table>
+
+![](images/436d2940ae60c41202b68f927d865b2647ae051ebe5529380563c2b25d828063.jpg)  
+Figure 7: KL and entropy of $q _ { l } ( \mathbf { z } )$ after VMI attack on CelebA and ChestX-ray at different layers.
+
+# 6 Limitation & Ethical Concerns
+
+While our VMI attack was effective, it relied on the same assumption made in previous works: the attacker had access to a relevant auxiliary dataset [Yang et al., 2019b; Zhang et al., 2020]. A worthwhile future direction is to develop methods that do not depend on this assumption. Methodologically, our proposed VMI attack used a GAN to narrow down the search space of the variational objective, but GANs might not be equally effective for other data modalities such as text, and tabular data. Lastly, our study focused on the white-box setting where the attacker had full access to the model; extensions of the current VMI attack to the grey-box or black-box settings are also worthy of further investigation.
+
+In this work, we focused on a method for improving model inversion attacks, which could have negative societal impacts if it falls into the wrong hands. As discussed in Section 1, malicious users can use attacks like this to break into secured systems and steal information from private data-centers. On the other hand, by pointing out the extent of the vulnerability of current models, we hope to facilitate research that builds better privacy-preserving algorithms, and raise awareness about privacy concerns.
+
+# 7 Conclusion
+
+An effective model inversion attack method must produce a set of samples that accurately captures the distinguishing features and variations of the underlying identity/class. Our proposed VMI attack optimizes a variational inference objective by using a combination of a StyleGAN generator and a deep flow model as its variational distribution. Our framework also provides insights into existing attack methods. Empirically, we found our VMI attacks were effective on three different tasks, and across different target classifiers.
+
+# Acknowledgments and Disclosure of Funding
+
+Acknowledgement. We would like to thank reviewers and ACs for constructive feedback and discussion. Resources used in preparing this research were provided, in part, by the Province of Ontario, the Government of Canada through CIFAR, and companies sponsoring the Vector Institute www.vectorinstitute.ai/#partners.
+
+# References
+
+Rameen Abdal, Yipeng Qin, and Peter Wonka. Image2stylegan: How to embed images into the stylegan latent space? In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 4432–4441, 2019.
+
+Amazon AWS. Amazon rekognition. URL https://aws.amazon.com/rekognition/.
+
+David Bau, Jun-Yan Zhu, Hendrik Strobelt, Bolei Zhou, Joshua B Tenenbaum, William T Freeman, and Antonio Torralba. Gan dissection: Visualizing and understanding generative adversarial networks. arXiv preprint arXiv:1811.10597, 2018.
+
+Pier Giovanni Bissiri, Chris C Holmes, and Stephen G Walker. A general framework for updating belief distributions. Journal of the Royal Statistical Society. Series B, Statistical methodology, 78(5):1103, 2016.
+
+David M Blei, Alp Kucukelbir, and Jon D McAuliffe. Variational inference: A review for statisticians. Journal of the American statistical Association, 112(518):859–877, 2017.
+
+Keith Bonawitz, Hubert Eichner, Wolfgang Grieskamp, Dzmitry Huba, Alex Ingerman, Vladimir Ivanov, Chloe Kiddon, Jakub Konecnˇ y, Stefano Mazzocchi, H Brendan McMahan, et al. Towards federated learning at \` scale: System design. arXiv preprint arXiv:1902.01046, 2019.
+
+Si Chen, Ruoxi Jia, and Guo-Jun Qi. Improved techniques for model inversion attack. arXiv preprint arXiv:2010.04092, 2020.
+
+Wei-Yu Chen, Yen-Cheng Liu, Zsolt Kira, Yu-Chiang Wang, and Jia-Bin Huang. A closer look at few-shot classification. In International Conference on Learning Representations, 2019.
+
+Gregory Cohen, Saeed Afshar, Jonathan Tapson, and Andre Van Schaik. Emnist: Extending mnist to handwritten letters. In 2017 International Joint Conference on Neural Networks (IJCNN), pages 2921–2926. IEEE, 2017.
+
+International Warfarin Pharmacogenetics Consortium. Estimation of the warfarin dose with clinical and pharmacogenetic data. New England Journal of Medicine, 360(8):753–764, 2009.
+
+Jiankang Deng, Jia Guo, Niannan Xue, and Stefanos Zafeiriou. Arcface: Additive angular margin loss for deep face recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4690–4699, 2019.
+
+Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017.
+
+Laurent Dinh, David Krueger, and Yoshua Bengio. Nice: Non-linear independent components estimation. arXiv preprint arXiv:1410.8516, 2014.
+
+Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using real nvp. arXiv preprint arXiv:1605.08803, 2016.
+
+Simon S Du, Wei Hu, Sham M Kakade, Jason D Lee, and Qi Lei. Few-shot learning via learning the representation, provably. arXiv preprint arXiv:2002.09434, 2020.
+
+Matt Fredrikson, Somesh Jha, and Thomas Ristenpart. Model inversion attacks that exploit confidence information and basic countermeasures. In Proceedings of the 22nd ACM SIGSAC Conference on Computer and Communications Security, pages 1322–1333, 2015.
+
+Matthew Fredrikson, Eric Lantz, Somesh Jha, Simon Lin, David Page, and Thomas Ristenpart. Privacy in pharmacogenetics: An end-to-end case study of personalized warfarin dosing. In 23rd {USENIX} Security Symposium ({USENIX} Security 14), pages 17–32, 2014.
+
+Javier Galbally, Sébastien Marcel, and Julian Fierrez. Biometric antispoofing methods: A survey in face recognition. IEEE Access, 2:1530–1552, 2014.
+
+Jonas Geiping, Hartmut Bauermeister, Hannah Dröge, and Michael Moeller. Inverting gradients–how easy is it to break privacy in federated learning? arXiv preprint arXiv:2003.14053, 2020.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. Advances in neural information processing systems, 27:2672–2680, 2014.
+
+Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q Weinberger. On calibration of modern neural networks. arXiv preprint arXiv:1706.04599, 2017.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. arXiv preprint arXiv:1706.08500, 2017.
+
+Seira Hidano, Takao Murakami, Shuichi Katsumata, Shinsaku Kiyomoto, and Goichiro Hanaoka. Model inversion attacks for prediction systems: Without knowledge of non-sensitive attributes. In 2017 15th Annual Conference on Privacy, Security and Trust (PST), pages 115–11509. IEEE, 2017.
+
+Briland Hitaj, Giuseppe Ateniese, and Fernando Perez-Cruz. Deep models under the gan: information leakage from collaborative deep learning. In Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security, pages 603–618, 2017.
+
+Corey D Holland and Oleg V Komogortsev. Complex eye movement pattern biometrics: Analyzing fixations and saccades. In 2013 International conference on biometrics (ICB), pages 1–8. IEEE, 2013.
+
+CC Holmes and SG Walker. Assigning a value to a power likelihood in a general bayesian model. Biometrika, 104(2):497–503, 2017.
+
+Michael I Jordan, Zoubin Ghahramani, Tommi S Jaakkola, and Lawrence K Saul. An introduction to variational methods for graphical models. Machine learning, 37(2):183–233, 1999.
+
+Georgios A Kaissis, Marcus R Makowski, Daniel Rückert, and Rickmer F Braren. Secure, privacy-preserving and federated machine learning in medical imaging. Nature Machine Intelligence, 2(6):305–311, 2020.
+
+Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4401–4410, 2019.
+
+Tero Karras, Samuli Laine, Miika Aittala, Janne Hellsten, Jaakko Lehtinen, and Timo Aila. Analyzing and improving the image quality of stylegan. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8110–8119, 2020.
+
+Mahdi Khosravy, Kazuaki Nakamura, Naoko Nitta, and Noboru Babaguchi. Deep face recognizer privacy attack: Model inversion initialization by a deep generative adversarial data space discriminator. In 2020 Asia-Pacific Signal and Information Processing Association Annual Summit and Conference (APSIPA ASC), pages 1400–1405. IEEE, 2020.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Durk P Kingma and Prafulla Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. In Advances in Neural Information Processing Systems, pages 10215–10224, 2018.
+
+Jeremias Knoblauch, Jack Jewson, and Theodoros Damoulas. Generalized variational inference: Three arguments for deriving new posteriors. arXiv preprint arXiv:1904.02063, 2019.
+
+Tuomas Kynkäänniemi, Tero Karras, Samuli Laine, Jaakko Lehtinen, and Timo Aila. Improved precision and recall metric for assessing generative models. arXiv preprint arXiv:1904.06991, 2019.
+
+Yann LeCun, Corinna Cortes, and CJ Burges. Mnist handwritten digit database, 2010.
+
+Erich L Lehmann and Joseph P Romano. Testing statistical hypotheses. Springer Science & Business Media, 2006.
+
+Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In Proceedings of International Conference on Computer Vision (ICCV), December 2015.
+
+Aravindh Mahendran and Andrea Vedaldi. Understanding deep image representations by inverting them. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 5188–5196, 2015.
+
+Jeffrey W Miller and David B Dunson. Robust bayesian inference via coarsening. Journal of the American Statistical Association, 2018.
+
+Muhammad Ferjad Naeem, Seong Joon Oh, Youngjung Uh, Yunjey Choi, and Jaejun Yoo. Reliable fidelity and diversity metrics for generative models. In International Conference on Machine Learning, pages 7176–7185. PMLR, 2020.
+
+Milad Nasr, Reza Shokri, and Amir Houmansadr. Comprehensive privacy analysis of deep learning: Passive and active white-box inference attacks against centralized and federated learning. In 2019 IEEE symposium on security and privacy $( S P )$ , pages 739–753. IEEE, 2019.
+
+Anh Nguyen, Jason Yosinski, and Jeff Clune. Deep neural networks are easily fooled: High confidence predictions for unrecognizable images. In Conference on Computer Vision and Pattern Recognition, pages 427–436, 2015.
+
+Anh Nguyen, Jeff Clune, Yoshua Bengio, Alexey Dosovitskiy, and Jason Yosinski. Plug & play generative networks: Conditional iterative generation of images in latent space. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4467–4477, 2017.
+
+Omkar M Parkhi, Andrea Vedaldi, and Andrew Zisserman. Deep face recognition. 2015.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.
+
+Christian Rathgeb and Andreas Uhl. A survey on biometric cryptosystems and cancelable biometrics. EURASIP Journal on Information Security, 2011(1):1–25, 2011.
+
+Maria Rigaki and Sebastian Garcia. A survey of privacy attacks in machine learning. arXiv preprint arXiv:2007.07646, 2020.
+
+Thomas Schlegl, Philipp Seeböck, Sebastian M Waldstein, Ursula Schmidt-Erfurth, and Georg Langs. Unsupervised anomaly detection with generative adversarial networks to guide marker discovery. In International conference on information processing in medical imaging, pages 146–157. Springer, 2017.
+
+Elizabeth A Sconce, Tayyaba I Khan, Hilary A Wynne, Peter Avery, Louise Monkhouse, Barry P King, Peter Wood, Patrick Kesteven, Ann K Daly, and Farhad Kamali. The impact of cyp2c9 and vkorc1 genetic polymorphism and patient characteristics upon warfarin dose requirements: proposal for a new dosing regimen. Blood, 106(7):2329–2333, 2005.
+
+Yujun Shen, Ceyuan Yang, Xiaoou Tang, and Bolei Zhou. Interfacegan: Interpreting the disentangled face representation learned by gans. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2020.
+
+Reza Shokri, Marco Stronati, Congzheng Song, and Vitaly Shmatikov. Membership inference attacks against machine learning models. In 2017 IEEE Symposium on Security and Privacy (SP), pages 3–18. IEEE, 2017.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. arXiv preprint arXiv:1312.6034, 2013.
+
+Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Advances in Neural Information Processing Systems, pages 4077–4087, 2017.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1–9, 2015.
+
+Google TensorFlow. Tensorflow hub. URL https://www.tensorflow.org/hub.
+
+Nilesh Tripuraneni, Michael I Jordan, and Chi Jin. On the theory of transfer learning: The importance of task diversity. arXiv preprint arXiv:2006.11650, 2020.
+
+Xiaosong Wang, Yifan Peng, Le Lu, Zhiyong Lu, Mohammadhadi Bagheri, and Ronald M Summers. Chestxray8: Hospital-scale chest x-ray database and benchmarks on weakly-supervised classification and localization of common thorax diseases. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2097–2106, 2017.
+
+Yaxing Wang, Abel Gonzalez-Garcia, David Berga, Luis Herranz, Fahad Shahbaz Khan, and Joost van de Weijer. Minegan: effective knowledge transfer from gans to target domains with few images. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9332–9341, 2020.
+
+Qiang Yang, Yang Liu, Tianjian Chen, and Yongxin Tong. Federated machine learning: Concept and applications. ACM Transactions on Intelligent Systems and Technology (TIST), 10(2):1–19, 2019a.
+
+Ziqi Yang, Ee-Chien Chang, and Zhenkai Liang. Adversarial neural network inversion via auxiliary knowledge alignment. arXiv preprint arXiv:1902.08552, 2019b.
+
+Raymond A Yeh, Chen Chen, Teck Yian Lim, Alexander G Schwing, Mark Hasegawa-Johnson, and Minh N Do. Semantic image inpainting with deep generative models. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 5485–5493, 2017.
+
+Hongxu Yin, Pavlo Molchanov, Jose M Alvarez, Zhizhong Li, Arun Mallya, Derek Hoiem, Niraj K Jha, and Jan Kautz. Dreaming to distill: Data-free knowledge transfer via deepinversion. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8715–8724, 2020.
+
+Yuheng Zhang, Ruoxi Jia, Hengzhi Pei, Wenxiao Wang, Bo Li, and Dawn Song. The secret revealer: generative model-inversion attacks against deep neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 253–261, 2020.

parse/train/c0O9vBVSvIl/c0O9vBVSvIl_content_list.json

@@ -0,0 +1,1879 @@
+[
+    {
+        "type": "text",
+        "text": "Variational Model Inversion Attacks ",
+        "text_level": 1,
+        "bbox": [
+            276,
+            122,
+            722,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Kuan-Chieh Wang1,2,† Yan Fu1 Ke Li3 Ashish Khisti1 Richard Zemel1,2 Alireza Makhzani1,2,§ University of Toronto1, Vector Institute2, Simon Fraser University3 †wangkua1@cs.toronto.edu, §makhzani@vectorinstitute.ai ",
+        "bbox": [
+            263,
+            195,
+            736,
+            256
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            290,
+            535,
+            308
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Given the ubiquity of deep neural networks, it is important that these models do not reveal information about sensitive data that they have been trained on. In model inversion attacks, a malicious user attempts to recover the private dataset used to train a supervised neural network. A successful model inversion attack should generate realistic and diverse samples that accurately describe each of the classes in the private dataset. In this work, we provide a probabilistic interpretation of model inversion attacks, and formulate a variational objective that accounts for both diversity and accuracy. In order to optimize this variational objective, we choose a variational family defined in the code space of a deep generative model, trained on a public auxiliary dataset that shares some structural similarity with the target dataset. Empirically, our method substantially improves performance in terms of target attack accuracy, sample realism, and diversity on datasets of faces and chest $\\mathrm { X }$ -ray images. ",
+        "bbox": [
+            233,
+            321,
+            766,
+            501
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            526,
+            310,
+            542
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Thanks to recent advances, deep neural networks are now widely used in applications including facial recognition [Parkhi et al., 2015], intelligent automated assistants, and personalized medicine [Consortium, 2009; Sconce et al., 2005]. Powerful deep neural networks are trained on large datasets that could contain sensitive information about individuals. Publishers release only the trained models (e.g., on TensorFlow Hub [TensorFlow]), but not the original dataset to protect the privacy of individuals whose information is in the training set. Regrettably, the published model can leak information about the original training set [Geiping et al., 2020; Nasr et al., 2019; Shokri et al., 2017]. Attacks that exploit such properties of machine learning models are privacy attacks [Rigaki and Garcia, 2020]. Other real-world scenarios where an attacker can access models trained on private datasets include interaction with APIs (e.g., Amazon Rekognition [AWS]), or in the growing paradigm of federated learning [Bonawitz et al., 2019; Yang et al., 2019a], where a malicious insider can try to steal data from other data centers [Hitaj et al., 2017]. Kaissis et al. [2020] provides an overview of how these privacy concerns are hindering the widespread application of deep learning in the medical domain. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            737
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper focuses on the model inversion (MI) attack, a type of privacy attack that tries to recover the training set given access only to a trained classifier [Chen et al., 2020; Fredrikson et al., 2015, 2014; Hidano et al., 2017; Khosravy et al., 2020; Yang et al., 2019b; Zhang et al., 2020]. The classifier under attack is referred to as the “target classifier” (see Figure 1). An important relevant application concerns identity recognition from face images, since facial recognition is a common approach to biometric identification [Galbally et al., 2014; Rathgeb and Uhl, 2011]. Once an attacker successfully reconstructs images of the faces of individuals in the private training set, they can use the stolen identity to break into otherwise secure systems. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            853
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Early studies of MI attacks focused on attacking classifiers whose inputs are tabular data [Fredrikson et al., 2015, 2014; Hidano et al., 2017] by directly performing inference in the input space. However, the same methods fail when the target classifier processes high-dimensional inputs, e.g., in the above example of a face recognizer. Recent methods cope with this high-dimensional search space by performing the attack in the latent space of a neural network generator [Khosravy et al., 2020; Yang et al., 2019b; Zhang et al., 2020]. Introducing a generator works well in practice, but this success is not theoretically understood. In this paper, we frame MI attacks as a variational inference (VI) [Blei et al., 2017; Jordan et al., 1999; Kingma and Welling, 2013] problem, and derive a practical objective. This view allows us to justify existing approaches based on a deep generative model, and identify missing ingredients in them. Empirically, we find that our proposed objective leads to significant improvements: more accurate and diverse attack images, which are quantified using standard sample quality metrics (i.e., FID [Heusel et al., 2017], precision, and recall [Kynkäänniemi et al., 2019; Naeem et al., 2020]). ",
+        "bbox": [
+            176,
+            859,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/854832cd91e0cbc7ed962ec78589eaa388141fda1ee3b8752003cba533466cb0.jpg",
+        "image_caption": [
+            "Figure 1: In model inversion attacks, the attacker tries to recover the original dataset used to train a classifier with access to only the trained classifier. In the two figures on the right, each row corresponds to a private identity – an individual whose images are not available to the attacker. The first five identities (not cherry-picked) were visualized. On the left are real data samples, and on the right are generated samples from our proposed method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            89,
+            812,
+            209
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            332,
+            825,
+            470
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, our contributions and findings are: ",
+        "bbox": [
+            173,
+            477,
+            485,
+            491
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We view the model inversion (MI) attack problem as a variational inference (VI) problem. This view allows us to derive a practical objective based on a statistical divergence, and provides a unified framework for analyzing existing methods.   \n• We provide an implementation of our framework using a set of deep normalizing flows [Dinh et al., 2014, 2016; Kingma and Dhariwal, 2018] in the extended latent space of a StyleGAN [Karras et al., 2020]. This implementation can leverage the hierarchy of learned representations, and perform targeted attacks while preserving diversity.   \n• Empirically, on the CelebA [Liu et al., 2015], and ChestX-ray [Wang et al., 2017] datasets, our method results in higher attack accuracy, and more diverse generation compared to existing methods. We provide thorough comparative experiments to understand which components contribute to improved target accuracy, sample realism, and sample diversity, and detail the benefits of the VI perspective. ",
+        "bbox": [
+            217,
+            501,
+            826,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Code can be found at https://github.com/wangkua1/vmi. ",
+        "bbox": [
+            173,
+            688,
+            586,
+            702
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Problem Setup: Model Inversion Attack ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            719,
+            540,
+            737
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the problem of model inversion (MI) attack, the attacker has access to a “target classifier”: ",
+        "bbox": [
+            169,
+            751,
+            782,
+            765
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bc527a32077e54b2495ea0eb3d73c768a53deb5a1b7fc3545fe4884065b5bb8c.jpg",
+        "text": "$$\n\\overline { { p } } _ { \\mathtt { T A R } } ( y | \\mathbf { x } ) : \\mathbb { R } ^ { d } \\to \\Delta ^ { C - 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            770,
+            581,
+            790
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\Delta ^ { C - 1 }$ to denote the $( C - 1 )$ -simplex, representing the $C$ -dimensional probability where $C$ is the number of classes. This target classifier is trained on the private target dataset, $\\mathcal { D } _ { \\mathrm { T A R } } = \\{ { \\bf x } _ { i } , y _ { i } \\} _ { i = 1 } ^ { N _ { \\mathrm { T A R } } }$ where $\\mathbf { x } \\in \\mathbb { R } ^ { d }$ and $y \\in \\{ 1 , 2 , . . . , C \\}$ . We use $\\overline { { p } } _ { \\mathrm { T A R } } ( y | \\mathbf { x } )$ to denote the given target classifier, which is an approximation of the true conditional probability $p _ { \\mathrm { T A R } } ( y | \\mathbf { x } )$ of the underlying data generating distribution. ",
+        "bbox": [
+            173,
+            795,
+            825,
+            869
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Goal. Given a target classifier $\\overline { { p } } _ { \\mathrm { T A R } } ( y | \\mathbf { x } )$ , we wish to approximate the class conditional distribution $p _ { \\mathrm { T A R } } ( \\mathbf { x } | y )$ without having access to the private training set $\\mathcal { D } _ { \\mathrm { T A R } }$ . ",
+        "bbox": [
+            173,
+            882,
+            821,
+            912
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A good model inversion attack should approximate the Bayes posterior $p _ { \\mathtt { T A R } } ( \\mathbf { x } | y ) \\propto p _ { \\mathtt { T A R } } ( y | \\mathbf { x } ) p _ { \\mathtt { T A R } } ( \\mathbf { x } )$ well, and allow the attacker to generate realistic, accurate, and diverse samples. Notice, our goal shifts slightly from recovering the exact instances in the training set to recovering the data generating distribution of the training data. Let’s consider a scenario where the attacker intends to fake a victim’s identity. A good security system might test the realism of a sequence of inputs [Holland and Komogortsev, 2013]. More generally, faking someone’s identity requires passing a two-sample test [Holland and Komogortsev, 2013; Lehmann and Romano, 2006], which means the ability to generate samples from $p _ { \\mathrm { T A R } } ( \\mathbf { x } | y )$ is necessary. Another scenario can be an attacker trying to steal private/proprietary information. For example, a malicious insider in a federated learning setting can try to steal information from another datacenter by accessing the shared model [Hitaj et al., 2017]. In such a scenario, a good $p _ { \\mathrm { T A R } } ( \\mathbf { x } | y )$ model can reveal not only the distinguishing features of the data, but also its variations. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            257
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            276,
+            321,
+            292
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first discuss related model inversion attack studies, and then discuss applications of inverting a classifier outside of the privacy attack setting. Lastly, since our attack method relies on using a pretrained generator, we discuss existing studies that used a pretrained generator for improving other applications. ",
+        "bbox": [
+            174,
+            308,
+            823,
+            363
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Model inversion attacks. MI attacks are one type of privacy attack where the attacker tries to reconstruct the training examples given access only to a target classifier. Other privacy attacks include membership attacks, attribute inference, and model extraction attacks (see Rigaki and Garcia [2020] for a general discussion). Fredrikson et al. [Fredrikson et al., 2015, 2014] were the first to study the MI attack and demonstrated successful attacks on low-capacity models (e.g., logistic regression, and a shallow MLP network) when partial input information was available to the attacker. The setting where partial input information was not available was studied by Hidano et al. [2017]. They termed performing gradient ascent w.r.t. the target classifier in the input space a General Model Inversion attack. Though effective on tabular data, this approach failed on deep image classifiers. It is well-known that directly performing gradient ascent in the image space results in imperceptible and unnatural changes [Szegedy et al., 2013]. ",
+        "bbox": [
+            174,
+            377,
+            825,
+            530
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To handle high-dimensional observations such as images, MI attacks based on deep generators were proposed [Chen et al., 2020; Yang et al., 2019b; Zhang et al., 2020]. By training a deep generator on an auxiliary dataset, these methods effectively reduce the search space to only the manifold of relevant images. For example, if the target classifier is a facial recognition system, then an auxiliary dataset of generic faces can be easily obtained. Zhang et al. [2020] pretrain a Generative Adversarial Network (GAN) [Goodfellow et al., 2014] on the auxiliary dataset and performed gradient-based attack in the latent space of the generator. Yang et al. [2019b] trained a generator that inverts the prediction of the target classifier, using the architecture of an autoencoder. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            646
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Other applications of classifier inversion. Inverting the predictions and activations of a classifier has been studied for applications such as model explanation, and model distillation. Motivated by using saliency maps to explain the decision of a classifier [Simonyan et al., 2013], Mahendran and Vedaldi [2015] proposed to maximize the activation of a target neuron in a classifier for synthesizing images that best explain that neuron. Their method is based on gradient ascent in the pixel-space. The same idea was recently extended to enable knowledge distillation in a setting where the original dataset was too large to be transferred [Yin et al., 2020]. Methods above have the advantage of not requiring the original dataset, but the generated images still appear unnatural. One effective way to improve the realism of the generated images is to optimize in the latent code space of a deep generator [Nguyen et al., 2015, 2017]. ",
+        "bbox": [
+            174,
+            661,
+            825,
+            799
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Pretrained generators. Pretrained generators from GANs have other applications. Image inpainting/restoration was one of the early successful applications of using a pretrained GAN as image prior. Yeh et al. [2017] optimized the latent code of GANs to minimize the reconstruction error of a partially occluded image for realistic inpainting. The same method formed the basis of AnoGAN, a popular technique for anomaly detection in medical images [Schlegl et al., 2017]. A combination of reconstruction error and discriminator loss was used as the anomaly score. A potential future direction is to apply our proposed method to these adjacent applications. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 Model Inversion Attack as Variational Inference ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            88,
+            609,
+            107
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we derive our Variational Model Inversion (VMI) learning objective. For each class label $y$ , we wish to approximate the true target posterior with a variational distribution $q ( \\mathbf { x } ) \\in \\mathcal { Q } _ { \\mathbf { x } }$ , where $\\mathcal { Q } _ { \\bf x }$ is the variational family. This can be achieved by the optimizing the following objectives ",
+        "bbox": [
+            174,
+            118,
+            826,
+            161
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/133bc5eed09482688b890e02f7484ed587d8a954053b75b131de568a62f97369.jpg",
+        "text": "$$\n\\begin{array} { r l } & { q ^ { * } ( \\mathbf { x } ) = \\underset { q \\in \\mathcal { Q } _ { \\mathbf { x } } } { \\arg \\operatorname* { m i n } } \\left. D _ { \\mathrm { K L } } ( q ( \\mathbf { x } ) | | p _ { \\mathrm { r a R } } ( \\mathbf { x } | y ) ) \\right. } \\\\ & { \\qquad = \\underset { q \\in \\mathcal { Q } _ { \\mathbf { x } } } { \\arg \\operatorname* { m i n } } \\left. \\mathbb { E } _ { q ( \\mathbf { x } ) } [ - \\log p _ { \\mathrm { r a R } } ( y | \\mathbf { x } ) ] + D _ { \\mathrm { K L } } ( q ( \\mathbf { x } ) | | p _ { \\mathrm { r a R } } ( \\mathbf { x } ) ) + \\log p _ { \\mathrm { r a R } } ( y ) \\right. } \\\\ & { \\qquad = \\underset { q \\in \\mathcal { Q } _ { \\mathbf { x } } } { \\arg \\operatorname* { m i n } } \\left. \\mathbb { E } _ { q ( \\mathbf { x } ) } [ - \\log p _ { \\mathrm { r a R } } ( y | \\mathbf { x } ) ] + D _ { \\mathrm { K L } } ( q ( \\mathbf { x } ) | | p _ { \\mathrm { r a R } } ( \\mathbf { x } ) ) \\right. . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            160,
+            766,
+            250
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where in Equation 1 we have used the fact that $\\log p _ { \\mathrm { T A R } } ( y )$ is independent of $q ( \\mathbf { x } )$ , and thus can be dropped in the optimization. ",
+        "bbox": [
+            173,
+            256,
+            823,
+            285
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Auxiliary Image Prior. In order to minimize Eq. (1), we need to compute $D _ { \\mathrm { K L } } ( q ( \\mathbf { x } ) | | p _ { \\mathrm { T A R } } ( \\mathbf { x } ) )$ , which requires evaluating the true image prior $p _ { \\mathrm { T A R } } ( \\mathbf { x } )$ , that is not accessible. Similar to recent works on MI attacks [Khosravy et al., 2020; Yang et al., 2019b; Zhang et al., 2020], we assume that a public auxiliary dataset ${ \\mathcal { D } } _ { \\mathrm { A U X } }$ , which shares structural similarity with the target dataset, is available to learn an auxiliary image prior $p _ { \\mathrm { A U X } } ( \\mathbf { x } )$ . This auxiliary image prior $p _ { \\mathrm { A U X } } ( \\mathbf { x } )$ is learned using a generative adversarial network (GAN) $p _ { \\mathrm { A U X } } ( \\mathbf { x } ) = \\mathbb { E } _ { p _ { \\mathrm { A U X } } ( \\mathbf { \\bar { z } } ) } [ p _ { \\mathrm { G } } ( \\mathbf { \\bar { x } } | \\mathbf { \\bar { z } } ) ]$ , where $p _ { \\mathrm { A U X } } ( \\mathbf { z } ) = \\mathcal { N } ( 0 , I )$ is the GAN prior, and $p _ { \\mathrm { G } } ( \\mathbf { x } | \\mathbf { z } )$ is the GAN generator that is parameterized by a deep neural network $G ( \\mathbf { z } )$ , and a Gaussian observation noise with small standard deviation $\\sigma \\colon p _ { \\mathtt { G } } ( \\mathbf { x } | \\mathbf { z } ) = { \\mathcal { N } } { \\big ( } G ( \\mathbf { z } ) , \\sigma ^ { 2 } I { \\big ) }$ , or equivalently ",
+        "bbox": [
+            173,
+            296,
+            826,
+            425
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f3b57079c43f462ba2282e78ba016b767df24e77b060561f4cbf7b0eba4f9a01.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { x } = G ( \\mathbf { z } ) + \\sigma \\epsilon , \\quad \\epsilon \\sim \\mathcal { N } ( 0 , I ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            422,
+            606,
+            440
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The learned generator $p _ { \\mathrm { G } } ( \\mathbf { x } | \\mathbf { z } )$ defines a low dimensional manifold in the observation space $\\mathbf { x }$ , when $\\mathbf { z }$ is chosen to have fewer dimensions than $\\mathbf { x }$ . We now make the following assumption about the structural similarity of $p _ { \\mathrm { A U X } } ( \\mathbf { x } )$ and $p _ { \\mathrm { T A R } } ( \\mathbf { x } )$ . ",
+        "bbox": [
+            173,
+            446,
+            825,
+            489
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Assumption 1 (Common Generator). We assume $p _ { \\mathrm { T A R } } ( \\mathbf { x } )$ is concentrated close to the low dimensional manifold of $p _ { \\mathrm { G } } ( \\mathbf { x } | \\mathbf { z } )$ , learned from the auxiliary dataset $\\mathcal { D } _ { \\mathrm { A U X } }$ . In other words, we assume there exists a target prior $p _ { \\mathrm { T A R } } ( \\mathbf { z } )$ , possibly different from $p _ { \\mathrm { A U X } } ( \\mathbf { z } )$ , such that $p _ { \\mathtt { T A R } } ( \\mathbf { x } ) \\approx \\mathbb { E } _ { p _ { \\mathtt { T A R } } ( \\mathbf { z } ) } [ p _ { \\mathtt { G } } ( \\mathbf { x } | \\mathbf { z } ) ]$ . We refer to $p _ { \\mathrm { G } } ( \\mathbf { x } | \\mathbf { z } )$ as the “common generator”. ",
+        "bbox": [
+            173,
+            491,
+            825,
+            549
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The name “common generator” is inspired by recent progress in theoretical analyses of few-shot and transfer learning, where assumptions about an underlying shared representation have been used to provide error bounds. In these works, this shared representation is referred to as the “common representation” [Du et al., 2020; Tripuraneni et al., 2020]. Assumption 1 usually holds in the context of model inversion attacks. For example, $p _ { \\mathrm { A U X } } ( \\mathbf { x } )$ could be the distribution of all human faces, while $p _ { \\mathrm { T A R } } ( \\mathbf { x } )$ could be the distribution of the celebrity faces; or $p _ { \\mathrm { A U X } } ( \\mathbf { x } )$ could be the distribution of natural images, while $p _ { \\mathrm { T A R } } ( \\mathbf { x } )$ could be the distribution of different breeds of dogs. In these examples, both $p _ { \\mathrm { A U X } } ( \\mathbf { x } )$ and $p _ { \\mathrm { T A R } } ( \\mathbf { x } )$ approximately live close to the same low dimensional manifold, but the distribution on this shared manifold could be different, i.e., $p _ { \\mathtt { T A R } } ( \\mathbf { z } ) \\neq p _ { \\mathtt { A U X } } ( \\mathbf { z } )$ . ",
+        "bbox": [
+            173,
+            556,
+            825,
+            683
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Variational Family. We further consider our variational family $\\mathcal { Q } _ { \\bf x }$ to be all distributions that lie on this manifold by assuming that $q ( \\mathbf { x } )$ is of the form $q ( \\mathbf { x } ) = \\mathbb { E } _ { q ( \\mathbf { z } ) } [ p _ { \\mathrm { G } } ( \\mathbf { x } | \\mathbf { z } ) ]$ , $q ( \\mathbf { z } ) \\in \\mathcal { Q } _ { \\mathbf { z } }$ , where $\\mathcal { Q } _ { \\mathbf { z } }$ is a variational family in the code space. In the next section, we further restrict $\\mathcal { Q } _ { \\mathbf { z } }$ to be either Gaussian distributions or normalizing flows. ",
+        "bbox": [
+            173,
+            694,
+            825,
+            750
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1. We have $D _ { \\mathrm { K L } } \\big ( q ( \\mathbf { z } ) | | p _ { \\mathrm { T A R } } ( \\mathbf { z } ) \\big ) \\geq D _ { \\mathrm { K L } } \\big ( \\mathbb { E } _ { q ( \\mathbf { z } ) } [ p _ { \\mathrm { G } } ( \\mathbf { x } | \\mathbf { z } ) ] | | \\mathbb { E } _ { p _ { \\mathrm { T A R } } ( \\mathbf { z } ) } [ p _ { \\mathrm { G } } ( \\mathbf { x } | \\mathbf { z } ) ] \\big ) .$ ",
+        "bbox": [
+            174,
+            751,
+            761,
+            770
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "See Appendix A for the proof. Using Assumption 1, we can approximate the objective of Equation 1 with ",
+        "bbox": [
+            173,
+            775,
+            823,
+            804
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fdce7b83dd470a422a7ffbd66d258f93d1e1646cbdba7ff2fdbdcf07174d1900.jpg",
+        "text": "$$\n\\mathbf { \\Sigma } ^ { * } ( \\mathbf { z } ) = \\underset { q \\in \\mathcal { Q } _ { \\infty } } { \\operatorname { a r g m i n } } \\left. \\mathbb { E } _ { \\mathbf { z } \\sim q ( \\mathbf { z } ) , \\epsilon \\sim \\mathcal { N } ( 0 , I ) } [ - \\log p _ { \\mathrm { r a g } } ( y | G ( \\mathbf { z } ) + \\sigma \\epsilon ) ] + D _ { \\mathrm { K L } } \\big ( \\mathbb { E } _ { q ( \\mathbf { z } ) } [ p _ { \\mathrm { o } } ( \\mathbf { x } | \\mathbf { z } ) ] | | \\mathbb { E } _ { p _ { \\mathrm { r a g } } ( \\mathbf { z } ) } [ p _ { \\mathrm { o } } ( \\mathbf { x } | \\mathbf { z } ) ] \\big ) \\right. ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            803,
+            825,
+            829
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where this objective is now defined in terms of $q ( \\mathbf { z } ) \\in \\mathcal { Q } _ { \\mathbf { z } }$ in the latent space of the GAN. Now using the Proposition 1, we can obtain the following upper bound on the objective of Equation 2 (assuming $\\sigma = 0$ ) ",
+        "bbox": [
+            173,
+            844,
+            825,
+            886
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2c2dd9dfaa10852b80d12640ca42902d74ee6233dcdce20cf427d9d6bef22ac3.jpg",
+        "text": "$$\n\\begin{array} { r } { q ^ { * } ( \\mathbf { z } ) = \\underset { q \\in \\mathcal { Q } _ { \\mathbf { z } } } { \\arg \\operatorname* { m i n } } \\left\\{ \\mathbb { E } _ { \\mathbf { z } \\sim q ( \\mathbf { z } ) } [ - \\log p _ { \\mathrm { T A R } } ( y | G ( \\mathbf { z } ) ) ] + D _ { \\mathrm { K L } } ( q ( \\mathbf { z } ) | | p _ { \\mathrm { T A R } } ( \\mathbf { z } ) ) \\right\\} . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            887,
+            738,
+            915
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Power Posteriors. We now consider the optimization of Equation 3. Since we do not have access to $p _ { \\mathrm { T A R } } ( \\mathbf { z } )$ , we propose to replace it with $p _ { \\mathrm { A U X } } ( \\mathbf { z } )$ , noting that, as argued above, $p _ { \\mathrm { A U X } } ( \\mathbf { z } )$ may not accurately represent $p _ { \\mathrm { T A R } } ( \\mathbf { z } )$ . We also propose to replace the unknown likelihood $p _ { \\mathrm { T A R } } ( y | G ( \\mathbf { z } ) )$ with the $\\overline { { p } } _ { \\mathrm { T A R } } ( y | G ( \\mathbf { z } ) )$ defined by the target classifier, noting that this likelihood could be miscalibrated. Miscalibration is a known problem in neural network classifiers [Guo et al., 2017]; namely, the classifier predictions can be over- or under-confident. In order to account for these issues, instead of the standard Bayes posterior $q _ { \\mathtt { B A Y E S } } ( \\mathbf { z } ) \\propto p _ { \\mathrm { A U X } } ( \\mathbf { z } ) \\overline { { p } } _ { \\mathtt { T A R } } ( y | G ( \\mathbf { z } ) )$ as the solution of Equation 3, we consider the family of “power posterior” 1 [Bissiri et al., 2016; Holmes and Walker, 2017; Knoblauch et al., 2019; Miller and Dunson, 2018], which raise the likelihood function to a power $\\frac { 1 } { \\gamma }$ ",
+        "bbox": [
+            173,
+            90,
+            826,
+            218
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/14472e3964962a56714fa1dc15858bfda8e1ec8fc7b75e8244aa9d932a4fcefd.jpg",
+        "text": "$$\nq _ { \\gamma } ^ { * } ( \\mathbf { z } ) \\propto p _ { \\mathrm { A U X } } ( \\mathbf { z } ) \\overline { { p } } _ { \\mathrm { T A R } } ^ { \\frac { 1 } { \\gamma } } ( y | G ( \\mathbf { z } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            228,
+            599,
+            253
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and can be characterized as the solution of the following optimization problem: ",
+        "bbox": [
+            173,
+            261,
+            692,
+            276
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/592865399501b7f5abda8c713706a7aeb6215e36a0f683964d5e72fac14a495e.jpg",
+        "text": "$$\n\\begin{array} { r } { \\begin{array} { r l } & { q _ { \\gamma } ^ { * } ( \\mathbf { z } ) = \\underset { q \\in \\mathcal { Q } _ { \\mathbf { z } } } { \\arg \\operatorname* { m i n } } \\mathcal { L } _ { \\mathrm { v u r } } ^ { \\gamma } ( q ) , } \\\\ & { \\mathcal { L } _ { \\mathrm { v M I } } ^ { \\gamma } ( q ) : = \\mathbb { E } _ { \\mathbf { z } \\sim q ( \\mathbf { z } ) } [ - \\log \\overline { { p } } _ { \\mathrm { T A R } } ( y | G ( \\mathbf { z } ) ) ] + \\gamma D _ { \\mathrm { K L } } ( q ( \\mathbf { z } ) | | p _ { \\mathrm { A U X } } ( \\mathbf { z } ) ) . } \\end{array} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            284,
+            717,
+            333
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "See Appendix A for the proof. If the prior $p _ { \\mathrm { A U X } } ( \\mathbf { z } )$ is not reliable, by decreasing $\\gamma$ , we can reduce the importance of the prior. Similarly, by adjusting $\\gamma$ , we can reduce or increase the importance of overor under-confident likelihood predictions $\\overline { { p } } _ { \\mathrm { T A R } } ( y | G ( \\mathbf { z } ) )$ . ",
+        "bbox": [
+            174,
+            340,
+            825,
+            385
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Accuracy vs. Diversity Tradeoff. In the context of model inversion attack, the Bayes posterior $q _ { \\mathrm { B A Y E S } } ( \\mathbf { z } )$ can only achieve a particular tradeoff between the accuracy and diversity of the generated samples. However, the family of power posteriors enables us to achieve an arbitrary desired tradeoff between accuracy and diversity by tuning $\\gamma$ . If $\\gamma = 0$ , then ${ q } _ { \\gamma = 0 } ^ { * } ( \\mathbf { z } ) = \\delta ( \\mathbf { z } - \\mathbf { z } ^ { * } )$ , and the model essentially ignores the image prior and diversity, and finds a single point estimate $\\mathbf { z } ^ { \\ast }$ on the manifold which maximizes the accuracy $\\overline { { p } } _ { \\mathrm { T A R } } ( y | G ( \\mathbf { z } ) )$ . As we increase $\\gamma$ , the the model achieves larger diversity at the cost of smaller average accuracy. When $\\gamma = 1$ , we recover the Bayes posterior $q _ { \\gamma = 1 } ^ { * } ( \\mathbf { z } ) \\propto p _ { \\mathrm { A U X } } ( \\mathbf { z } ) \\overline { { p } } _ { \\mathrm { T A R } } ( y | G ( \\mathbf { z } ) )$ . In the limit of $\\gamma \\to \\infty$ , we have $q _ { \\infty } ^ { * } ( \\mathbf { z } ) \\ = \\ p _ { \\mathrm { A U X } } ( \\mathbf { z } )$ . In this case, the model ignores the classifier and accuracy, and sample unconditionally from the auxiliary distribution (maximum diversity). We empirically study the effect of $\\gamma$ in Section 5. ",
+        "bbox": [
+            173,
+            392,
+            825,
+            531
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 The Common Generator ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            542,
+            385,
+            558
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the previous section, we derived a practical MI objective from the perspective of variational inference. Similar to previous works [Chen et al., 2020; Zhang et al., 2020] VMI requires a common generator that is trained on a relevant auxiliary dataset. In this subsection, we first provide a brief description of the most common choice, DCGAN. Then, we introduce StyleGAN, which has an architecture that allows for fine-grained control. Finally, we describe how to adapt our VMI objective to leverage this architecture by using a layer-wise approximate distribution. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            645
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For the common generator $G$ we use a GAN due to their ability to synthesize high quality samples [Abdal et al., 2019; Bau et al., 2018; Karras et al., 2019; Shen et al., 2020]. The generator is trained on the auxiliary dataset. A common choice is the DCGAN architecture [Radford et al., 2015]. Though optimizing in the latent space results in more realistic samples, this search space is also more restrictive. Early investigation showed that optimizing at some intermediate layers of a pretrained generator was better than either optimizing in the code space, or the pixel space. This motivated the use of a generator architecture where activations of intermediate layers can be manipulated. ",
+        "bbox": [
+            173,
+            650,
+            825,
+            747
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "StyleGAN. A framework that naturally allows for optimization in the intermediate layers is the $S$ yleGAN [Karras et al., 2019]. It consists of a mapping network . The synthesis network takes as input one w at each layer, $f : \\mathbf { z } \\mapsto \\mathbf { w }$ $\\dot { S } : \\{ \\mathbf { w } _ { l } \\} _ { l = 1 } ^ { L } \\mapsto \\mathbf { x }$ ynthesis, where $L$ etworkis the number of layers in $S$ . During training of a StyleGAN, the output from the mapping network is copied $L$ times, $\\{ \\mathbf { w } \\} _ { l = 1 } ^ { L } = \\mathrm { c o p y } ( \\mathbf { w } , L )$ before being fed to the synthesis network. This input space of the synthesis network $S$ has been referred to as the “extended w space” [Abdal et al., 2019]. The full generator is $G _ { \\mathrm { { s T Y L E } } } ( \\mathbf { z } ) = S \\Big ( \\mathrm { { c o p Y } } \\big ( f ( \\mathbf { z } ) , L \\big ) \\Big )$ . ",
+        "bbox": [
+            173,
+            763,
+            825,
+            869
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/12ec27e7922d22da99dc0038a4dad4044670322e1e61a5df1a47bb3f6890abcf.jpg",
+        "image_caption": [
+            "Figure 2: Visualizing the factors of variations in each layer of the StyleGAN [Karras et al., 2019] using style mixing. Each image is generated by mixing the the corresponding image in the topmost row, and the image in the leftmost column. The topmost row image provides the features for the indicated set of layers, and the leftmost column image provides features for the remaining layers. We can see that in general, the earlier features contribute more to the facial features, while the later features contribute more to the low-level images statistics such as lighting and general shading. Given this learned layer-wise disentanglement, our VMI attack can adaptively discover layers that contribute the most to the face identity (layers $1 , 2 , 4 , 5 , 6$ ), and only manipulates the corresponding features (see Figure 7). This is not facilitated by the generator of a DCGAN, as found in existing MI attack methods [Chen et al., 2020; Zhang et al., 2020]. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            261,
+            93,
+            738,
+            233
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "StyleGAN is known for its surprising ability to perform “style mixing”. Namely, the synthesis network can generate a “mixed” image, when being fed a mixture of two w’s in the extended w space, i.e., $S ( [ \\{ \\mathbf { w } _ { 1 } \\} _ { l = 1 } ^ { L _ { 0 } } ; \\{ \\mathbf { w } _ { 2 } \\} _ { l = L _ { 0 } + 1 } ^ { L } ] )$ , where $[ \\cdot ; \\cdot ]$ denotes concatenation, and $L _ { 0 }$ is some intermediate layer. Figure 2 visualizes the effect of manipulating different layers of the synthesis network. Performing an attack in this extended w space allows us to achieve the desired effect of optimizing the intermediate layers. Because of the lack of a explicit prior for w, we instead optimize the extended $\\mathbf { z }$ space (Figure 3). ",
+        "bbox": [
+            174,
+            398,
+            485,
+            582
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Suppose $q ( \\mathbf { z } _ { 1 } , \\ldots , \\mathbf { z } _ { L } )$ is the joint density over ",
+        "bbox": [
+            176,
+            583,
+            485,
+            597
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/910cdcdabf56a3637cb3e8d21ef8fd25417c343f6fdd544fe4629c8f3d804149.jpg",
+        "image_caption": [
+            "Figure 3: Utilizing the StyleGAN architecture, our VMI attack tends to focus on layers whose representation are relevant for the attack, such as the layer for “face shape”. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            395,
+            815,
+            513
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { z } _ { 1 } , \\ldots , \\mathbf { z } _ { L }$ , and $q _ { l } ( { \\bf z } _ { l } )$ is the marginal density over $\\mathbf { z } _ { l }$ . We consider the following objective for the VMI with the StyleGAN generator: ",
+        "bbox": [
+            176,
+            597,
+            825,
+            623
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/86d66caf06a3ad813f285e4fe3f0e24b8af593a364a70a5220fa2663d59edc79.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { s - v M } } ^ { \\gamma } ( q ) : = \\mathbb { E } _ { q ( \\mathbf { z } _ { 1 } , \\ldots , \\mathbf { z } _ { L } ) } \\Big [ - \\log \\overline { { p } } _ { \\mathrm { r a R } } \\Big ( y \\Big | S \\big ( \\{ f ( \\mathbf { z } _ { l } ) \\} _ { l = 1 } ^ { L } \\big ) \\Big ) \\Big ] + \\frac { \\gamma } { L } \\sum _ { l = 1 } ^ { L } D _ { \\mathrm { K L } } ( q _ { l } ( \\mathbf { z } _ { l } ) | | p _ { \\mathrm { A U X } } ( \\mathbf { z } _ { l } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            621,
+            790,
+            664
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Code Space Variational Family $\\mathcal { Q } _ { \\mathbf { z } }$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            664,
+            452,
+            679
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the VMI formulations (Equation 4 and 5), the approximate distribution $q ( \\mathbf { z } )$ can be seen as a generator, or “miner” network [Wang et al., 2020] for the latent space of the common generator. It must belong to a distribution family $\\mathcal { Q } _ { \\mathbf { z } }$ , whose distribution can be sampled from, and can be evaluated in order to optimize the KL-divergence. In this work, we experiment with a powerful class of tractable generative models: deep flow models. When optimizing $\\mathcal { L } _ { \\mathrm { s - V M I } } ^ { \\gamma } ( q )$ (Equation 5), we use $L$ such models, one for each layer in the synthesis network. In our experiments, we used an architecture similar to that of Glow [Kingma and Dhariwal, 2018], where we treated the latent vector as 1x1 images. We removed the original squeezing layers that reduced the image size to account for this change. We also experimented with using a Gaussian variational family for $q ( \\mathbf { z } )$ . ",
+        "bbox": [
+            173,
+            681,
+            826,
+            808
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Relationships with Existing Methods ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            821,
+            468,
+            837
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "VMI provides a unified framework that encompasses existing attack methods. Through the lens of VMI, we can obtain insights on the conceptual differences between the existing methods and their pros and cons. “General MI” attack [Hidano et al., 2017] performs the following optimization: ",
+        "bbox": [
+            173,
+            839,
+            826,
+            881
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0136dd29e0d195aa9c4bedb79341de54a0ddd23f5e4e0c7242481f052ddcf2ba.jpg",
+        "text": "$$\n\\mathbf { x } ^ { * } = \\mathop { \\underset { \\mathbf { x } } { \\operatorname { \\arg m a x } } } \\log \\overline { { p } } _ { \\mathrm { T A R } } ( y | \\mathbf { x } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            883,
+            596,
+            909
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/cae78751cba9824787ffb9a601e25fa880d387b8d686ce87669135e18f333f05.jpg",
+        "image_caption": [
+            "Figure 4: Visualization of real samples for all 3 tasks: MNIST, CelebA, and ChestX-ray. For the target datasets, each row corresponds to one class/identity. Best viewed zoomed in. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            88,
+            820,
+            172
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Note that this objective can be viewed as special case of VMI, where the code space is the same as the data space, and we have $\\gamma = 0$ in the objective: $\\mathcal { L } _ { \\mathrm { v M } } ^ { \\gamma = 0 } ( q )$ . In this case, as discussed in the previous section, the $q ( \\mathbf { x } )$ distribution collapses to a point estimate at which $\\overline { { p } } _ { \\mathrm { T A R } } ( y | \\mathbf { x } )$ is maximized. As we will see in the experiment section, since the optimization is in the data space, the solution does not live close the manifold of images, and thus generally does not structurally looks like natural images. ",
+        "bbox": [
+            173,
+            229,
+            825,
+            303
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "“Generative MI” attack [Zhang et al., 2020] also uses a generator trained on an “auxiliary” dataset. The attack optimizes the following objective: ",
+        "bbox": [
+            173,
+            308,
+            820,
+            337
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/76d127e64dde99e44b039ca1c49a52eb0985d43414e387580e8086cd08366d67.jpg",
+        "text": "$$\n\\mathbf { z } ^ { * } = \\underset { \\mathbf { z } } { \\arg \\operatorname* { m i n } } \\left\\{ - \\lambda \\log \\overline { { p } } _ { \\mathrm { T A R } } ( y | ( G ( \\mathbf { z } ) ) - \\log \\sigma \\big ( D ( G ( \\mathbf { z } ) ) \\big ) \\right\\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            343,
+            696,
+            371
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $G , D$ denotes the generator and discriminator respectively, and $\\sigma ( \\cdot )$ is the sigmoid function. Note that this objective can be viewed as special case of VMI, with $\\begin{array} { r } { \\gamma = \\frac { 1 } { \\lambda } } \\end{array}$ , and with the prior $p ( \\mathbf { z } ) \\propto \\sigma \\big ( D ( G ( \\mathbf { z } ) \\big )$ , and a point estimate for $\\mathbf { z }$ , instead of optimizing over distributions $q ( \\mathbf { z } )$ . As a result of this point-wise optimization, the Generative MI attack requires re-running the optimization procedure for every new samples. In contrast, VMI learns a distribution $q ( \\mathbf { z } )$ using expressive normalizing flows, which allows us to draw multiple attack samples after a single optimization procedure. Recently, Chen et al. [2020] proposed extending Generative MI by considering a Gaussian variational family in the latent space of the pretrained generator in Equation 7. However, we note this method still theoretically results in collapsing the Gaussian variational distributions to a point estimate. VMI prevents this by penalizing the entropy of the variational distribution with the KL-divergence term. From the implementation perspective, Chen et al. [2020] uses DCGAN while we use StyleGAN which helps us to achieve better disentanglement. Furthermore, we use a more expressive variational family such as normalizing flows. ",
+        "bbox": [
+            173,
+            378,
+            826,
+            563
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            575,
+            312,
+            593
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we demonstrate the effectiveness of the proposed VMI attack method on three separate tasks. We will refer to each task by their target dataset: MNIST [LeCun et al., 2010], CelebA [Liu et al., 2015], and ChestX-ray (CXR) [Wang et al., 2017]. Then, we showcase the robustness of the VMI attack to different target classifiers on CelebA. More experimental details can be found in Appendix B. ",
+        "bbox": [
+            173,
+            607,
+            825,
+            678
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Data. For the MNIST task, we used the ‘letters’ split (i.e., handwritten English alphabets) of the EMNIST [Cohen et al., 2017] dataset as the auxiliary dataset. For CelebA, we used the 1000 most frequent identities as the target dataset, and the rest as the auxiliary dataset. For ChestX-ray, we used the 8 diseases outlined by Wang et al. [2017] as the target dataset, and randomly selected 50,000 images from the remaining as the auxiliary dataset. Real samples from these six datasets are visualized in Figure 4. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            770
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Target classifiers. The target classifiers used in all tasks were ResNets trained using SGD with momentum. Optimization hyperparameters were selected to maximize accuracy on a validation set of the private data. ",
+        "bbox": [
+            174,
+            773,
+            825,
+            816
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Evaluation metrics. An ideal evaluation protocol should measure different aspects of the attack samples such as target accuracy, sample realism, and sample diversity. ",
+        "bbox": [
+            174,
+            821,
+            820,
+            849
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Target Accuracy: To automate the process of judging the accuracy of an attack, we use an “evaluation” classifier. This metrics measures how well the generated samples resemble the target class/identity. Given a target identity $i$ , an attack produces a set of samples $\\{ \\mathbf { x } _ { n } ^ { \\prime } \\} _ { n = 1 } ^ { N }$ . Each sample is assigned a predicted label by the evaluation classifier, and then the top-1 accuracy is computed. ",
+        "bbox": [
+            174,
+            856,
+            826,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/093c5232de01098cb0ea8e9db780858043aa33839c715c495d026f9f44a0678b.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\bf { \\sigma } } _ { \\mathrm { { G e n e r a l } ~ M I ~ [ H i d a n o ~ e t a l . ~ 2 0 1 7 ] } } ^ { \\bf { A c c u r a c y \\dagger } } } & { { \\bf { \\sigma } } _ { \\mathrm { { K L } } } ^ { \\mathrm { { F I D } } } . } \\\\ { { \\bf { \\sigma } } _ { \\mathrm { { G e n e r a l } ~ M I ~ [ H i d a n o ~ e t a l . ~ 2 0 1 7 ] } } ^ { \\bf { C } } } & { { \\bf { \\sigma } } _ { \\mathrm { { G e l e b a } } } ^ { \\mathrm { { G e l e b A } } } } & { { \\bf { \\sigma } } _ { \\mathrm { { X } } } { \\bf { R } } } \\\\ { { \\bf { \\sigma } } _ { \\mathrm { { G e n e r a l } ~ M I ~ [ H i d a n o ~ e t a l . ~ 2 0 1 7 ] } } ^ { \\bf { G e n d } } } & { { \\bf { \\sigma } } _ { \\mathrm { { 0 } } + \\mathrm { { 0 } } , \\mathrm { { 0 } } + \\mathrm { { 0 } } , \\mathrm { { 0 } } + \\mathrm { { 0 } } , \\mathrm { { 2 } } 3 + \\mathrm { { 0 } } , \\mathrm { { 2 } } 3 + \\mathrm { { 0 } } , \\mathrm { { 2 } } 5 / \\mathrm { { 6 } } , { 7 } 4 \\mathrm { { 0 } } , \\mathrm { { 2 } } 1 . 2 1 \\mathrm { { \\sigma } } _ { \\mathrm { { { 0 } } } , \\mathrm { { 3 } } } } } & { { \\mathrm { { 4 9 } } 2 . 5 4 \\mathrm { { \\sigma } } _ { \\mathrm { { 0 } } 6 , \\mathrm { { 3 } } } } } \\\\  { \\frac { { \\bf { G e n e r a t i v e ~ M I ~ [ Z h a n g ~ e t a l . ~ 2 0 2 0 ] } } } { \\bf { \\sigma } } _ { \\mathrm { { S } } } } & { { \\bf { 0 } . 9 2 \\pm \\mathrm { { 0 } } \\mathrm { { 0 } } 2 } } &  { 0 . 0 7 \\pm \\mathrm { { 0 } } \\mathrm { { 2 } } \\mathrm { { 0 } } \\mathrm { { 2 } } \\mathrm { { 0 } } \\mathrm { { 2 } } \\mathrm { { 0 } } \\mathrm { { 2 } } \\mathrm { { 8 } } \\mathrm { { 2 } } 0 . 3 \\mathrm { { \\sigma } } _ { \\mathrm { { 0 } } } } &  { \\bf { 0 } . 9 1 \\mathrm { { \\sigma } } _ { \\mathrm { { 0 } } \\mathrm { { 3 } } } } &   \\bf { 2 } 6 \\mathrm { 5 } , \\mathrm { { 1 } } 4 \\mathrm { { 0 } } \\mathrm    \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            87,
+            833,
+            184
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: MI attack comparison across tasks. Both VMI methods here used the Flow model for $q ( \\mathbf { z } )$ . Best values are in bold, and values within the $9 5 \\%$ confidence interval $( \\pm )$ of the best are underlined. The numbers in the braces in the FID columns are FIDs of the pre-trained generators. Our VMI attack results in better accuracy and FID compared to baselines on all three tasks. "
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "If a good evaluation classifier only generalized to realistic inputs, then this metric would also penalize unrealistic attack samples. To some extent, this was the case in our experiments as evidenced by the extremely low accuracy assigned to the General MI attack baseline in Table 1. In Figure 5, the General MI attack samples were clearly unrealistic. To ensure a fair and informative evaluation, the evaluation classifier should be as accurate and generalizable as possible (details in Appendix B.3). ",
+        "bbox": [
+            174,
+            261,
+            825,
+            330
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Sample Realism: We used FID [Heusel et al., 2017] to directly measure the overall sample quality. To compute FID, we aggregated attack samples across classes and compared them to aggregated real images. Following standard practice, the feature extractor used for computing FID was the pretrained Inception network [Szegedy et al., 2015]. ",
+        "bbox": [
+            174,
+            337,
+            825,
+            392
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Sample Diversity: Though FID captures realism and overall diversity, it is known to neglect properties such as intra-class diversity, which is an important feature of a good MI attack. To overcome this limitation, we computed the improved precision & recall [Kynkäänniemi et al., 2019], coverage & density [Naeem et al., 2020] on a per class basis, capturing the intra-class diversity of the generated samples. The same Inception network was used as the feature extractor. Recall proposed in Kynkäänniemi et al. [2019] can be problematic when the generated samples contain outliers. Coverage proposed in Naeem et al. [2020] is less susceptible to outliers, but also less sensitive. For convenience of comparison, we take the average of the two quantities and call the resulting metric “diversity”. ",
+        "bbox": [
+            173,
+            397,
+            825,
+            522
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Generators. Two generator models were considered: DCGAN [Radford et al., 2015], and StyleGAN [Karras et al., 2019]. For StyleGAN, we used the original implementations.2 There were 10 and 12 layers in the synthesis networks for the $6 4 \\mathrm { x } 6 4$ CelebA data and 128x128 ChestX-ray data respectively. We do not use StyleGAN for the MNIST task since the images are simple. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            588
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            607,
+            263,
+            621
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparison with Baselines. Across all three tasks, our VMI formulations outperformed baselines in terms of target accuracy and sample realism (see Table 1), even when using the same generator architecture (DCGAN). Using a flow model for $q ( \\mathbf { z } )$ led to improvements in terms of accuracy. Using the formulation in Equation 5 and a StyleGAN further improved performance on all metrics. VMI also improved the overall sample qualities as evidenced by the lower FIDs. The full VMI (Equation 5) was able to improve FID over pre-trained generators on CelebA. In general, MI attack methods including VMI sacrificed sample quality to achieve higher accuracy, suggesting there is still room for improvements for methods that can retain full realism. Detailed evaluation using sample diversity metrics are reported in Table 2. In general, increasing $\\gamma$ increased diversity and realism while sacrificing accuracy. Our VMI attack outperformed the baseline on all metrics at multiple settings. The reported improvements in the quantitative metrics can be verified qualitatively in Figure 5. Detailed results for MNIST and ChestX-ray (Table 4, and 5) can be found in the Appendix C. Using StyleGAN with a Gaussian $q ( \\mathbf { z } )$ resulted in a slightly lower accuracy, but better diversity. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            813
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our reported results for our baseline [Zhang et al., 2020] are obtained using our own implementation since the reproduction code was not publicly available. The discrepancy with the original result can come from a number of factors: dataset split, target classifier checkpoint, and the hyperparameters involved in the method. We used the task setup described in this paper, and tuned the hyperparameters over a reasonable grid of values. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            887
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/c5ffe07dfee50c65f58a077439d23dda82903f11731394e686f7f51bbee81cc9.jpg",
+        "image_caption": [
+            "Figure 5: MI attack samples on the first ten identities of CelebA and MNIST. Each row corresponds to a different identity/digit. Qualitative differences are best viewed zoomed in. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            90,
+            800,
+            303
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/d30785c2d31be2481cbd2313cc0b4a59ad4af603caf86c7331ea02972a2e4086.jpg",
+        "table_caption": [
+            "Table 2: Detailed comparison between attack methods on CelebA. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td colspan=\"9\">VMI (ours)</td></tr><tr><td></td><td>Generative MI</td><td colspan=\"3\">DCGAN</td><td colspan=\"6\">StyleGAN</td></tr><tr><td></td><td>[Zhang et al., 2020]</td><td>q(z) = Gaussian =0</td><td>Flow le-3</td><td>le-1</td><td>0</td><td>Gaussian le-3</td><td>le-1</td><td>0</td><td>Flow 1e-3</td><td>le-1</td></tr><tr><td>Accuracy</td><td>0.07± 0.02</td><td>0.24± 0.05</td><td>0</td><td></td><td>0.57±0.06</td><td></td><td></td><td></td><td>0.55±0.06</td><td>0.39±0.07</td></tr><tr><td>Precision</td><td>0.51± 0.04</td><td>0.64±0.05</td><td>10.33± 0.09 0.37±0.07 0.13± 0.03 0.48±0.08 0.52±0.06</td><td>0.40±0.06</td><td>0.87±0.02</td><td>0.56±0.05 0.88±0.02</td><td>0.23±0.03 0.82±0.02</td><td>0.58± 0.06 0.87±0.03</td><td>0.87±0.03</td><td>0.89± 0.03</td></tr><tr><td>Density</td><td>0.41± 0.04</td><td>0.67± 0.08</td><td>0.49± 0.11</td><td>0.52± 0.08 0.38± 0.06</td><td>1.26± 0.07</td><td>1.28± 0.07</td><td>1.14± 0.06</td><td>1.22± 0.08</td><td>1.22± 0.08</td><td>1.31± 0.10</td></tr><tr><td></td><td></td><td>0.03± 0.01</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Recall Coverage</td><td>0.21± 0.04 0.83± 0.03</td><td>0.79±0.04</td><td>[0.00±0.00 0.01± 0.01 0.37±0.06 0.67± 0.06</td><td>0.13±0.03 0.70± 0.06</td><td>0.22± 0.03 0.98± 0.01</td><td>0.25± 0.03 0.98±0.01</td><td>0.42±0.03 0.98±0.01</td><td>|0.11 ± 0.02 0.96± 0.02</td><td>0.15± 0.03 0.97± 0.02</td><td>0.21±0.04 0.98±0.02</td></tr><tr><td>Diversity</td><td>0.52± 0.05</td><td>0.41± 0.04</td><td>0.19±0.06 0.34± 0.06</td><td>0.41± 0.07</td><td>0.60± 0.03</td><td>0.61± 0.03</td><td>0.70± 0.03</td><td>0.54± 0.02</td><td>0.56±0.04</td><td>0.59±0.05</td></tr><tr><td>FID</td><td>43.21</td><td>28.98</td><td>58.39 40.89</td><td>40.74</td><td>16.69</td><td>16.11</td><td>13.49</td><td>17.28</td><td>17.41</td><td>21.35</td></tr></table>",
+        "bbox": [
+            179,
+            352,
+            821,
+            476
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Attacking Different Target Classifiers. After establishing the effectiveness of our VMI attack on different datasets, we conducted experiments to test the effectiveness of our VMI attack against different target classifiers. We further tested two target classifier on CelebA: a VGG network [Simonyan and Zisserman, 2014] trained from scratch on our target dataset, and an adapted ArcFace classifier [Deng et al., 2019], which we denote as ArcFace-NC. The ArcFace is a specialized face identity recognizer pretrained on a large collection of datasets. We adapt it by using the pretrained network as a feature encoder,3 and adding a nearest cluster classifier in the feature space. This approach of adapting a powerful feature extractor is popular and effective in few-shot classification [Chen et al., 2019; Snell et al., 2017]. The resulting accuracy on held-out test examples in the target dataset were $6 2 . 1 \\%$ (VGG) and $9 6 . 1 \\%$ (ArcFace-NC). Results in Table 3 show that the same observations hold. ",
+        "bbox": [
+            173,
+            516,
+            826,
+            655
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Accuracy vs. Diversity Tradeoff. Figure 6 shows the accuracy vs. diversity tradeoff in VMI attacks on CelebA. The VMI attacks that used the StyleGAN generally achieved a better accuracy vs. diversity tradeoff than the ones used the DCGAN. We conjecture this is because of the better layer-wise disentanglement that the StyleGAN achieves. ",
+        "bbox": [
+            174,
+            671,
+            624,
+            741
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effect of Individual Layers. As motivated in Section 4.1, the extended latent space in Equation 5 allowed our attack to modify each layer which controlled different aspects of an image. Figure 7 shows values for the KL-divergence and entropy for $q _ { l } ( \\mathbf { z } )$ at all layers after VMI optimization in CelebA and ChestX-ray datasets. We can see a general downward trend in KL divergences and an upward trend in entropies of $q ( \\mathbf { z } )$ with respect to layers. This shows that in general the $q ( \\mathbf { z } )$ of the earlier layers were modified more by the optimization than the $q ( \\mathbf { z } )$ of the later layers. This is consistent with our observation in Figure 2 that the earlier layers have more control over features relevant to the identity of a face. ",
+        "bbox": [
+            174,
+            758,
+            625,
+            827
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/ca235ae6f3d57011a238b7ee7e6fda724f542ea618fa0e38b2d7479819facc65.jpg",
+        "image_caption": [
+            "Figure 6: Accuracy and diversity tradeoff on CelebA. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            647,
+            672,
+            807,
+            779
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            828,
+            820,
+            882
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/c37ca6d69639f793cdcff490a8e9009833bfe63aee307ac4a4e7cc2c26aad06e.jpg",
+        "table_caption": [
+            "Table 3: Detailed comparison on CelebA for two other target classifiers: VGG, and ArcFace-NC. $\\mathrm { F I D ^ { \\ast } }$ reported here was computed over 20 identities instead of 100, so the values can not be directly compared with those in Table 2. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\"></td><td colspan=\"5\">VGG</td><td colspan=\"5\">ArcFace-NC</td></tr><tr><td rowspan=\"2\">Generative MI</td><td colspan=\"4\">VMI (ours)</td><td rowspan=\"2\">Generative MI</td><td colspan=\"4\">VMI (ours)</td></tr><tr><td>DCGAN Gaussian</td><td>Flow</td><td>StyleGAN Gaussian</td><td>Flow</td><td>Gaussian</td><td>DCGAN Flow</td><td>StyleGAN Gaussian</td><td>Flow</td></tr><tr><td>Accuracy</td><td>[Zhang et al., 2020] 0.04±0.03</td><td>0.16± 0.09</td><td></td><td></td><td></td><td>[Zhang et al., 2020]</td><td></td><td></td><td></td><td></td></tr><tr><td>Precision</td><td>0.51± 0.09</td><td>0.60± 0.10</td><td>0.12±0.08 0.74±0.07</td><td>0.17±0.10 0.80±0.08</td><td>0.33±0.18 0.79± 0.11</td><td>0.21±0.08 0.59±0.09</td><td>0.63± 0.17 0.52±0.13</td><td>0.55±0.18</td><td>0.52± 0.13 0.86±0.04</td><td>0.90±0.07 0.84±0.07</td></tr><tr><td>Density</td><td>0.42± 0.1</td><td>0.63± 0.16</td><td>0.76±0.20</td><td>1.04± 0.19</td><td>1.02±0.24</td><td>0.46± 0.13</td><td>0.55±0.18</td><td>0.53± 0.14 0.64± 0.21</td><td>1.26± 0.21</td><td>1.26± 0.23</td></tr><tr><td></td><td>0.23±0.10</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Recall Coverage</td><td>0.79±0.13</td><td>0.09±0.04 0.75±0.13</td><td>0.02± 0.02 0.77±0.12</td><td>0.28±0.06 0.93±0.08</td><td>0.04±0.03 0.88±0.10</td><td>0.11± 0.04 0.81± 0.07</td><td>0.01± 0.01 0.69±0.11</td><td>0.00± 0.01 0.69±0.12</td><td>0.23±0.07 0.98± 0.03</td><td>0.04±0.03 0.96±0.05</td></tr><tr><td>Diversity</td><td>0.51± 0.16</td><td>0.42± 0.13</td><td>0.39± 0.12</td><td>0.61± 0.10</td><td>0.46±0.11</td><td>0.46±0.08</td><td>0.35± 0.12</td><td>0.35±0.12</td><td>0.60±0.08</td><td>0.50± 0.05</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>FID*</td><td>59.27</td><td>53.85</td><td>57.88</td><td>32.51</td><td>46.13</td><td>63.63</td><td>59.23</td><td>63.37</td><td>32.94</td><td>40.22</td></tr></table>",
+        "bbox": [
+            179,
+            89,
+            821,
+            217
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/436d2940ae60c41202b68f927d865b2647ae051ebe5529380563c2b25d828063.jpg",
+        "image_caption": [
+            "Figure 7: KL and entropy of $q _ { l } ( \\mathbf { z } )$ after VMI attack on CelebA and ChestX-ray at different layers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            271,
+            823,
+            391
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Limitation & Ethical Concerns ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            434,
+            464,
+            450
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "While our VMI attack was effective, it relied on the same assumption made in previous works: the attacker had access to a relevant auxiliary dataset [Yang et al., 2019b; Zhang et al., 2020]. A worthwhile future direction is to develop methods that do not depend on this assumption. Methodologically, our proposed VMI attack used a GAN to narrow down the search space of the variational objective, but GANs might not be equally effective for other data modalities such as text, and tabular data. Lastly, our study focused on the white-box setting where the attacker had full access to the model; extensions of the current VMI attack to the grey-box or black-box settings are also worthy of further investigation. ",
+        "bbox": [
+            173,
+            460,
+            826,
+            571
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focused on a method for improving model inversion attacks, which could have negative societal impacts if it falls into the wrong hands. As discussed in Section 1, malicious users can use attacks like this to break into secured systems and steal information from private data-centers. On the other hand, by pointing out the extent of the vulnerability of current models, we hope to facilitate research that builds better privacy-preserving algorithms, and raise awareness about privacy concerns. ",
+        "bbox": [
+            174,
+            577,
+            825,
+            660
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            683,
+            299,
+            700
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "An effective model inversion attack method must produce a set of samples that accurately captures the distinguishing features and variations of the underlying identity/class. Our proposed VMI attack optimizes a variational inference objective by using a combination of a StyleGAN generator and a deep flow model as its variational distribution. Our framework also provides insights into existing attack methods. Empirically, we found our VMI attacks were effective on three different tasks, and across different target classifiers. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            799
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            821,
+            553,
+            839
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgement. We would like to thank reviewers and ACs for constructive feedback and discussion. Resources used in preparing this research were provided, in part, by the Province of Ontario, the Government of Canada through CIFAR, and companies sponsoring the Vector Institute www.vectorinstitute.ai/#partners. ",
+        "bbox": [
+            176,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            267,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rameen Abdal, Yipeng Qin, and Peter Wonka. Image2stylegan: How to embed images into the stylegan latent space? In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 4432–4441, 2019. ",
+        "bbox": [
+            174,
+            112,
+            826,
+            150
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Amazon AWS. Amazon rekognition. URL https://aws.amazon.com/rekognition/. ",
+        "bbox": [
+            173,
+            159,
+            705,
+            174
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Bau, Jun-Yan Zhu, Hendrik Strobelt, Bolei Zhou, Joshua B Tenenbaum, William T Freeman, and Antonio Torralba. Gan dissection: Visualizing and understanding generative adversarial networks. arXiv preprint arXiv:1811.10597, 2018. ",
+        "bbox": [
+            173,
+            181,
+            823,
+            220
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pier Giovanni Bissiri, Chris C Holmes, and Stephen G Walker. A general framework for updating belief distributions. Journal of the Royal Statistical Society. Series B, Statistical methodology, 78(5):1103, 2016. ",
+        "bbox": [
+            174,
+            229,
+            823,
+            256
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David M Blei, Alp Kucukelbir, and Jon D McAuliffe. Variational inference: A review for statisticians. Journal of the American statistical Association, 112(518):859–877, 2017. ",
+        "bbox": [
+            171,
+            263,
+            823,
+            291
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Keith Bonawitz, Hubert Eichner, Wolfgang Grieskamp, Dzmitry Huba, Alex Ingerman, Vladimir Ivanov, Chloe Kiddon, Jakub Konecnˇ y, Stefano Mazzocchi, H Brendan McMahan, et al. Towards federated learning at \\` scale: System design. arXiv preprint arXiv:1902.01046, 2019. ",
+        "bbox": [
+            174,
+            299,
+            823,
+            338
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Si Chen, Ruoxi Jia, and Guo-Jun Qi. Improved techniques for model inversion attack. arXiv preprint arXiv:2010.04092, 2020. ",
+        "bbox": [
+            173,
+            345,
+            823,
+            372
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wei-Yu Chen, Yen-Cheng Liu, Zsolt Kira, Yu-Chiang Wang, and Jia-Bin Huang. A closer look at few-shot classification. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            173,
+            381,
+            823,
+            409
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gregory Cohen, Saeed Afshar, Jonathan Tapson, and Andre Van Schaik. Emnist: Extending mnist to handwritten letters. In 2017 International Joint Conference on Neural Networks (IJCNN), pages 2921–2926. IEEE, 2017. ",
+        "bbox": [
+            174,
+            416,
+            823,
+            443
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "International Warfarin Pharmacogenetics Consortium. Estimation of the warfarin dose with clinical and pharmacogenetic data. New England Journal of Medicine, 360(8):753–764, 2009. ",
+        "bbox": [
+            174,
+            450,
+            823,
+            477
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiankang Deng, Jia Guo, Niannan Xue, and Stefanos Zafeiriou. Arcface: Additive angular margin loss for deep face recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4690–4699, 2019. ",
+        "bbox": [
+            173,
+            486,
+            823,
+            525
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017. ",
+        "bbox": [
+            171,
+            534,
+            823,
+            559
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, David Krueger, and Yoshua Bengio. Nice: Non-linear independent components estimation. arXiv preprint arXiv:1410.8516, 2014. ",
+        "bbox": [
+            169,
+            568,
+            823,
+            594
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using real nvp. arXiv preprint arXiv:1605.08803, 2016. ",
+        "bbox": [
+            173,
+            603,
+            823,
+            630
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Simon S Du, Wei Hu, Sham M Kakade, Jason D Lee, and Qi Lei. Few-shot learning via learning the representation, provably. arXiv preprint arXiv:2002.09434, 2020. ",
+        "bbox": [
+            173,
+            637,
+            823,
+            665
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matt Fredrikson, Somesh Jha, and Thomas Ristenpart. Model inversion attacks that exploit confidence information and basic countermeasures. In Proceedings of the 22nd ACM SIGSAC Conference on Computer and Communications Security, pages 1322–1333, 2015. ",
+        "bbox": [
+            173,
+            672,
+            823,
+            712
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew Fredrikson, Eric Lantz, Somesh Jha, Simon Lin, David Page, and Thomas Ristenpart. Privacy in pharmacogenetics: An end-to-end case study of personalized warfarin dosing. In 23rd {USENIX} Security Symposium ({USENIX} Security 14), pages 17–32, 2014. ",
+        "bbox": [
+            173,
+            719,
+            823,
+            760
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Javier Galbally, Sébastien Marcel, and Julian Fierrez. Biometric antispoofing methods: A survey in face recognition. IEEE Access, 2:1530–1552, 2014. ",
+        "bbox": [
+            171,
+            767,
+            823,
+            794
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jonas Geiping, Hartmut Bauermeister, Hannah Dröge, and Michael Moeller. Inverting gradients–how easy is it to break privacy in federated learning? arXiv preprint arXiv:2003.14053, 2020. ",
+        "bbox": [
+            169,
+            803,
+            823,
+            829
+        ],
+        "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. Advances in neural information processing systems, 27:2672–2680, 2014. ",
+        "bbox": [
+            173,
+            837,
+            823,
+            876
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q Weinberger. On calibration of modern neural networks. arXiv preprint arXiv:1706.04599, 2017. ",
+        "bbox": [
+            173,
+            885,
+            825,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. arXiv preprint arXiv:1706.08500, 2017. ",
+        "bbox": [
+            171,
+            92,
+            823,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Seira Hidano, Takao Murakami, Shuichi Katsumata, Shinsaku Kiyomoto, and Goichiro Hanaoka. Model inversion attacks for prediction systems: Without knowledge of non-sensitive attributes. In 2017 15th Annual Conference on Privacy, Security and Trust (PST), pages 115–11509. IEEE, 2017. ",
+        "bbox": [
+            176,
+            127,
+            823,
+            167
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Briland Hitaj, Giuseppe Ateniese, and Fernando Perez-Cruz. Deep models under the gan: information leakage from collaborative deep learning. In Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security, pages 603–618, 2017. ",
+        "bbox": [
+            174,
+            176,
+            821,
+            215
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Corey D Holland and Oleg V Komogortsev. Complex eye movement pattern biometrics: Analyzing fixations and saccades. In 2013 International conference on biometrics (ICB), pages 1–8. IEEE, 2013. ",
+        "bbox": [
+            174,
+            224,
+            823,
+            251
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "CC Holmes and SG Walker. Assigning a value to a power likelihood in a general bayesian model. Biometrika, 104(2):497–503, 2017. ",
+        "bbox": [
+            176,
+            260,
+            823,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Michael I Jordan, Zoubin Ghahramani, Tommi S Jaakkola, and Lawrence K Saul. An introduction to variational methods for graphical models. Machine learning, 37(2):183–233, 1999. ",
+        "bbox": [
+            173,
+            296,
+            823,
+            323
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Georgios A Kaissis, Marcus R Makowski, Daniel Rückert, and Rickmer F Braren. Secure, privacy-preserving and federated machine learning in medical imaging. Nature Machine Intelligence, 2(6):305–311, 2020. ",
+        "bbox": [
+            173,
+            332,
+            825,
+            359
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4401–4410, 2019. ",
+        "bbox": [
+            173,
+            368,
+            823,
+            407
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tero Karras, Samuli Laine, Miika Aittala, Janne Hellsten, Jaakko Lehtinen, and Timo Aila. Analyzing and improving the image quality of stylegan. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8110–8119, 2020. ",
+        "bbox": [
+            174,
+            416,
+            823,
+            455
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mahdi Khosravy, Kazuaki Nakamura, Naoko Nitta, and Noboru Babaguchi. Deep face recognizer privacy attack: Model inversion initialization by a deep generative adversarial data space discriminator. In 2020 Asia-Pacific Signal and Information Processing Association Annual Summit and Conference (APSIPA ASC), pages 1400–1405. IEEE, 2020. ",
+        "bbox": [
+            174,
+            464,
+            826,
+            517
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013. ",
+        "bbox": [
+            171,
+            525,
+            823,
+            541
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Durk P Kingma and Prafulla Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. In Advances in Neural Information Processing Systems, pages 10215–10224, 2018. ",
+        "bbox": [
+            174,
+            549,
+            823,
+            577
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jeremias Knoblauch, Jack Jewson, and Theodoros Damoulas. Generalized variational inference: Three arguments for deriving new posteriors. arXiv preprint arXiv:1904.02063, 2019. ",
+        "bbox": [
+            176,
+            584,
+            823,
+            612
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tuomas Kynkäänniemi, Tero Karras, Samuli Laine, Jaakko Lehtinen, and Timo Aila. Improved precision and recall metric for assessing generative models. arXiv preprint arXiv:1904.06991, 2019. ",
+        "bbox": [
+            174,
+            621,
+            823,
+            648
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Corinna Cortes, and CJ Burges. Mnist handwritten digit database, 2010. ",
+        "bbox": [
+            174,
+            656,
+            683,
+            671
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Erich L Lehmann and Joseph P Romano. Testing statistical hypotheses. Springer Science & Business Media, 2006. ",
+        "bbox": [
+            174,
+            680,
+            823,
+            707
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In Proceedings of International Conference on Computer Vision (ICCV), December 2015. ",
+        "bbox": [
+            173,
+            715,
+            823,
+            743
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aravindh Mahendran and Andrea Vedaldi. Understanding deep image representations by inverting them. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 5188–5196, 2015. ",
+        "bbox": [
+            173,
+            752,
+            823,
+            779
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey W Miller and David B Dunson. Robust bayesian inference via coarsening. Journal of the American Statistical Association, 2018. ",
+        "bbox": [
+            173,
+            787,
+            823,
+            814
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Muhammad Ferjad Naeem, Seong Joon Oh, Youngjung Uh, Yunjey Choi, and Jaejun Yoo. Reliable fidelity and diversity metrics for generative models. In International Conference on Machine Learning, pages 7176–7185. PMLR, 2020. ",
+        "bbox": [
+            173,
+            823,
+            825,
+            863
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Milad Nasr, Reza Shokri, and Amir Houmansadr. Comprehensive privacy analysis of deep learning: Passive and active white-box inference attacks against centralized and federated learning. In 2019 IEEE symposium on security and privacy $( S P )$ , pages 739–753. IEEE, 2019. ",
+        "bbox": [
+            173,
+            872,
+            826,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Anh Nguyen, Jason Yosinski, and Jeff Clune. Deep neural networks are easily fooled: High confidence predictions for unrecognizable images. In Conference on Computer Vision and Pattern Recognition, pages 427–436, 2015. ",
+        "bbox": [
+            171,
+            92,
+            823,
+            131
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Anh Nguyen, Jeff Clune, Yoshua Bengio, Alexey Dosovitskiy, and Jason Yosinski. Plug & play generative networks: Conditional iterative generation of images in latent space. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4467–4477, 2017. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            179
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Omkar M Parkhi, Andrea Vedaldi, and Andrew Zisserman. Deep face recognition. 2015. ",
+        "bbox": [
+            173,
+            188,
+            699,
+            202
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015. ",
+        "bbox": [
+            173,
+            210,
+            823,
+            237
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Christian Rathgeb and Andreas Uhl. A survey on biometric cryptosystems and cancelable biometrics. EURASIP Journal on Information Security, 2011(1):1–25, 2011. ",
+        "bbox": [
+            169,
+            246,
+            823,
+            272
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Maria Rigaki and Sebastian Garcia. A survey of privacy attacks in machine learning. arXiv preprint arXiv:2007.07646, 2020. ",
+        "bbox": [
+            169,
+            280,
+            823,
+            308
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Thomas Schlegl, Philipp Seeböck, Sebastian M Waldstein, Ursula Schmidt-Erfurth, and Georg Langs. Unsupervised anomaly detection with generative adversarial networks to guide marker discovery. In International conference on information processing in medical imaging, pages 146–157. Springer, 2017. ",
+        "bbox": [
+            173,
+            315,
+            823,
+            356
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Elizabeth A Sconce, Tayyaba I Khan, Hilary A Wynne, Peter Avery, Louise Monkhouse, Barry P King, Peter Wood, Patrick Kesteven, Ann K Daly, and Farhad Kamali. The impact of cyp2c9 and vkorc1 genetic polymorphism and patient characteristics upon warfarin dose requirements: proposal for a new dosing regimen. Blood, 106(7):2329–2333, 2005. ",
+        "bbox": [
+            173,
+            363,
+            825,
+            415
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yujun Shen, Ceyuan Yang, Xiaoou Tang, and Bolei Zhou. Interfacegan: Interpreting the disentangled face representation learned by gans. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2020. ",
+        "bbox": [
+            174,
+            424,
+            823,
+            450
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Reza Shokri, Marco Stronati, Congzheng Song, and Vitaly Shmatikov. Membership inference attacks against machine learning models. In 2017 IEEE Symposium on Security and Privacy (SP), pages 3–18. IEEE, 2017. ",
+        "bbox": [
+            174,
+            458,
+            821,
+            487
+        ],
+        "page_idx": 12
+    },
+    {
+        "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,
+            494,
+            825,
+            521
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. arXiv preprint arXiv:1312.6034, 2013. ",
+        "bbox": [
+            171,
+            529,
+            823,
+            558
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Advances in Neural Information Processing Systems, pages 4077–4087, 2017. ",
+        "bbox": [
+            173,
+            565,
+            823,
+            592
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013. ",
+        "bbox": [
+            174,
+            599,
+            823,
+            627
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1–9, 2015. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            675
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Google TensorFlow. Tensorflow hub. URL https://www.tensorflow.org/hub. ",
+        "bbox": [
+            174,
+            683,
+            669,
+            698
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nilesh Tripuraneni, Michael I Jordan, and Chi Jin. On the theory of transfer learning: The importance of task diversity. arXiv preprint arXiv:2006.11650, 2020. ",
+        "bbox": [
+            173,
+            705,
+            823,
+            733
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Xiaosong Wang, Yifan Peng, Le Lu, Zhiyong Lu, Mohammadhadi Bagheri, and Ronald M Summers. Chestxray8: Hospital-scale chest x-ray database and benchmarks on weakly-supervised classification and localization of common thorax diseases. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2097–2106, 2017. ",
+        "bbox": [
+            174,
+            741,
+            825,
+            792
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yaxing Wang, Abel Gonzalez-Garcia, David Berga, Luis Herranz, Fahad Shahbaz Khan, and Joost van de Weijer. Minegan: effective knowledge transfer from gans to target domains with few images. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9332–9341, 2020. ",
+        "bbox": [
+            173,
+            801,
+            825,
+            842
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Qiang Yang, Yang Liu, Tianjian Chen, and Yongxin Tong. Federated machine learning: Concept and applications. ACM Transactions on Intelligent Systems and Technology (TIST), 10(2):1–19, 2019a. ",
+        "bbox": [
+            173,
+            849,
+            823,
+            876
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ziqi Yang, Ee-Chien Chang, and Zhenkai Liang. Adversarial neural network inversion via auxiliary knowledge alignment. arXiv preprint arXiv:1902.08552, 2019b. ",
+        "bbox": [
+            171,
+            885,
+            825,
+            911
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Raymond A Yeh, Chen Chen, Teck Yian Lim, Alexander G Schwing, Mark Hasegawa-Johnson, and Minh N Do. Semantic image inpainting with deep generative models. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 5485–5493, 2017. ",
+        "bbox": [
+            173,
+            92,
+            825,
+            131
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Hongxu Yin, Pavlo Molchanov, Jose M Alvarez, Zhizhong Li, Arun Mallya, Derek Hoiem, Niraj K Jha, and Jan Kautz. Dreaming to distill: Data-free knowledge transfer via deepinversion. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8715–8724, 2020. ",
+        "bbox": [
+            176,
+            140,
+            823,
+            179
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Yuheng Zhang, Ruoxi Jia, Hengzhi Pei, Wenxiao Wang, Bo Li, and Dawn Song. The secret revealer: generative model-inversion attacks against deep neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 253–261, 2020. ",
+        "bbox": [
+            174,
+            188,
+            823,
+            226
+        ],
+        "page_idx": 13
+    }
+]