Add files using upload-large-folder tool

parse/train/HJxJ2h4tPr/HJxJ2h4tPr.md

@@ -0,0 +1,375 @@
+# HIGHRES-NET: MULTI-FRAME SUPER-RESOLUTION BY RECURSIVE FUSION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Generative deep learning has sparked a new wave of Super-Resolution (SR) algorithms that enhance single images with impressive aesthetic results, albeit with imaginary details. Multi-frame Super-Resolution (MFSR) offers a more grounded approach to the ill-posed problem, by conditioning on multiple low-resolution views. This is important for satellite monitoring of human impact on the planet – from deforestation, to human rights violations – that depend on reliable imagery. To this end, we present HighRes-net, the first deep learning approach to MFSR that learns its sub-tasks in an end-to-end fashion: (i) co-registration, (ii) fusion, (iii) up-sampling, and (iv) registration-at-the-loss. Co-registration of low-res views is learned implicitly through a reference-frame channel, with no explicit registration mechanism. We learn a global fusion operator that is applied recursively on an arbitrary number of low-res pairs. We introduce a registered loss, by learning to align the SR output to a ground-truth through ShiftNet. We show that by learning deep representations of multiple views, we can super-resolve low-resolution signals and enhance Earth observation data at scale. Our approach recently topped the European Space Agency’s MFSR competition on real-world satellite imagery.
+
+# 1 INTRODUCTION
+
+Multiple low-resolution images collectively contain more information than any individual lowresolution image, due to minor geometric displacements, e.g. shifts, rotations, atmospheric turbulence, and instrument noise. Multi-Frame Super-Resolution (MFSR) (Tsai, 1984) aims to reconstruct hidden high-resolution details from multiple low-resolution views of the same scene. Single Image Super-Resolution (SISR), as a special case of MFSR, has attracted much attention in the computer vision, machine learning and deep learning communities in the last 5 years, with neural networks learning complex image priors to upsample and interpolate images (Xu et al., 2014; Srivastava et al., 2015; He et al., 2016). However, in the meantime not much work has explored the learning of representations for the more general problem of MFSR to address the additional challenges of co-registration and fusion of multiple low-resolution images.
+
+This paper explores how Multi-Frame Super-Resolution (MFSR) can benefit from recent advances in learning representations with neural networks. To the best of our knowledge, this work is the first to introduce a deep-learning approach that solves the co-registration, fusion and registration-at-theloss problems in an end-to-end learning framework.
+
+Prompting this line of research is the increasing drive towards planetary-scale Earth observation to monitor the environment and human rights violations. Such observation can be used to inform policy, achieve accountability and direct on-the-ground action, e.g. within the framework of the Sustainable Development Goals (Jensen & Campbell, 2019).
+
+Nomenclature Registration is the problem of estimating the relative geometric differences between two images (e.g. due to shifts, rotations, deformations). Fusion, in the MFSR context, is the problem of mapping multiple low-res representations into a single representation. By coregistration, we mean the problem of registering all low-resolution views to improve their fusion. By registration-at-the-loss, we mean the problem of registering the super-resolved reconstruction to the high-resolution ground-truth prior to computing the loss. This gives rise to the notion of a registered loss.
+
+Co-registration of multiple images is required for longitudinal studies of land change and environmental degradation. The fusion of multiple images is key to exploiting cheap, high-revisit-frequency satellite imagery, but of low-resolution, moving away from the analysis of infrequent and expensive high-resolution images. Finally, beyond fusion itself, super-resolved generation is required throughout the technical stack: both for labeling, but also for human oversight (Drexler, 2019) demanded by legal context (Harris et al., 2018).
+
+# Summary of contributions
+
+• HighRes-net: We propose a deep architecture that learns to fuse an arbitrary number of lowresolution frames with implicit co-registration through a reference-frame channel.   
+• ShiftNet: Inspired by HomographyNet (DeTone et al., 2016), we define a model that learns to register and align the super-resolved output of HighRes-net, using ground-truth high-resolution frames as supervision. This registration-at-the-loss mechanism enables more accurate feedback from the loss function into the fusion model, when comparing a super-resolved output to a ground truth high resolution image. Otherwise, a MFSR model would naturally yield blurry outputs to compensate for the lack of registration, to correct for sub-pixel shifts and account for misalignments in the loss.   
+• By combining the two components above, we contribute the first architecture to learn fusion and registration end-to-end.   
+• We test and compare our approach to several baselines on real-world imagery from the PROBA-V satellite of ESA. Our performance has topped the Kelvins competition on MFSR, organized by the Advanced Concepts Team of ESA (Martens et al. ¨ , 2019) (see section 5).
+
+![](images/57f84aa8ae2163a66792c1b839d4633dbbc9d02c4c6432e1c23677304399db54.jpg)  
+Figure 1: HighRes-net combines many low-resolution images (300 meters/pixel) into one image of superior resolution. The same site shot in high-resolution $( { 1 0 0 } \mathrm { { m } / { p i x } ) }$ is also shown for reference. Source of low-res and high-res: imgset1087 and imgset0285 of PROBA-V dataset, see section 5.
+
+The rest of the paper is divided as follows: in Section 2, we discuss related work on SISR and MFSR; Section 3 outlines HighRes-net and section 4 presents ShiftNet, a differentiable registration component that drives our registered loss mechanism during end-to-end training. We present our results in section 5, and in Section 6 we discuss some opportunities for and limitations and risks of super-resolution.
+
+# 2 BACKGROUND
+
+# 2.1 MULTI-FRAME SUPER-RESOLUTION
+
+How much detail can we resolve in the digital sample of some natural phenomenon? Nyquist (1928) observed that it depends on the instrument’s sampling rate and the oscillation frequency of the underlying natural signal. Shannon (1949) built a sampling theory that explained Nyquist’s observations when the sampling rate is constant (uniform sampling) and determined the conditions of aliasing in a sample. Figure 2 illustrates this phenomenon.
+
+![](images/19931371c44718352413422be81c54ee05750a8e418aac479f81249e3b2d120f.jpg)  
+high-resolutioDFT magnitude F fHR Figure 2: Top: A chirp harmonic oscillator $\sin \left( 2 \pi \omega ( t ) t \right)$ equency 1 kHz DFT magnitudeF fLR , with instantaneous frequency $\omega ( t )$ . Left: The shape of the high-resolution sample resembles the underlying chirp signal. Right: Close to $t = 1$ , the apparent −400 −200 0 200 400 frequency (Hz) −100 −50 0 50 100 frequency (Hz)frequency of the low-resolution sample does not match that of the chirp. This is an example of aliasing (shown 0.0 0.2 0.4 0.6 0.8 1.0 t (sec)   with red at its most extreme), and it happens when the sampling rate falls below the Nyquist rate, $s _ { N } = 2 \cdot s _ { B }$ , where $s _ { B }$ is the highest non-zero frequency of the signal.
+
+− −   frequency (Hz) Sampling at high-resolution (left) maintains the frequency of the chirp signal (top). Sampling at a lower resolution (right), this apparent chirped frequency is lost due to aliasing, which means that the lower-resolution sample has a fundamentally smaller capacity for resolving the information of the natural signal, and a higher sampling rate can resolve more information.
+
+Shannon’s sampling theory has since been generalized for multiple interleaved sampling frames (Papoulis, 1977; Marks, 2012). One result of the generalized sampling theory is that we can go beyond the Nyquist limit of any individual uniform sample by interleaving several uniform samples taken concurrently. When an image is down-sampled to a lower resolution, its high-frequency details are lost permanently and cannot be recovered from any image in isolation. However, by combining multiple low-resolution images, it becomes possible to recover the original scene at a higher resolution.
+
+Moreover, different low-resolution samples may be sampled at different phases, such that the same high-resolution frequency information will be packed with a phase shift. As a consequence, when multiple low-resolution samples are available, the fundamental challenge of MFSR is de-aliasing, i.e. disentangling the high-frequency components (Tsai, 1984).
+
+The first work on MSFR (Tsai, 1984) considered the reconstruction of a high-resolution image as a fusion of co-registered low-resolution images in the Fourier domain. With proper registration and fusion (Irani & Peleg, 1991; Fitzpatrick et al., 2000; Capel & Zisserman, 2001), a composite super-resolved image can reveal some of the original high-frequency detail that would not have been accessible from single low-resolution image. In this work, we introduce HighRes-Net, which aims to provide an end-to-end deep learning framework for MFSR settings.
+
+Relation to Video and Stereo Super-Resolution While there are obvious similarities to Video SR (Tao et al., 2017; Sajjadi et al., 2018; Yan et al., 2019; Wang et al., 2019b) and Stereo SR (Wang et al., 2019d) (Wang et al., 2019a), the setting of this work differs in several ways: HighResnet learns to super-resolve sets and not sequences of low-res views. Video SR relies on motion estimation from a sequence of observations. Also, prediction at time $t = T$ relies on predictions at $t < T$ (autoregressive approach). Whereas in our case, we predict a single image from an unordered set of low-res inputs. Also, the low-res views are multi-temporal (taken at different times).
+
+Video SR methods assume that the input is a temporal sequence of frames. Motion or optical flow can be estimated to super-resolve the sequences of frames. In this work, we do not assume low-res inputs to be ordered in time. Our training input is a set of low-res views with unknown timestamps and our target output is a single image — not another sequence.
+
+# 2.2 A PROBABILISTIC APPROACH
+
+In addition to aliasing, MFSR deals with random processes like noise, blur, geometric distortions – all contributing to random low-resolution images. Traditionally, MFSR methods assume a-priori knowledge of the data generating motion model, blur kernel, noise level and degradation process; see for example, Pickup et al. (2006). Given multiple low-resolution images, the challenge of MFSR is to reconstruct a plausible image of higher-resolution that could have generated the observed lowresolution images. Optimization methods aim to improve an initial guess by minimizing an error between simulated and observed low-resolution images. These methods traditionally model the additive noise $\epsilon$ and prior knowledge about natural images explicitly, to constrain the parameter search space and derive objective functions, using e.g. Total Variation (Chan & Wong, 1998; Farsiu et al., 2004), Tikhonov regularization (Nguyen et al., 2001) or Huber potential (Pickup et al., 2006) to define appropriate constraints on images.
+
+![](images/60f3e8ff55b1438a0126fff317ac8933a2245b72bfd38df5a060692c6d6872ef.jpg)  
+Figure 3: Schematic of the full processing pipeline, trained end-to-end. At test time, only HighRes-net is used. (a) HighRes-net: In the Encode stage, an arbitrary number of LR views are paired with the reference low-res image (the median low-res in this work). Each LR view–reference pair is encoded into a view-specific latent representation. The LR encodings are fused recursively into a single global encoding. In the Decode stage, the global representation is upsampled by a certain zoom factor $\times 3$ in this work). Finally, the superresolved image is reconstructed by combining all channels of the upsampled global encoding. (b) Registered loss: Generally, the reconstructed SR will be shifted with respect to the ground-truth HR. ShiftNet learns to estimate the $( \Delta x , \Delta y )$ shift that improves the loss. Lanczos resampling: $( \Delta x , \Delta y )$ define two 1D shifting Lanczos kernels that translate the SR by a separable convolution.
+
+In some situations, the image degradation process is complex or not available, motivating the development of nonparametric strategies. Patch-based methods learn to form high-resolution images directly from low-resolution patches, e.g. with $\mathbf { k }$ -nearest neighbor search (Freeman et al., 2002; Chang et al., 2004), sparse coding and sparse dictionary methods (Yang et al., 2010; Zeyde et al., 2010; Kim & Kwon, 2010)). The latter represents images in an over-complete basis and allows for sharing a prior across multiple sites.
+
+In this work, we are particularly interested in super-resolving satellite imagery. Much of the recent work in Super-Resolution has focused on SISR for natural images. For instance, Dong et al. (2014) showed that training a CNN for super-resolution is equivalent to sparse coding and dictionary based approaches. Kim et al. (2016) proposed an approach to SISR using recursion to increase the receptive field of a model while maintaining capacity by sharing weights. Many more networks and learning strategies have recently been introduced for SISR and image deblurring. Benchmarks for SISR (Timofte et al., 2018), differ mainly in their upscaling method, network design, learning strategies, etc. We refer the reader to (Wang et al., 2019d) for a more comprehensive review.
+
+Few deep-learning approaches have considered the more general MFSR setting and attempted to address it in an end-to-end learning framework. Reecently, Kawulok et al. (2019) proposed a shiftand-add method and suggested “including image registration” in the learning process as future work.
+
+In the following sections, we describe our approach to solving both aspects of the registration problem – co-registration and registration-at-the-loss – in a memory-efficient manner.
+
+# 3 HIGHRES-NET: MFSR BY RECURSIVE FUSION
+
+In this section, we present HighRes-net, a neural network for multi-frame super-resolution inside a single spectral band (greyscale images), using joint co-registration and fusion of multiple lowresolution views in an end-to-end learning framework. From a high-level, HighRes-net consists of an encoder-decoder architecture and can be trained by stochastic gradient descent using highresolution ground truth as supervision, as shown in Figure 3.
+
+Notation We denote by $\theta$ the parameters of HighRes-net trained for a given upscaling factor $\gamma$ . $L R _ { v , i } \ \in \ \mathbb { R } ^ { C \times W \times H }$ is one of a set of $K$ low-resolution views from the same site $v$ , where $C$ , $W$ and $H$ are the number of input channels, width and height of $L R _ { v , i }$ , respectively. We denote by $S R _ { v } ^ { \theta } = F _ { \theta } ^ { \gamma } \left( L R _ { v , 1 } . \right.$ , . . . , $L R _ { v , K } )$ , the output of HighRes-net and by $H R _ { v } \in \mathbb R ^ { C \times \gamma W \times \gamma H }$ a ground truth high-resolution image. We denote by $[ T _ { 1 } , T _ { 2 } ]$ the concatenation of two images channelwise. In the following we supress the index $v$ over sites for clarity.
+
+HighRes-Net consists of three main steps: (1) encoding, which learns relevant features associated with each low-resolution view, (2) fusion, which merges relevant information from views within the same scene, and (3) decoding, which proposes a high-resolution reconstruction from the fused summary.
+
+# 3.1 ENCODE, FUSE, DECODE
+
+Embed, Encode The core assumption of MFSR is that the low-resolution image set contains collectively more information than any single low-resolution image alone, due to differences in photometric or spatial coverage for instance. However, the redundant low frequency information in multiple views can hinder the training and test performance of a MFSR model. We thus compute a reference image ref as a shared representation for multiple low-resolution views $\left( L R _ { i } \right) _ { i = 1 } ^ { K }$ and embed each image jointly with ref. This highlights differences across the multiple views (Sanchez et al., 2019), and potentially allows HighRes-net to focus on difficult high-frequency features such as crop boundaries and rivers during super-resolution. The shared representation or reference image intuitively serves as an anchor for implicitly aligning and denoising multiple views in deeper layers. We refer to this mechanism as implicit $c o$ -registration.
+
+HighRes-net’s embedding layer $\operatorname { e m b } _ { \theta }$ consists of a convolutional layer and two residual blocks with PReLu activations (He et al., 2015) and is shared across all views. The embedded hidden states $s _ { i } ^ { 0 }$ are computed in parallel as follows:
+
+$$
+\begin{array} { r l } & { r e f ( c , i , j ) = \operatorname * { m e d i a n } \left( L R _ { 1 } ( c , i , j ) , \mathrm { ~ } \ldots , \mathrm { ~ } L R _ { K } ( c , i , j ) \right) , \mathrm { s u c h ~ t h a t } r e f \in \mathbb { R } ^ { C \times W \times H } } \\ & { \qquad \quad s _ { i } ^ { 0 } = \operatorname { e m b } _ { \theta } \left( \left[ L R _ { i } , \mathrm { ~ } r e f \right] \right) \in \mathbb { R } ^ { C _ { h } \times W \times H } , } \end{array}
+$$
+
+where $C _ { h }$ denotes the channels of the hidden state.
+
+The imageset is padded if the number of low-res views $K ^ { \prime }$ is not a power of 2: we pad the set with dummy zero-valued views, such that the new size of the imageset $K$ is the next power of 2. See Algorithm 1, line 1.
+
+Fuse The embedded hidden states $s _ { i } ^ { 0 }$ are then fused recursively, halving by two the number of low-resolution states at each fusion step $t$ , as shown in Figure 4. Given a pair of hidden states $s _ { i } ^ { t } , s _ { j } ^ { t }$ HighRes-net computes a new representation:
+
+$$
+\begin{array} { r l } & { \left[ { \tilde { s } } _ { i } ^ { t } , \ { \tilde { s } } _ { j } ^ { t } \right] = \left[ s _ { i } ^ { t } , \ s _ { j } ^ { t } \right] + g _ { \theta } \left( \left[ s _ { i } ^ { t } , \ s _ { j } ^ { t } \right] \right) \in \mathbb { R } ^ { 2 C _ { h } \times W \times H } } \\ & { \quad \quad s _ { i } ^ { t + 1 } = s _ { i } ^ { t } + \alpha _ { j } f _ { \theta } \left( \tilde { s } _ { i } ^ { t } , \ { \tilde { s } } _ { j } ^ { t } \right) \in \mathbb { R } ^ { C _ { h } \times W \times H } , } \end{array}
+$$
+
+where $\tilde { s } _ { i } ^ { t } , ~ \tilde { s } _ { j } ^ { t }$ are intermediate representations; $g _ { \theta }$ is a shared-representation within an inner residual block (equation 3); $f _ { \theta }$ is a fusion block, and $\alpha _ { j }$ is 0 if the $j$ -th low-resolution view is part of the padding, and 1 otherwise. $f _ { \theta }$ squashes $2 C _ { h }$ input channels into $C _ { h }$ channels and consists of a $( \mathrm { c o n v } 2 \mathrm { d } \mathrm { + } \mathrm { P r e L u } )$ . Intuitively, gθ aligns the two representations and it consists of two $\mathrm { \ c o n v { 2 d } + }$ PreLU) layers.
+
+The blocks $\left( f _ { \theta } , g _ { \theta } \right)$ are shared across all pairs and depths, giving it the flexibility to deal with variable size inputs and significantly reduce the number of parameters to learn.
+
+Upscale and Decode After $T = \log _ { 2 } K$ fusion layers, the final low-resolution encoded state $s _ { i } ^ { T }$ contains information from all $K$ input views. Any information of a spatial location that was initially missing from $L R _ { i }$ , is now encoded implicitly in $s _ { i } ^ { T }$ . $T$ is called the depth of HighRes-net. Only then, $s _ { i } ^ { T }$ is upsampled with a deconvolutional layer ( $\mathrm { { X u } }$ et al., 2014) to a higher-resolution space $s _ { H R } ^ { T } \in \dot { \mathbb { R } } ^ { C _ { h } \times \gamma W \times \gamma H }$ . The hidden high-resolution encoded state $s _ { H R } ^ { T }$ is eventually convolved with a $1 \times 1$ 2D kernel to produce a final super-resolved image $S R ^ { \theta } \in \bar { \mathbb { R } ^ { C \times \gamma W \times \gamma H } }$ .
+
+![](images/2da5cd799cda4ada5a8f1231723d647c1af6bd186e40b14a471878e403e09943.jpg)  
+Figure 4: HighRes-net’s global fusion operator consists of a co-registration $g _ { \theta }$ and a fusion $f _ { \theta }$ block which aligns and combines two representations into a single representation.
+
+The overall architecture of HighRes-net is summarized in Figure 3(a) and the pseudocode for the forward pass is given in Algorithm 1.
+
+# Algorithm 1: HighRes-net forward pass
+
+<table><tr><td>Input: low-res views LR1 ...LRk&#x27;</td></tr><tr><td>1 (LR1...LRK,α1...αk)← pad(LR1...LRκ&#x27;) // pad inputs to next power of 2</td></tr><tr><td>2 s ← encode(LRi) // parallelized across 1...K</td></tr><tr><td></td></tr><tr><td>3 T←log2K // fusion depth 4k←K</td></tr><tr><td>5 fort = 1...Tdo</td></tr><tr><td>6 fori = 1...k/2do t-1</td></tr><tr><td>st← fuse s-i， 7 Qk-i) // fuse encoded views 8 k=k/2</td></tr><tr><td>9 SR ← decode(sT)</td></tr><tr><td>Output: super-resolved view SR</td></tr></table>
+
+# 4 REGISTRATION MATTERS
+
+Co-registration matters for fusion. HighRes-net learns to implicity co-register multiple lowresolution views $L R _ { i }$ and fuse them into a single super resolved image $S R _ { \theta }$ .
+
+A more explicit registration-at-the-loss can also be used for measuring similarity metrics and distances between $S R _ { \theta }$ and $H R$ . Indeed, training HighRes-Net alone, by minimizing a reconstruction error such as the mean-squared error between $S R _ { \theta }$ and $H R$ , leads to blurry outputs, since the neural network has to compensate for pixel and sub-pixel misalignments between its output $S R _ { \theta }$ and $H R$ .
+
+Here, we present ShiftNet-Lanczos, a neural network that can be paired with HighRes-net to account for pixel and sub-pixel shifts in the loss, as depicted in Figure 3(b). Our ablation study A.2 and qualitative visual analysis suggest that this strategy helps HighRes-net learn to super-resolve and leads to clearly improved results.
+
+# 4.1 SHIFTNET-LANCZOS
+
+ShiftNet learns to align a pair of images with sub-pixel translations. ShiftNet registers pairs of images by predicting two parameters defining a global translation. Once a sub-pixel translation is found for a given pair of images, it is applied through a Lanczos shift kernel to align the images.
+
+ShiftNet The architecture of ShiftNet is adapted from HomographyNet (DeTone et al., 2016). Translations are a special case of homographies. In this sense, ShiftNet is simply a special case of HomographyNet, predicting 2 shift parameters instead of 8 homography parameters. See Appendix A.3, for details on the architecture of ShiftNet.
+
+Algorithm 2: Sub-pixel registered loss through ShiftNet-Lanczos   
+
+<table><tr><td>Input: SRθ, HR</td><td>// super-resolved view, high-resolution ground-truth</td></tr><tr><td>1 (△x,△y)← ShiftNet (SRe,HR)</td><td>// register SR to HR</td></tr><tr><td>2 κ△ ← LanczosShiftKernel(△)</td><td>// 1D Lanczos kernels for x and y sub-pixel shifts</td></tr><tr><td>3 SRθ,△ ← SRθ * K△x * K△y</td><td>// 2D sub-pixel shift by separable 1D convolutions</td></tr><tr><td></td><td>// sub-pixel registered loss</td></tr><tr><td>4 lθ,△ ← loss(SRθ,△,HR) Output: lθ,△</td><td></td></tr></table>
+
+One major difference from HomographyNet is the way we train ShiftNet: In (DeTone et al., 2016), HomographyNet is trained on synthetically transformed data, supervised with ground-truth homography matrices. In our setting, ShiftNet is trained to cooperate with HighRes-net, towards the common goal of MFSR (see section Objective function below).
+
+Lanczos shift & interpolation kernel To shift and align an image by a sub-pixel amount, it must be convolved with a filter that shifts for the integer parts and interpolates for the fractional parts of the translation. Standard options for interpolation include the nearest-neighbor, sinc, bilinear, bicubic, and Lanczos filters (Turkowski, 1990). The sinc filter has an infinite support as opposed to any digital signal, so in practice it produces ringing or ripple artifacts — an example of the Gibbs phenomenon. The nearest-neighbor and bilinear filters do not induce ringing, but strongly attenuate the higher-frequency components (over-smoothing), and can even alias the image. The Lanczos filter reduces the ringing significantly by using only a finite part of the since (up to a few lobes from the origin). Experimentally, we found the Lanczos filter to perform the best.
+
+Objective function In our setting, registration benefits super-resolution. HighRes-net receives more informative gradient signals when its output is aligned with the ground truth high-resolution image. Conversely, super-resolution benefits registration, since good features are key to align images (Clement et al., 2018). We thus trained HighRes-Net and ShiftNet-Lanczos in a cooperative setting, where both neural networks work together to minimize an objective function, as opposed to an adversarial setting where a generator tries to fool a discriminator. HighRes-net infers a latent superresolved variable and ShiftNet maximises its similarity to a ground truth high-resolution image with sub-pixel shifts.
+
+By predicting and applying sub-pixel translations in a differentiable way, our approach for registration and super-resolution can be combined in an end-to-end learning framework. Shift-Net predicts a sub-pixel shift $\Delta$ from a pair of high-resolution images. The predicted transformation is applied with Lanczos interpolation to align the two images at a pixel level. ShiftNet and HighRes-Net are trained jointly to minimize a common loss function, using backpropagation and stochastic gradient descent. Our objective function is composed of a registered reconstruction loss computed as in Algorithm 2. In our case, we used the corrected clear PSNR metric (cPSNR), chosen by ESA, which is a variant of the mean squared error, designed to correct for brightness and clouds in satellite images (Martens et al. ¨ , 2019), but the proposed architecture is decoupled from the choice of loss.
+
+See Algorithm 4 for the pseudo-code for computing the alignment loss $\ell _ { \theta , \Delta }$ . We further regularize the L2 norm of ShiftNet’s ouput with a hyperparameter $\lambda$ and our final joint objective is given by:
+
+$$
+L _ { \theta , \Delta } ( S R _ { \theta } , H R ) = \ell _ { \theta , \Delta } + \lambda | | \Delta | | _ { 2 } .
+$$
+
+# 5 EXPERIMENTS AND RESULTS
+
+Prior SR work has focused on super-resolving low-res images that are artificially generated by simple bilinear down-sampling, (Bulat et al., 2018) The PROBA-V satellite has separate cameras onboard for capturing high-res / low-res pairs. As far as we know, the PROBA-V dataset is the first publicly available dataset for MFSR that contains naturally occurring low-res and high-res pairs. This is in contrast to most of the work in SR (SISR, MFSR, Video SR, Stereo SR) that synthetically down-sample high-res images and frames (Wang et al., 2019c; Nah et al., 2019). Methods that are trained on artificially downscaled datasets fail to produce good results when applied to real-world low-resolution, low quality images (Shocher et al., 2018). For this reason, we experiment only on PROBA-V, a dataset that does not suffer from biases induced by artificial down-sampling.
+
+# 5.1 PROBA-V KELVIN DATASET
+
+The performance of our method is illustrated with satellite imagery from the Kelvin competition, organized by ESA’s Advanced Concept Team (ACT).
+
+The Proba-V Kelvin dataset (Martens et al. ¨ , 2019) contains 1450 scenes (RED and NIR spectral bands) from 74 hand-selected Earth regions around the globe at different points in time. The scenes are split into 1160 scenes for training and 290 scenes for testing. Each data-point consists of exactly one $1 0 0 \mathrm { m }$ resolution image as $3 8 4 \times 3 8 4$ grey-scale pixel images (HR) and several $3 0 0 \mathrm { m }$ resolution images from the same scene as $1 2 8 \times 1 2 8$ grey-scale pixel images (LR), spaced days apart. We refer the reader to the Proba-V manual (Wolters et al., 2014) for further details on image acquisition.
+
+Each scene comes with at least 9 low-res views, and an average of 19. Each view comes with a noisy quality map. The quality map is a binary map, that indicates concealed pixels due to volatile features, such as clouds, cloud shadows, ice, water and snow. The sum of clear pixels (1s in the binary mask) is defined as the clearance of a low-res view. These incidental and noisy features can change fundamental aspects of the image, such as the contrast, brightness, illumination and landscape features. We use the clearance scores to randomly sample from the imageset of low-res views, such that views with higher clearance are more likely to be selected. This strategy helps to prevent overfitting. See Appendix A.4 for more details.
+
+Working with missing or noisy values A quality map can be used as a binary mask to indicate noisy or occluded pixels, due to clouds, snow, or other volatile objects. Such a mask can be fed as an additional input channel in the respective low-res view, in the same fashion as thereference frame. When missing value masks are available, neural networks can learn which parts of the input are anomalous, noisy, or missing, when provided with such binary masks (see e.g. Che et al. (2018)). In satellite applications where clouds masks are not available, other segmentation methods would be in order to infer such masks as a preprocessing step (e.g. Long et al. (2015)). In the case of the PROBA-V dataset, we get improved results when we make no use of the masks provided. Instead we use the masks only to inform the sampling scheme within the low-res imageset to prevent overfitting.
+
+# 5.2 EXPERIMENTS
+
+Across all experiments, we used the same hyperparameters, reported in Appendix A.1. By default, each imageset is padded to 32 views for training and testing, unless specified otherwise. Our pytorch implementation requires less than 9h of training on a single NVIDIA V100 GPU. At test time, superresolving an imageset of size $1 2 8 \mathrm { x } 1 2 8$ by a factor of 3, takes less than 0.2 seconds. Our code is made available on github1.
+
+We evaluated different models on ESA’s Kelvin competition. Our best model, HighRes-Net trained jointly with shiftNet-Lanczos, scored consistently at the top of the public and final leaderboard, see Table 1. In the following, we discuss several baselines and report our experiments.
+
+# 5.3 COMPARISONS
+
+• ESA baseline upsamples each low-resolution view separately with bicubic up-sampling and averages those of maximum clearance.   
+• SRResNet (Ledig et al., 2017) is a deep learning SISR baseline.   
+SRResNet- $1 +$ shiftNet was trained with ShiftNet.   
+• SRResNet- $^ { 6 + }$ shiftNet differs from the previous model during test time only. It independently upsamples 6 low-resolution views with SRResNet-1, co-registers the super-resolved images using shiftNet, and averages the 6 aligned super-resolved images into a final prediction.   
+ACT baseline (Martens et al. ¨ , 2019) is a Convolutional Neural Network with five fixed channels for the five clearest low-resolution views.   
+DeepSUM baseline (Molini et al., 2019) can be seen as a variant of SRResNet- $\cdot 6 +$ shiftNet. Multiple low-res views are independently upsampled, then co-registered and fused into a single image.   
+• HighRes-net $^ +$ shiftNet are described in sections 3 and 4. Upsampling is done in the last step as opposed to (Molini et al., 2019).   
+• Ensemble An ensemble of two trained (HighRes-net $^ +$ shiftNet) models, one with ${ \mathrm { K } } { = } 1 6$ and one with ${ \mathrm { K } } { = } 3 2$ input views, whose outputs are averaged.
+
+# 5.4 ESA KELVIN LEADERBOARD
+
+The Kelvin competition used the corrected clear PSNR (cPSNR) quality metric as the standardized measure of performance. The cPSNR is a variant of the Peak Signal to Noise Ratio (PSNR) used to compensate for pixel-shifts and brightness bias. We refer the reader to (Martens et al. ¨ , 2019) for the motivation and derivation of this quality metric. The cPSNR metric is normalized by the score of the ESA baseline algorithm so that a score smaller than 1 means “better than the baseline” and lower is better. We also use it as our training objective with sub-pixel registration (see also section 3(b) on ShiftNet).
+
+Table 1: Public and final leaderboard scores for the ESA’s Kelvin competition. Lower score means a better reconstruction.   
+
+<table><tr><td>Method</td><td>Public score</td><td>Final score</td></tr><tr><td>SRResNet (Ledig et al., 2017)</td><td>1.0095</td><td>1.0084</td></tr><tr><td>ESA baseline</td><td>1.0000</td><td>1.0000</td></tr><tr><td>SRResNet-1+ shiftNet</td><td>1.0002</td><td>0.9995</td></tr><tr><td>ACT baseline (Märtens et al., 2019)</td><td>0.9874</td><td>0.9879</td></tr><tr><td>SRResNet-6+ shiftNet</td><td>0.9808</td><td>0.9794</td></tr><tr><td>HighRes-net + shiftNet (ours)</td><td>0.9496</td><td>0.9488</td></tr><tr><td>HighRes-net+ shiftNet Ensemble (ours)</td><td>0.94738</td><td>0.94774</td></tr><tr><td>DeepSUM (Molini et al., 2019)</td><td>0.94884</td><td>0.94744</td></tr></table>
+
+# 5.4.1 ABLATION STUDY
+
+We further ran an ablation study on the available labeled data (1450 image sets), split in $9 0 \% / \ 1 0 \%$ for training and testing. Our results suggest that more low-resolution views benefit the reconstruction error, plateuing after 16 views, see Appendix A.2. Another finding is that registration matters for MFSR, both in co-registering low-res views, and registering-at-the-loss, see Appendix A.3. Finally, selecting the $k$ clearest views for fusion can lead to ovefitting. One remedy is to randomly sample the views with a bias for clearance, see A.4.
+
+# 6 DISCUSSION
+
+# 6.1 THE IMPORTANCE OF GROUNDED DETAILS
+
+The PROBA-V satellite (Dierckx et al., 2014) was launched by ESA to monitor Earth’s vegetation growth, water resources and agriculture. As a form of data fusion and enrichment, multi-frame super-resolution could enhance the vision of such satellites for scientific and monitoring applications (Carlson & Ripley, 1997; Pettorelli et al., 2005). More broadly, satellite imagery can help NGOs and non-profits monitor the environment and human rights (Cornebise et al., 2018; Helber et al., 2018; Rudner et al., 2019; Rolnick et al., 2019) at scale, from space, ultimately contributing to the UN sustainable development goals. Low-resolution imagery is cheap or sometimes free, and it is frequently updated. However, with the addition of fake or imaginary details, such enhancement wouldn’t be valuable as scientific, legal, or forensic evidence.
+
+# 6.2 FUTURE WORK
+
+Registration matters at the loss stage but also at the fusion stage. The latter is not explicit in our model and the reason why and how it works is less understood. Learning to sample a reference frame and learning to fuse multiple representations with attention could also be a promising approach to extend HighRes-net.
+
+Ensuring authenticity of detail is a major challenge and quantifying uncertainty of super-resolved images is an important line of future work for real world applications. Along this line of research, the question of how to evaluate a super-resolved image is important for downstream tasks and, more generally, similarity metrics remain an open question for many computer visions tasks (Bruna et al., 2015; Johnson et al., 2016; Isola et al., 2017; Ledig et al., 2017).
+
+# 6.3 CONCLUSION
+
+In this paper, we presented HighRes-net – the first deep learning approach to multi-frame superresolution that learns typical sub-tasks of MFSR in an end-to-end fashion: (i) co-registration, (ii) fusion, (iii) up-sampling, and (iv) registration-at-the-loss.
+
+It recursively fuses a variable number of low-resolution views by learning a global fusion operator. The overall fusion also aligns all low-resolution views with an implicit co-registration mechanism through the reference channel. We also introduced ShiftNet-Lanczos, a network that learns to register and align the super-resolved output of HighRes-net with a high-resolution ground-truth.
+
+Registration is important both to align multiple low-resolution inputs (co-registration) and to compute similarity metrics between shifted signals. Our experiments suggest that an end-to-end cooperative setting (HighRes-net $^ +$ ShiftNet-Lanczos) helps with training and test performance. By design, our approach is fast to train, faster to test, and low in terms of memory-footprint by doing the bulk of the computational work (co-registration $^ +$ fusion) on multiple images while maintaining their low-resolution height & width.
+
+There is an ongoing proliferation of low-resolution yet high-revisit low-cost satellite imagery, but they often lack the detailed information of expensive high-resolution imagery. We believe MFSR can raise its potential to NGOs and non-profits that contribute to the UN Sunstainable Development Goals.
+
+# REFERENCES
+
+Joan Bruna, Pablo Sprechmann, and Yann LeCun. Super-resolution with deep convolutional sufficient statistics. arXiv preprint arXiv:1511.05666, 2015.
+
+Adrian Bulat, Jing Yang, and Georgios Tzimiropoulos. To learn image super-resolution, use a gan to learn how to do image degradation first. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 185–200, 2018.
+
+David Capel and Andrew Zisserman. Super-resolution from multiple views using learnt image models. In Proceedings of the 2001 IEEE Computer Society Conference on Computer Vision and Pattern Recognition. CVPR 2001, volume 2, pp. II–II. IEEE, 2001.
+
+Toby N Carlson and David A Ripley. On the relation between ndvi, fractional vegetation cover, and leaf area index. Remote sensing of Environment, 62(3):241–252, 1997.
+
+Tony F Chan and Chiu-Kwong Wong. Total variation blind deconvolution. IEEE transactions on Image Processing, 7(3):370–375, 1998.
+
+Hong Chang, Dit-Yan Yeung, and Yimin Xiong. Super-resolution through neighbor embedding. In Proceedings of the 2004 IEEE Computer Society Conference on Computer Vision and Pattern Recognition, 2004. CVPR 2004., volume 1, pp. I–I. IEEE, 2004.
+
+Zhengping Che, Sanjay Purushotham, Kyunghyun Cho, David Sontag, and Yan Liu. Recurrent neural networks for multivariate time series with missing values. Scientific reports, 8(1):6085, 2018.
+
+Colin B Clement, Matthew Bierbaum, and James P Sethna. Image registration and super resolution from first principles. arXiv preprint arXiv:1809.05583, 2018.
+
+Julien Cornebise, Daniel Worrall, Micah Farfour, and Milena Marin. Witnessing atrocities: Quantifying villages destruction in darfur with crowdsourcing and transfer learning. In AI for Social Good NIPS2018 Workshop, Montreal, Canada ´ , 2018.
+
+Daniel DeTone, Tomasz Malisiewicz, and Andrew Rabinovich. Deep image homography estimation. arXiv preprint arXiv:1606.03798, 2016.
+
+Wouter Dierckx, Sindy Sterckx, Iskander Benhadj, Stefan Livens, Geert Duhoux, Tanja Van Achteren, Michael Francois, Karim Mellab, and Gilbert Saint. Proba-v mission for global vegetation monitoring: standard products and image quality. International Journal of Remote Sensing, 35(7):2589–2614, 2014.
+
+Chao Dong, Chen Change Loy, Kaiming He, and Xiaoou Tang. Learning a deep convolutional network for image super-resolution. In European conference on computer vision, pp. 184–199. Springer, 2014.
+
+K Eric Drexler. Reframing superintelligence: Comprehensive ai services as general intelligence, 2019.
+
+Sina Farsiu, M Dirk Robinson, Michael Elad, and Peyman Milanfar. Fast and robust multiframe super resolution. IEEE transactions on image processing, 13(10):1327–1344, 2004.
+
+J Michael Fitzpatrick, Derek LG Hill, Calvin R Maurer, et al. Image registration. Handbook of medical imaging, 2:447–513, 2000.
+
+William T Freeman, Thouis R Jones, and Egon C Pasztor. Example-based super-resolution. IEEE Computer graphics and Applications, 22(2):56–65, 2002.
+
+Theresa L. Harris, Jonathan Drake, Jessica M. Wyndham, Susan R. Wolfinbarger, Stephen D. Lott, and Michael Lerner. Geospatial evidence in international human rights litigation: Technical and legal considerations. Technical report, AAAS Scientific Responsibility, Human Rights and Law Program, 2018.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing humanlevel performance on imagenet classification. In Proceedings of the 2015 IEEE International Conference on Computer Vision (ICCV), ICCV ’15, pp. 1026–1034, Washington, DC, USA, 2015. IEEE Computer Society. ISBN 978-1-4673-8391-2. doi: 10.1109/ICCV.2015.123. URL http://dx.doi.org/10.1109/ ICCV.2015.123.
+
+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.
+
+Patrick Helber, Bradley Gram-Hansen, Indhu Varatharajan, Faiza Azam, Alejandro Coca-Castro, Veronika Kopackova, and Piotr Bilinski. Mapping informal settlements in developing countries with multi-resolution, multi-spectral data. arXiv preprint arXiv:1812.00812, 2018.
+
+Michal Irani and Shmuel Peleg. Improving resolution by image registration. CVGIP: Graphical models and image processing, 53(3):231–239, 1991.
+
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1125–1134, 2017.
+
+David Jensen and Jillian Campbell. The promise and peril of a digital ecosystem for the planet, September 2019. URL https://medium.com/@davidedjensen 99356/building-a-digitalecosystem-for-the-planet-557c41225dc2. [Online; posted 11-September-2019].
+
+Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and superresolution. In European conference on computer vision, pp. 694–711. Springer, 2016.
+
+Michal Kawulok, Pawel Benecki, Krzysztof Hrynczenko, Daniel Kostrzewa, Szymon Piechaczek, Jakub Nalepa, and Bogdan Smolka. Deep learning for fast super-resolution reconstruction from multiple images. In Real-Time Image Processing and Deep Learning 2019, volume 10996, pp. 109960B. International Society for Optics and Photonics, 2019.
+
+Jiwon Kim, Jung Kwon Lee, and Kyoung Mu Lee. Deeply-recursive convolutional network for image superresolution. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1637– 1645, 2016.
+
+Kwang In Kim and Younghee Kwon. Single-image super-resolution using sparse regression and natural image prior. IEEE transactions on pattern analysis and machine intelligence, 32(6):1127–1133, 2010.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Christian Ledig, Lucas Theis, Ferenc Huszar, Jose Caballero, Andrew Cunningham, Alejandro Acosta, Andrew ´ Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, et al. Photo-realistic single image super-resolution using a generative adversarial network. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4681–4690, 2017.
+
+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.
+
+Robert J II Marks. Introduction to Shannon sampling and interpolation theory. Springer Science & Business Media, 2012.
+
+Marcus Martens, Dario Izzo, Andrej Krzic, and Dani ¨ el Cox. Super-resolution of proba-v images using convo-¨ lutional neural networks. Astrodynamics, 3(4):387–402, Dec 2019.
+
+Andrea Bordone Molini, Diego Valsesia, Giulia Fracastoro, and Enrico Magli. Deepsum: Deep neural network for super-resolution of unregistered multitemporal images. arXiv preprint arXiv:1907.06490, 2019.
+
+Seungjun Nah, Radu Timofte, Sungyong Baik, Seokil Hong, Gyeongsik Moon, Sanghyun Son, and Kyoung Mu Lee. Ntire 2019 challenge on video deblurring: Methods and results. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pp. 0–0, 2019.
+
+Nhat Nguyen, Peyman Milanfar, and Gene Golub. A computationally efficient superresolution image reconstruction algorithm. IEEE transactions on image processing, 10(4):573–583, 2001.
+
+Harry Nyquist. Certain topics in telegraph transmission theory. Transactions of the American Institute of Electrical Engineers, 47(2):617–644, 1928.
+
+Athanasios Papoulis. Generalized sampling expansion. IEEE transactions on circuits and systems, 24(11): 652–654, 1977.
+
+Nathalie Pettorelli, Jon Olav Vik, Atle Mysterud, Jean-Michel Gaillard, Compton J Tucker, and Nils Chr Stenseth. Using the satellite-derived ndvi to assess ecological responses to environmental change. Trends in ecology & evolution, 20(9):503–510, 2005.
+
+Lyndsey C Pickup, Stephen J Roberts, and Andrew Zisserman. Optimizing and learning for super-resolution. In BMVC, volume 9, pp. 4–7. Citeseer, 2006.
+
+David Rolnick, Priya L Donti, Lynn H Kaack, Kelly Kochanski, Alexandre Lacoste, Kris Sankaran, Andrew Slavin Ross, Nikola Milojevic-Dupont, Natasha Jaques, Anna Waldman-Brown, et al. Tackling climate change with machine learning. arXiv preprint arXiv:1906.05433, 2019.
+
+Tim GJ Rudner, Marc Rußwurm, Jakub Fil, Ramona Pelich, Benjamin Bischke, Veronika Kopackov ˇ a, and ´ Piotr Bilinski. Multi3net: Segmenting flooded buildings via fusion of multiresolution, multisensor, and ´ multitemporal satellite imagery. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 702–709, 2019.   
+Mehdi SM Sajjadi, Raviteja Vemulapalli, and Matthew Brown. Frame-recurrent video super-resolution. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 6626–6634, 2018.   
+Eduardo Sanchez, Mathieu Serrurier, and Mathias Ortner. Learning disentangled representations of satellite image time series. arXiv preprint arXiv:1903.08863, 2019.   
+Claude Elwood Shannon. Communication in the presence of noise. Proceedings of the IRE, 37(1):10–21, 1949.   
+Assaf Shocher, Nadav Cohen, and Michal Irani. zero-shot super-resolution using deep internal learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3118–3126, 2018.   
+Rupesh Kumar Srivastava, Klaus Greff, and Jurgen Schmidhuber. Highway networks. ¨ arXiv preprint arXiv:1505.00387, 2015.   
+Xin Tao, Hongyun Gao, Renjie Liao, Jue Wang, and Jiaya Jia. Detail-revealing deep video super-resolution. In Proceedings of the IEEE International Conference on Computer Vision, pp. 4472–4480, 2017.   
+Radu Timofte, Shuhang Gu, Jiqing Wu, Luc Van Gool, Lei Zhang, Ming-Hsuan Yang, Muhammad Haris, et al. Ntire 2018 challenge on single image super-resolution: Methods and results. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR) Workshops, June 2018.   
+RY Tsai. Multiple frame image restoration and registration. Advances in Computer Vision and Image Processing, 1:1715–1984, 1984.   
+Ken Turkowski. Filters for common resampling tasks. In Graphics gems, pp. 147–165. Academic Press Professional, Inc., 1990.   
+Oriol Vinyals, Samy Bengio, and Manjunath Kudlur. Order matters: Sequence to sequence for sets. arXiv preprint arXiv:1511.06391, 2015.   
+Longguang Wang, Yingqian Wang, Zhengfa Liang, Zaiping Lin, Jungang Yang, Wei An, and Yulan Guo. Learning parallax attention for stereo image super-resolution. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 12250–12259, 2019a.   
+Xintao Wang, Kelvin CK Chan, Ke Yu, Chao Dong, and Chen Change Loy. Edvr: Video restoration with enhanced deformable convolutional networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pp. 0–0, 2019b.   
+Yingqian Wang, Longguang Wang, Jungang Yang, Wei An, and Yulan Guo. Flickr1024: A large-scale dataset for stereo image super-resolution. In Proceedings of the IEEE International Conference on Computer Vision Workshops, pp. 0–0, 2019c.   
+Zhihao Wang, Jian Chen, and Steven CH Hoi. Deep learning for image super-resolution: A survey. arXiv preprint arXiv:1902.06068, 2019d.   
+Erwin Wolters, Wouter Dierckx, J Dries, and Else Swinnen. Proba-v products user manual. VITO. http://probav. vgt. vito. be/sites/default/files/Product User Manual. pdf, 2014.   
+Li Xu, Jimmy SJ Ren, Ce Liu, and Jiaya Jia. Deep convolutional neural network for image deconvolution. In Advances in Neural Information Processing Systems, pp. 1790–1798, 2014.   
+Bo Yan, Chuming Lin, and Weimin Tan. Frame and feature-context video super-resolution. arXiv preprint arXiv:1909.13057, 2019.   
+Jianchao Yang, John Wright, Thomas S Huang, and Yi Ma. Image super-resolution via sparse representation. IEEE transactions on image processing, 19(11):2861–2873, 2010.   
+Roman Zeyde, Michael Elad, and Matan Protter. On single image scale-up using sparse-representations. In International conference on curves and surfaces, pp. 711–730. Springer, 2010.
+
+# A APPENDIX
+
+# A.1 EXPERIMENTAL DETAILS
+
+We trained our models on low-resolution patches of size 64x64. HighRes-net’s architecture is reported in Table 3. We denote by Conv2d(in, out, k, s, p) a conv2D layer with in and out input/output channels, kernel of size $^ { ( \mathrm { k } , \mathrm { k } ) }$ , stride (s,s) and padding p. We used the ADAM optimizer (Kingma & Ba, 2014) with default hyperparameters and trained our models on batches of size 32, for 400 epochs, using $90 \%$ of the data for training and $10 \%$ for validation. Our learning rate is initialized to 0.0007, decayed by a factor of 0.97 if the validation loss plateaus for more than 2 epochs. For the regularization of shiftNet, we employed $\lambda = 0 . 0 0 0 0 0 1$ .
+
+Table 2: ResidualBlock(h) architecture   
+
+<table><tr><td>layerO layer1 layer2 layer3</td><td>Conv2d(in=h,out=h,k3,s1,p1) PReLU Conv2d(in=h,out=h,k3,s1, p1) PReLU</td></tr></table>
+
+Table 3: HRNet architecture   
+
+<table><tr><td>Step</td><td>Layers</td><td>Number of params</td></tr><tr><td rowspan="4">encode</td><td>Conv2d(in=2, out=64,k3,s1, p1)</td><td>1216</td></tr><tr><td>PReLU</td><td>1</td></tr><tr><td>ResidualBlock(64)</td><td>73858</td></tr><tr><td>ResidualBlock(64)</td><td>73858</td></tr><tr><td rowspan="3">fuse</td><td>Conv2d(in=64,out=64,k3,s1, p1)</td><td>36928</td></tr><tr><td>ResidualBlock(128) Conv2d(in=128, out=64,k3, s1, p1)</td><td>295170</td></tr><tr><td>PReLU</td><td>73792 1</td></tr><tr><td rowspan="2">decode</td><td>ConvTranspose2d(in=64,out=64,k3, s1) PreLU</td><td>36928</td></tr><tr><td>Conv2d(in=64,out=1,k1, s1)</td><td>1 65</td></tr><tr><td>residual (optional)</td><td>Upsample(scale_factor=3.0, mode=bicubic)</td><td>0</td></tr><tr><td></td><td></td><td>591818 (total)</td></tr></table>
+
+Thanks to weight sharing, HighRes-net super-resolves scenes with 32 views in 5 recursive steps, while requiring less than 600K parameters. ShiftNet has more than 34M parameters (34187648) but is dropped during test time. We report GPU memory requirements in table 4 for reproducibility purposes.
+
+Table 4: GPU memory requirements to train HighRes-net $^ +$ ShiftNet on patches of size $6 4 \mathrm { x 6 4 }$ with batches of size 32, and a variable number of low-resolution frames.   
+
+<table><tr><td># views GPU memory (GB)</td><td>32 27</td><td>16 15</td><td>4 6</td></tr></table>
+
+# A.2 HOW MANY FRAMES DO YOU NEED?
+
+We trained and tested HighRes-net with ShiftNet using 1 to 32 frames. With a single image, our approach performs worse than the ESA baseline. Doubling the number of frames significantly improves both our training and validation scores. After 16 frames, our model’s performance stops increasing as show in Figure 5.
+
+![](images/4e7d47197ce6d9c764083126f46b2e6c722419fc57fa52c2620e750025708518.jpg)  
+Figure 5: Public leaderboard scores vs. nviews for HighRes-net $^ +$ ShiftNet. Lower is better.
+
+# A.3 REGISTRATION MATTERS
+
+Registered loss The only explicit registration that we perform is at the loss stage, to allow the model partial credit for a solution. This solution can be enhanced but otherwise mis-registered wrt to the ground truth. We trained our base model HighRes-net without ShiftNet-Lanczos and observed a drop in performance as shown in Table 5. Registration matters and aligning outputs with targets helps HighRes-net generate sharper outputs and achieve competitive results.
+
+Table 5: Registration matters: Train and validation scores for HighResNet trained with and without ShiftNet-Lanczos. Lower is better.   
+
+<table><tr><td rowspan=1 colspan=1>HighRes-net +</td><td rowspan=1 colspan=1>train score</td><td rowspan=1 colspan=1>test score</td></tr><tr><td rowspan=1 colspan=1>w/o registrationShiftNet +Lanczos</td><td rowspan=1 colspan=1>0.96160.9501</td><td rowspan=1 colspan=1>0.96710.9532</td></tr></table>
+
+Implicit co-registration The traditional practice in MFSR is to explicitly co-register the LR views prior to super-resolution (Tsai, 1984; Molini et al., 2019). The knowledge of sub-pixel missalignments tells an algorithm what pieces of information to fuse from each LR image for any pixel in the SR output. Contrary to the conventional practice in MFSR, we propose implicit co-registeration by pairing LR views with a reference frame a.k.a. anchor. In this sense, we never explicitly compute the relative shifts between any LR pair. Instead, we simply stack each view with a chosen reference frame as an additional channel to the input. We call this strategy implicit co-registration, We found this strategy to be effective in the following ablation study which addresses the impact of the choice of a reference frame aka anchor.
+
+We observe the median reference is the most effective in terms of train and test score. We suspect the median performs better than the mean because the median is more robust to outliers and can help denoise the LR views. Interestingly, training and testing without a shared reference performed worse than the ESA baseline. This shows that co-registration (implicit or explicit) matters. This can be due to the fact that the model lacks information to align and fuse the multiple views.
+
+ShiftNet architecture ShitNet has 8 layers of (conv2D $^ +$ BatchNorm2d $^ +$ ReLU). Layer 2, 4 and 6 are followed by MaxPool2d. The final output is flattened to a vector $x$ of size 32768. Then, we compute a vector of size 1024, $x = \operatorname { R e L U } ( \operatorname { f c 1 } ( \operatorname { d r o p o u t } ( x ) ) )$ . The final shift prediction is $\operatorname { f c } 2 ( x )$ of size 2. The bulk of the parameters come from fc1, with $3 2 7 6 8 \times 1 0 2 4$ weights. These alone, account for $9 9 \%$ of ShiftNet’s parameters. Adding a MaxPool2d on top of layer 3, 5, 7 or 8 halves the parameters of ShiftNet.
+
+Table 6: Train and validation scores for HighRes-net $^ +$ ShiftNet-Lanczos trained and tested with different references as input. Lower is better.   
+
+<table><tr><td>Reference</td><td>train score</td><td>test score</td></tr><tr><td>None (no co-registration)</td><td>1.0131</td><td>1.0088</td></tr><tr><td>Mean of 9 LRs</td><td>0.9636</td><td>0.9690</td></tr><tr><td>Median or 9 LRs (base)</td><td>0.9501</td><td>0.9532</td></tr></table>
+
+# A.4 TOWARDS PERMUTATION INVARIANCE
+
+A desirable property of a fusion model acting on an un-ordered set of images, is permutationinvariance: the output of the model should be invariant to the order in which the LR views are fused. An easy approach to encourage permutation invariant neural networks is to randomly shuffle the inputs at training time before feeding them to a model (Vinyals et al., 2015).
+
+In addition to randomization, we still want to give more importance to clear LR views (with high clearance score), which can be done by sorting them by clearance. A good trade-off between uniform sampling and deterministic sorting by clearance, is to sample $k$ LR views without replacement and with a bias towards higher clearance:
+
+$$
+p ( i \mid C _ { 1 } , \ldots , C _ { k } ) = { \frac { e ^ { \beta C _ { i } } } { \sum _ { j = 1 } ^ { k } e ^ { \beta C _ { j } } } } ,
+$$
+
+where $k$ is the total number of LR views, $C _ { i }$ is the clearance score of $\mathrm { L R } _ { i }$ and $\beta$ regulates the bias towards higher clearance scores,
+
+When $\beta = 0$ , this sampling strategy corresponds to uniform sampling and when $\beta = + i n f$ , this corresponds to picking the $\mathbf { k }$ -clearest views in a deterministic way. Our default model was trained with $\beta = 5 0$ and our experiments are reported in Table 7.
+
+Table 7: Validation scores vs. nviews for HighRes-net $^ +$ ShiftNet. Lower is better.   
+
+<table><tr><td rowspan=1 colspan=1>Sampling strategy</td><td rowspan=1 colspan=1>train score</td><td rowspan=1 colspan=1>test score</td></tr><tr><td rowspan=1 colspan=1>β=∞ (k-clearest)β = 0 (uniform-k)β= 50 (base)</td><td rowspan=1 colspan=1>0.93860.96380.9501</td><td rowspan=1 colspan=1>0.96870.96750.9532</td></tr></table>
+
+From Table 7, $\beta = \infty$ reaches best training score and worst testing score. For $\beta = 5 0$ and $\beta = 0$ , the train/test gap is much more reduced. This suggests that the deterministic strategy is overfitting and randomness prevents overfitting (diversity matters). On the other hand, $\beta = 5 0$ performs significantly better than $\beta = 0$ suggesting that biasing a model towards higher clearances could be beneficial i.e., clouds matter too.

parse/train/HJxJ2h4tPr/HJxJ2h4tPr_content_list.json

@@ -0,0 +1,1916 @@
+[
+    {
+        "type": "text",
+        "text": "HIGHRES-NET: MULTI-FRAME SUPER-RESOLUTION BY RECURSIVE FUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative deep learning has sparked a new wave of Super-Resolution (SR) algorithms that enhance single images with impressive aesthetic results, albeit with imaginary details. Multi-frame Super-Resolution (MFSR) offers a more grounded approach to the ill-posed problem, by conditioning on multiple low-resolution views. This is important for satellite monitoring of human impact on the planet – from deforestation, to human rights violations – that depend on reliable imagery. To this end, we present HighRes-net, the first deep learning approach to MFSR that learns its sub-tasks in an end-to-end fashion: (i) co-registration, (ii) fusion, (iii) up-sampling, and (iv) registration-at-the-loss. Co-registration of low-res views is learned implicitly through a reference-frame channel, with no explicit registration mechanism. We learn a global fusion operator that is applied recursively on an arbitrary number of low-res pairs. We introduce a registered loss, by learning to align the SR output to a ground-truth through ShiftNet. We show that by learning deep representations of multiple views, we can super-resolve low-resolution signals and enhance Earth observation data at scale. Our approach recently topped the European Space Agency’s MFSR competition on real-world satellite imagery. ",
+        "bbox": [
+            232,
+            268,
+            764,
+            505
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            536,
+            334,
+            553
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Multiple low-resolution images collectively contain more information than any individual lowresolution image, due to minor geometric displacements, e.g. shifts, rotations, atmospheric turbulence, and instrument noise. Multi-Frame Super-Resolution (MFSR) (Tsai, 1984) aims to reconstruct hidden high-resolution details from multiple low-resolution views of the same scene. Single Image Super-Resolution (SISR), as a special case of MFSR, has attracted much attention in the computer vision, machine learning and deep learning communities in the last 5 years, with neural networks learning complex image priors to upsample and interpolate images (Xu et al., 2014; Srivastava et al., 2015; He et al., 2016). However, in the meantime not much work has explored the learning of representations for the more general problem of MFSR to address the additional challenges of co-registration and fusion of multiple low-resolution images. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            709
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper explores how Multi-Frame Super-Resolution (MFSR) can benefit from recent advances in learning representations with neural networks. To the best of our knowledge, this work is the first to introduce a deep-learning approach that solves the co-registration, fusion and registration-at-theloss problems in an end-to-end learning framework. ",
+        "bbox": [
+            174,
+            717,
+            823,
+            772
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Prompting this line of research is the increasing drive towards planetary-scale Earth observation to monitor the environment and human rights violations. Such observation can be used to inform policy, achieve accountability and direct on-the-ground action, e.g. within the framework of the Sustainable Development Goals (Jensen & Campbell, 2019). ",
+        "bbox": [
+            174,
+            779,
+            823,
+            835
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Nomenclature Registration is the problem of estimating the relative geometric differences between two images (e.g. due to shifts, rotations, deformations). Fusion, in the MFSR context, is the problem of mapping multiple low-res representations into a single representation. By coregistration, we mean the problem of registering all low-resolution views to improve their fusion. By registration-at-the-loss, we mean the problem of registering the super-resolved reconstruction to the high-resolution ground-truth prior to computing the loss. This gives rise to the notion of a registered loss. ",
+        "bbox": [
+            176,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Co-registration of multiple images is required for longitudinal studies of land change and environmental degradation. The fusion of multiple images is key to exploiting cheap, high-revisit-frequency satellite imagery, but of low-resolution, moving away from the analysis of infrequent and expensive high-resolution images. Finally, beyond fusion itself, super-resolved generation is required throughout the technical stack: both for labeling, but also for human oversight (Drexler, 2019) demanded by legal context (Harris et al., 2018). ",
+        "bbox": [
+            173,
+            138,
+            825,
+            222
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Summary of contributions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            241,
+            357,
+            255
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• HighRes-net: We propose a deep architecture that learns to fuse an arbitrary number of lowresolution frames with implicit co-registration through a reference-frame channel.   \n• ShiftNet: Inspired by HomographyNet (DeTone et al., 2016), we define a model that learns to register and align the super-resolved output of HighRes-net, using ground-truth high-resolution frames as supervision. This registration-at-the-loss mechanism enables more accurate feedback from the loss function into the fusion model, when comparing a super-resolved output to a ground truth high resolution image. Otherwise, a MFSR model would naturally yield blurry outputs to compensate for the lack of registration, to correct for sub-pixel shifts and account for misalignments in the loss.   \n• By combining the two components above, we contribute the first architecture to learn fusion and registration end-to-end.   \n• We test and compare our approach to several baselines on real-world imagery from the PROBA-V satellite of ESA. Our performance has topped the Kelvins competition on MFSR, organized by the Advanced Concepts Team of ESA (Martens et al. ¨ , 2019) (see section 5). ",
+        "bbox": [
+            173,
+            266,
+            825,
+            473
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/57f84aa8ae2163a66792c1b839d4633dbbc9d02c4c6432e1c23677304399db54.jpg",
+        "image_caption": [
+            "Figure 1: HighRes-net combines many low-resolution images (300 meters/pixel) into one image of superior resolution. The same site shot in high-resolution $( { 1 0 0 } \\mathrm { { m } / { p i x } ) }$ is also shown for reference. Source of low-res and high-res: imgset1087 and imgset0285 of PROBA-V dataset, see section 5. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            494,
+            821,
+            626
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The rest of the paper is divided as follows: in Section 2, we discuss related work on SISR and MFSR; Section 3 outlines HighRes-net and section 4 presents ShiftNet, a differentiable registration component that drives our registered loss mechanism during end-to-end training. We present our results in section 5, and in Section 6 we discuss some opportunities for and limitations and risks of super-resolution. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            770
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            792,
+            326,
+            810
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 MULTI-FRAME SUPER-RESOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            827,
+            460,
+            840
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "How much detail can we resolve in the digital sample of some natural phenomenon? Nyquist (1928) observed that it depends on the instrument’s sampling rate and the oscillation frequency of the underlying natural signal. Shannon (1949) built a sampling theory that explained Nyquist’s observations when the sampling rate is constant (uniform sampling) and determined the conditions of aliasing in a sample. Figure 2 illustrates this phenomenon. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/19931371c44718352413422be81c54ee05750a8e418aac479f81249e3b2d120f.jpg",
+        "image_caption": [
+            "high-resolutioDFT magnitude F fHR Figure 2: Top: A chirp harmonic oscillator $\\sin \\left( 2 \\pi \\omega ( t ) t \\right)$ equency 1 kHz DFT magnitudeF fLR , with instantaneous frequency $\\omega ( t )$ . Left: The shape of the high-resolution sample resembles the underlying chirp signal. Right: Close to $t = 1$ , the apparent −400 −200 0 200 400 frequency (Hz) −100 −50 0 50 100 frequency (Hz)frequency of the low-resolution sample does not match that of the chirp. This is an example of aliasing (shown 0.0 0.2 0.4 0.6 0.8 1.0 t (sec)   with red at its most extreme), and it happens when the sampling rate falls below the Nyquist rate, $s _ { N } = 2 \\cdot s _ { B }$ , where $s _ { B }$ is the highest non-zero frequency of the signal. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            97,
+            823,
+            185
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "− −   frequency (Hz) Sampling at high-resolution (left) maintains the frequency of the chirp signal (top). Sampling at a lower resolution (right), this apparent chirped frequency is lost due to aliasing, which means that the lower-resolution sample has a fundamentally smaller capacity for resolving the information of the natural signal, and a higher sampling rate can resolve more information. ",
+        "bbox": [
+            174,
+            290,
+            825,
+            345
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Shannon’s sampling theory has since been generalized for multiple interleaved sampling frames (Papoulis, 1977; Marks, 2012). One result of the generalized sampling theory is that we can go beyond the Nyquist limit of any individual uniform sample by interleaving several uniform samples taken concurrently. When an image is down-sampled to a lower resolution, its high-frequency details are lost permanently and cannot be recovered from any image in isolation. However, by combining multiple low-resolution images, it becomes possible to recover the original scene at a higher resolution. ",
+        "bbox": [
+            174,
+            353,
+            825,
+            450
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Moreover, different low-resolution samples may be sampled at different phases, such that the same high-resolution frequency information will be packed with a phase shift. As a consequence, when multiple low-resolution samples are available, the fundamental challenge of MFSR is de-aliasing, i.e. disentangling the high-frequency components (Tsai, 1984). ",
+        "bbox": [
+            174,
+            458,
+            825,
+            513
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The first work on MSFR (Tsai, 1984) considered the reconstruction of a high-resolution image as a fusion of co-registered low-resolution images in the Fourier domain. With proper registration and fusion (Irani & Peleg, 1991; Fitzpatrick et al., 2000; Capel & Zisserman, 2001), a composite super-resolved image can reveal some of the original high-frequency detail that would not have been accessible from single low-resolution image. In this work, we introduce HighRes-Net, which aims to provide an end-to-end deep learning framework for MFSR settings. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            604
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Relation to Video and Stereo Super-Resolution While there are obvious similarities to Video SR (Tao et al., 2017; Sajjadi et al., 2018; Yan et al., 2019; Wang et al., 2019b) and Stereo SR (Wang et al., 2019d) (Wang et al., 2019a), the setting of this work differs in several ways: HighResnet learns to super-resolve sets and not sequences of low-res views. Video SR relies on motion estimation from a sequence of observations. Also, prediction at time $t = T$ relies on predictions at $t < T$ (autoregressive approach). Whereas in our case, we predict a single image from an unordered set of low-res inputs. Also, the low-res views are multi-temporal (taken at different times). ",
+        "bbox": [
+            174,
+            621,
+            825,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Video SR methods assume that the input is a temporal sequence of frames. Motion or optical flow can be estimated to super-resolve the sequences of frames. In this work, we do not assume low-res inputs to be ordered in time. Our training input is a set of low-res views with unknown timestamps and our target output is a single image — not another sequence. ",
+        "bbox": [
+            174,
+            726,
+            823,
+            781
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 A PROBABILISTIC APPROACH ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            800,
+            416,
+            814
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In addition to aliasing, MFSR deals with random processes like noise, blur, geometric distortions – all contributing to random low-resolution images. Traditionally, MFSR methods assume a-priori knowledge of the data generating motion model, blur kernel, noise level and degradation process; see for example, Pickup et al. (2006). Given multiple low-resolution images, the challenge of MFSR is to reconstruct a plausible image of higher-resolution that could have generated the observed lowresolution images. Optimization methods aim to improve an initial guess by minimizing an error between simulated and observed low-resolution images. These methods traditionally model the additive noise $\\epsilon$ and prior knowledge about natural images explicitly, to constrain the parameter search space and derive objective functions, using e.g. Total Variation (Chan & Wong, 1998; Farsiu et al., 2004), Tikhonov regularization (Nguyen et al., 2001) or Huber potential (Pickup et al., 2006) to define appropriate constraints on images. ",
+        "bbox": [
+            174,
+            825,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/60f3e8ff55b1438a0126fff317ac8933a2245b72bfd38df5a060692c6d6872ef.jpg",
+        "image_caption": [
+            "Figure 3: Schematic of the full processing pipeline, trained end-to-end. At test time, only HighRes-net is used. (a) HighRes-net: In the Encode stage, an arbitrary number of LR views are paired with the reference low-res image (the median low-res in this work). Each LR view–reference pair is encoded into a view-specific latent representation. The LR encodings are fused recursively into a single global encoding. In the Decode stage, the global representation is upsampled by a certain zoom factor $\\times 3$ in this work). Finally, the superresolved image is reconstructed by combining all channels of the upsampled global encoding. (b) Registered loss: Generally, the reconstructed SR will be shifted with respect to the ground-truth HR. ShiftNet learns to estimate the $( \\Delta x , \\Delta y )$ shift that improves the loss. Lanczos resampling: $( \\Delta x , \\Delta y )$ define two 1D shifting Lanczos kernels that translate the SR by a separable convolution. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            99,
+            810,
+            297
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            453,
+            825,
+            510
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In some situations, the image degradation process is complex or not available, motivating the development of nonparametric strategies. Patch-based methods learn to form high-resolution images directly from low-resolution patches, e.g. with $\\mathbf { k }$ -nearest neighbor search (Freeman et al., 2002; Chang et al., 2004), sparse coding and sparse dictionary methods (Yang et al., 2010; Zeyde et al., 2010; Kim & Kwon, 2010)). The latter represents images in an over-complete basis and allows for sharing a prior across multiple sites. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            599
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this work, we are particularly interested in super-resolving satellite imagery. Much of the recent work in Super-Resolution has focused on SISR for natural images. For instance, Dong et al. (2014) showed that training a CNN for super-resolution is equivalent to sparse coding and dictionary based approaches. Kim et al. (2016) proposed an approach to SISR using recursion to increase the receptive field of a model while maintaining capacity by sharing weights. Many more networks and learning strategies have recently been introduced for SISR and image deblurring. Benchmarks for SISR (Timofte et al., 2018), differ mainly in their upscaling method, network design, learning strategies, etc. We refer the reader to (Wang et al., 2019d) for a more comprehensive review. ",
+        "bbox": [
+            174,
+            607,
+            823,
+            718
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Few deep-learning approaches have considered the more general MFSR setting and attempted to address it in an end-to-end learning framework. Reecently, Kawulok et al. (2019) proposed a shiftand-add method and suggested “including image registration” in the learning process as future work. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            767
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the following sections, we describe our approach to solving both aspects of the registration problem – co-registration and registration-at-the-loss – in a memory-efficient manner. ",
+        "bbox": [
+            174,
+            773,
+            821,
+            803
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 HIGHRES-NET: MFSR BY RECURSIVE FUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            821,
+            591,
+            838
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present HighRes-net, a neural network for multi-frame super-resolution inside a single spectral band (greyscale images), using joint co-registration and fusion of multiple lowresolution views in an end-to-end learning framework. From a high-level, HighRes-net consists of an encoder-decoder architecture and can be trained by stochastic gradient descent using highresolution ground truth as supervision, as shown in Figure 3. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Notation We denote by $\\theta$ the parameters of HighRes-net trained for a given upscaling factor $\\gamma$ . $L R _ { v , i } \\ \\in \\ \\mathbb { R } ^ { C \\times W \\times H }$ is one of a set of $K$ low-resolution views from the same site $v$ , where $C$ , $W$ and $H$ are the number of input channels, width and height of $L R _ { v , i }$ , respectively. We denote by $S R _ { v } ^ { \\theta } = F _ { \\theta } ^ { \\gamma } \\left( L R _ { v , 1 } . \\right.$ , . . . , $L R _ { v , K } )$ , the output of HighRes-net and by $H R _ { v } \\in \\mathbb R ^ { C \\times \\gamma W \\times \\gamma H }$ a ground truth high-resolution image. We denote by $[ T _ { 1 } , T _ { 2 } ]$ the concatenation of two images channelwise. In the following we supress the index $v$ over sites for clarity. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            189
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "HighRes-Net consists of three main steps: (1) encoding, which learns relevant features associated with each low-resolution view, (2) fusion, which merges relevant information from views within the same scene, and (3) decoding, which proposes a high-resolution reconstruction from the fused summary. ",
+        "bbox": [
+            174,
+            195,
+            825,
+            252
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 ENCODE, FUSE, DECODE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            268,
+            390,
+            284
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Embed, Encode The core assumption of MFSR is that the low-resolution image set contains collectively more information than any single low-resolution image alone, due to differences in photometric or spatial coverage for instance. However, the redundant low frequency information in multiple views can hinder the training and test performance of a MFSR model. We thus compute a reference image ref as a shared representation for multiple low-resolution views $\\left( L R _ { i } \\right) _ { i = 1 } ^ { K }$ and embed each image jointly with ref. This highlights differences across the multiple views (Sanchez et al., 2019), and potentially allows HighRes-net to focus on difficult high-frequency features such as crop boundaries and rivers during super-resolution. The shared representation or reference image intuitively serves as an anchor for implicitly aligning and denoising multiple views in deeper layers. We refer to this mechanism as implicit $c o$ -registration. ",
+        "bbox": [
+            173,
+            294,
+            825,
+            438
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "HighRes-net’s embedding layer $\\operatorname { e m b } _ { \\theta }$ consists of a convolutional layer and two residual blocks with PReLu activations (He et al., 2015) and is shared across all views. The embedded hidden states $s _ { i } ^ { 0 }$ are computed in parallel as follows: ",
+        "bbox": [
+            176,
+            444,
+            823,
+            486
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9020e4a398a8ebd3e620f80c19ec9d9355ab348701c6bba98dde4baa4477a335.jpg",
+        "text": "$$\n\\begin{array} { r l } & { r e f ( c , i , j ) = \\operatorname * { m e d i a n } \\left( L R _ { 1 } ( c , i , j ) , \\mathrm { ~ } \\ldots , \\mathrm { ~ } L R _ { K } ( c , i , j ) \\right) , \\mathrm { s u c h ~ t h a t } r e f \\in \\mathbb { R } ^ { C \\times W \\times H } } \\\\ & { \\qquad \\quad s _ { i } ^ { 0 } = \\operatorname { e m b } _ { \\theta } \\left( \\left[ L R _ { i } , \\mathrm { ~ } r e f \\right] \\right) \\in \\mathbb { R } ^ { C _ { h } \\times W \\times H } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            212,
+            492,
+            784,
+            534
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $C _ { h }$ denotes the channels of the hidden state. ",
+        "bbox": [
+            174,
+            537,
+            506,
+            553
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The imageset is padded if the number of low-res views $K ^ { \\prime }$ is not a power of 2: we pad the set with dummy zero-valued views, such that the new size of the imageset $K$ is the next power of 2. See Algorithm 1, line 1. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            602
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Fuse The embedded hidden states $s _ { i } ^ { 0 }$ are then fused recursively, halving by two the number of low-resolution states at each fusion step $t$ , as shown in Figure 4. Given a pair of hidden states $s _ { i } ^ { t } , s _ { j } ^ { t }$ HighRes-net computes a new representation: ",
+        "bbox": [
+            176,
+            617,
+            823,
+            660
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1ee78e5fd328025558e3207514a155258a77812f75ef2a2b36a1ca1246c1d9f4.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\left[ { \\tilde { s } } _ { i } ^ { t } , \\ { \\tilde { s } } _ { j } ^ { t } \\right] = \\left[ s _ { i } ^ { t } , \\ s _ { j } ^ { t } \\right] + g _ { \\theta } \\left( \\left[ s _ { i } ^ { t } , \\ s _ { j } ^ { t } \\right] \\right) \\in \\mathbb { R } ^ { 2 C _ { h } \\times W \\times H } } \\\\ & { \\quad \\quad s _ { i } ^ { t + 1 } = s _ { i } ^ { t } + \\alpha _ { j } f _ { \\theta } \\left( \\tilde { s } _ { i } ^ { t } , \\ { \\tilde { s } } _ { j } ^ { t } \\right) \\in \\mathbb { R } ^ { C _ { h } \\times W \\times H } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            665,
+            668,
+            710
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\tilde { s } _ { i } ^ { t } , ~ \\tilde { s } _ { j } ^ { t }$ are intermediate representations; $g _ { \\theta }$ is a shared-representation within an inner residual block (equation 3); $f _ { \\theta }$ is a fusion block, and $\\alpha _ { j }$ is 0 if the $j$ -th low-resolution view is part of the padding, and 1 otherwise. $f _ { \\theta }$ squashes $2 C _ { h }$ input channels into $C _ { h }$ channels and consists of a $( \\mathrm { c o n v } 2 \\mathrm { d } \\mathrm { + } \\mathrm { P r e L u } )$ . Intuitively, gθ aligns the two representations and it consists of two $\\mathrm { \\ c o n v { 2 d } + }$ PreLU) layers. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            785
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The blocks $\\left( f _ { \\theta } , g _ { \\theta } \\right)$ are shared across all pairs and depths, giving it the flexibility to deal with variable size inputs and significantly reduce the number of parameters to learn. ",
+        "bbox": [
+            173,
+            791,
+            823,
+            820
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Upscale and Decode After $T = \\log _ { 2 } K$ fusion layers, the final low-resolution encoded state $s _ { i } ^ { T }$ contains information from all $K$ input views. Any information of a spatial location that was initially missing from $L R _ { i }$ , is now encoded implicitly in $s _ { i } ^ { T }$ . $T$ is called the depth of HighRes-net. Only then, $s _ { i } ^ { T }$ is upsampled with a deconvolutional layer ( $\\mathrm { { X u } }$ et al., 2014) to a higher-resolution space $s _ { H R } ^ { T } \\in \\dot { \\mathbb { R } } ^ { C _ { h } \\times \\gamma W \\times \\gamma H }$ . The hidden high-resolution encoded state $s _ { H R } ^ { T }$ is eventually convolved with a $1 \\times 1$ 2D kernel to produce a final super-resolved image $S R ^ { \\theta } \\in \\bar { \\mathbb { R } ^ { C \\times \\gamma W \\times \\gamma H } }$ . ",
+        "bbox": [
+            173,
+            835,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/2da5cd799cda4ada5a8f1231723d647c1af6bd186e40b14a471878e403e09943.jpg",
+        "image_caption": [
+            "Figure 4: HighRes-net’s global fusion operator consists of a co-registration $g _ { \\theta }$ and a fusion $f _ { \\theta }$ block which aligns and combines two representations into a single representation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            101,
+            774,
+            198
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The overall architecture of HighRes-net is summarized in Figure 3(a) and the pseudocode for the forward pass is given in Algorithm 1. ",
+        "bbox": [
+            174,
+            273,
+            823,
+            303
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: HighRes-net forward pass ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            324,
+            441,
+            339
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/3a651b4ba44461cfd44f5d6a812803492ae264099b545f3454214425f1050396.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Input: low-res views LR1 ...LRk&#x27;</td></tr><tr><td>1 (LR1...LRK,α1...αk)← pad(LR1...LRκ&#x27;) // pad inputs to next power of 2</td></tr><tr><td>2 s ← encode(LRi) // parallelized across 1...K</td></tr><tr><td></td></tr><tr><td>3 T←log2K // fusion depth 4k←K</td></tr><tr><td>5 fort = 1...Tdo</td></tr><tr><td>6 fori = 1...k/2do t-1</td></tr><tr><td>st← fuse s-i， 7 Qk-i) // fuse encoded views 8 k=k/2</td></tr><tr><td>9 SR ← decode(sT)</td></tr><tr><td>Output: super-resolved view SR</td></tr></table>",
+        "bbox": [
+            176,
+            343,
+            813,
+            527
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 REGISTRATION MATTERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            574,
+            415,
+            589
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Co-registration matters for fusion. HighRes-net learns to implicity co-register multiple lowresolution views $L R _ { i }$ and fuse them into a single super resolved image $S R _ { \\theta }$ . ",
+        "bbox": [
+            173,
+            606,
+            821,
+            635
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A more explicit registration-at-the-loss can also be used for measuring similarity metrics and distances between $S R _ { \\theta }$ and $H R$ . Indeed, training HighRes-Net alone, by minimizing a reconstruction error such as the mean-squared error between $S R _ { \\theta }$ and $H R$ , leads to blurry outputs, since the neural network has to compensate for pixel and sub-pixel misalignments between its output $S R _ { \\theta }$ and $H R$ . ",
+        "bbox": [
+            174,
+            641,
+            825,
+            698
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here, we present ShiftNet-Lanczos, a neural network that can be paired with HighRes-net to account for pixel and sub-pixel shifts in the loss, as depicted in Figure 3(b). Our ablation study A.2 and qualitative visual analysis suggest that this strategy helps HighRes-net learn to super-resolve and leads to clearly improved results. ",
+        "bbox": [
+            174,
+            704,
+            825,
+            760
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 SHIFTNET-LANCZOS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            780,
+            359,
+            795
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "ShiftNet learns to align a pair of images with sub-pixel translations. ShiftNet registers pairs of images by predicting two parameters defining a global translation. Once a sub-pixel translation is found for a given pair of images, it is applied through a Lanczos shift kernel to align the images. ",
+        "bbox": [
+            174,
+            808,
+            825,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "ShiftNet The architecture of ShiftNet is adapted from HomographyNet (DeTone et al., 2016). Translations are a special case of homographies. In this sense, ShiftNet is simply a special case of HomographyNet, predicting 2 shift parameters instead of 8 homography parameters. See Appendix A.3, for details on the architecture of ShiftNet. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/73db354f5cca89b2ceab5bb8dbfcdfada06bbe9e32ed16efbff32b443321d3ad.jpg",
+        "table_caption": [
+            "Algorithm 2: Sub-pixel registered loss through ShiftNet-Lanczos "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Input: SRθ, HR</td><td>// super-resolved view, high-resolution ground-truth</td></tr><tr><td>1 (△x,△y)← ShiftNet (SRe,HR)</td><td>// register SR to HR</td></tr><tr><td>2 κ△ ← LanczosShiftKernel(△)</td><td>// 1D Lanczos kernels for x and y sub-pixel shifts</td></tr><tr><td>3 SRθ,△ ← SRθ * K△x * K△y</td><td>// 2D sub-pixel shift by separable 1D convolutions</td></tr><tr><td></td><td>// sub-pixel registered loss</td></tr><tr><td>4 lθ,△ ← loss(SRθ,△,HR) Output: lθ,△</td><td></td></tr></table>",
+        "bbox": [
+            178,
+            127,
+            815,
+            243
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "One major difference from HomographyNet is the way we train ShiftNet: In (DeTone et al., 2016), HomographyNet is trained on synthetically transformed data, supervised with ground-truth homography matrices. In our setting, ShiftNet is trained to cooperate with HighRes-net, towards the common goal of MFSR (see section Objective function below). ",
+        "bbox": [
+            173,
+            273,
+            825,
+            330
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Lanczos shift & interpolation kernel To shift and align an image by a sub-pixel amount, it must be convolved with a filter that shifts for the integer parts and interpolates for the fractional parts of the translation. Standard options for interpolation include the nearest-neighbor, sinc, bilinear, bicubic, and Lanczos filters (Turkowski, 1990). The sinc filter has an infinite support as opposed to any digital signal, so in practice it produces ringing or ripple artifacts — an example of the Gibbs phenomenon. The nearest-neighbor and bilinear filters do not induce ringing, but strongly attenuate the higher-frequency components (over-smoothing), and can even alias the image. The Lanczos filter reduces the ringing significantly by using only a finite part of the since (up to a few lobes from the origin). Experimentally, we found the Lanczos filter to perform the best. ",
+        "bbox": [
+            173,
+            344,
+            825,
+            472
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Objective function In our setting, registration benefits super-resolution. HighRes-net receives more informative gradient signals when its output is aligned with the ground truth high-resolution image. Conversely, super-resolution benefits registration, since good features are key to align images (Clement et al., 2018). We thus trained HighRes-Net and ShiftNet-Lanczos in a cooperative setting, where both neural networks work together to minimize an objective function, as opposed to an adversarial setting where a generator tries to fool a discriminator. HighRes-net infers a latent superresolved variable and ShiftNet maximises its similarity to a ground truth high-resolution image with sub-pixel shifts. ",
+        "bbox": [
+            173,
+            486,
+            825,
+            598
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "By predicting and applying sub-pixel translations in a differentiable way, our approach for registration and super-resolution can be combined in an end-to-end learning framework. Shift-Net predicts a sub-pixel shift $\\Delta$ from a pair of high-resolution images. The predicted transformation is applied with Lanczos interpolation to align the two images at a pixel level. ShiftNet and HighRes-Net are trained jointly to minimize a common loss function, using backpropagation and stochastic gradient descent. Our objective function is composed of a registered reconstruction loss computed as in Algorithm 2. In our case, we used the corrected clear PSNR metric (cPSNR), chosen by ESA, which is a variant of the mean squared error, designed to correct for brightness and clouds in satellite images (Martens et al. ¨ , 2019), but the proposed architecture is decoupled from the choice of loss. ",
+        "bbox": [
+            173,
+            604,
+            825,
+            729
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "See Algorithm 4 for the pseudo-code for computing the alignment loss $\\ell _ { \\theta , \\Delta }$ . We further regularize the L2 norm of ShiftNet’s ouput with a hyperparameter $\\lambda$ and our final joint objective is given by: ",
+        "bbox": [
+            173,
+            737,
+            823,
+            765
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/16a704395ed4a96b1e11cfa0ee1c73f0a2b92f9301a48fa677ebc29e1c8bb36e.jpg",
+        "text": "$$\nL _ { \\theta , \\Delta } ( S R _ { \\theta } , H R ) = \\ell _ { \\theta , \\Delta } + \\lambda | | \\Delta | | _ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            772,
+            619,
+            790
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS AND RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            809,
+            446,
+            824
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Prior SR work has focused on super-resolving low-res images that are artificially generated by simple bilinear down-sampling, (Bulat et al., 2018) The PROBA-V satellite has separate cameras onboard for capturing high-res / low-res pairs. As far as we know, the PROBA-V dataset is the first publicly available dataset for MFSR that contains naturally occurring low-res and high-res pairs. This is in contrast to most of the work in SR (SISR, MFSR, Video SR, Stereo SR) that synthetically down-sample high-res images and frames (Wang et al., 2019c; Nah et al., 2019). Methods that are trained on artificially downscaled datasets fail to produce good results when applied to real-world low-resolution, low quality images (Shocher et al., 2018). For this reason, we experiment only on PROBA-V, a dataset that does not suffer from biases induced by artificial down-sampling. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 PROBA-V KELVIN DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            162,
+            405,
+            176
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The performance of our method is illustrated with satellite imagery from the Kelvin competition, organized by ESA’s Advanced Concept Team (ACT). ",
+        "bbox": [
+            171,
+            188,
+            823,
+            217
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The Proba-V Kelvin dataset (Martens et al. ¨ , 2019) contains 1450 scenes (RED and NIR spectral bands) from 74 hand-selected Earth regions around the globe at different points in time. The scenes are split into 1160 scenes for training and 290 scenes for testing. Each data-point consists of exactly one $1 0 0 \\mathrm { m }$ resolution image as $3 8 4 \\times 3 8 4$ grey-scale pixel images (HR) and several $3 0 0 \\mathrm { m }$ resolution images from the same scene as $1 2 8 \\times 1 2 8$ grey-scale pixel images (LR), spaced days apart. We refer the reader to the Proba-V manual (Wolters et al., 2014) for further details on image acquisition. ",
+        "bbox": [
+            174,
+            223,
+            823,
+            308
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Each scene comes with at least 9 low-res views, and an average of 19. Each view comes with a noisy quality map. The quality map is a binary map, that indicates concealed pixels due to volatile features, such as clouds, cloud shadows, ice, water and snow. The sum of clear pixels (1s in the binary mask) is defined as the clearance of a low-res view. These incidental and noisy features can change fundamental aspects of the image, such as the contrast, brightness, illumination and landscape features. We use the clearance scores to randomly sample from the imageset of low-res views, such that views with higher clearance are more likely to be selected. This strategy helps to prevent overfitting. See Appendix A.4 for more details. ",
+        "bbox": [
+            174,
+            314,
+            825,
+            426
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Working with missing or noisy values A quality map can be used as a binary mask to indicate noisy or occluded pixels, due to clouds, snow, or other volatile objects. Such a mask can be fed as an additional input channel in the respective low-res view, in the same fashion as thereference frame. When missing value masks are available, neural networks can learn which parts of the input are anomalous, noisy, or missing, when provided with such binary masks (see e.g. Che et al. (2018)). In satellite applications where clouds masks are not available, other segmentation methods would be in order to infer such masks as a preprocessing step (e.g. Long et al. (2015)). In the case of the PROBA-V dataset, we get improved results when we make no use of the masks provided. Instead we use the masks only to inform the sampling scheme within the low-res imageset to prevent overfitting. ",
+        "bbox": [
+            174,
+            441,
+            825,
+            566
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            583,
+            315,
+            598
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Across all experiments, we used the same hyperparameters, reported in Appendix A.1. By default, each imageset is padded to 32 views for training and testing, unless specified otherwise. Our pytorch implementation requires less than 9h of training on a single NVIDIA V100 GPU. At test time, superresolving an imageset of size $1 2 8 \\mathrm { x } 1 2 8$ by a factor of 3, takes less than 0.2 seconds. Our code is made available on github1. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            679
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We evaluated different models on ESA’s Kelvin competition. Our best model, HighRes-Net trained jointly with shiftNet-Lanczos, scored consistently at the top of the public and final leaderboard, see Table 1. In the following, we discuss several baselines and report our experiments. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            728
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 COMPARISONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            746,
+            316,
+            760
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• ESA baseline upsamples each low-resolution view separately with bicubic up-sampling and averages those of maximum clearance.   \n• SRResNet (Ledig et al., 2017) is a deep learning SISR baseline.   \nSRResNet- $1 +$ shiftNet was trained with ShiftNet.   \n• SRResNet- $^ { 6 + }$ shiftNet differs from the previous model during test time only. It independently upsamples 6 low-resolution views with SRResNet-1, co-registers the super-resolved images using shiftNet, and averages the 6 aligned super-resolved images into a final prediction.   \nACT baseline (Martens et al. ¨ , 2019) is a Convolutional Neural Network with five fixed channels for the five clearest low-resolution views.   \nDeepSUM baseline (Molini et al., 2019) can be seen as a variant of SRResNet- $\\cdot 6 +$ shiftNet. Multiple low-res views are independently upsampled, then co-registered and fused into a single image.   \n• HighRes-net $^ +$ shiftNet are described in sections 3 and 4. Upsampling is done in the last step as opposed to (Molini et al., 2019).   \n• Ensemble An ensemble of two trained (HighRes-net $^ +$ shiftNet) models, one with ${ \\mathrm { K } } { = } 1 6$ and one with ${ \\mathrm { K } } { = } 3 2$ input views, whose outputs are averaged. ",
+        "bbox": [
+            173,
+            767,
+            825,
+            902
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            191
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 ESA KELVIN LEADERBOARD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            208,
+            415,
+            222
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The Kelvin competition used the corrected clear PSNR (cPSNR) quality metric as the standardized measure of performance. The cPSNR is a variant of the Peak Signal to Noise Ratio (PSNR) used to compensate for pixel-shifts and brightness bias. We refer the reader to (Martens et al. ¨ , 2019) for the motivation and derivation of this quality metric. The cPSNR metric is normalized by the score of the ESA baseline algorithm so that a score smaller than 1 means “better than the baseline” and lower is better. We also use it as our training objective with sub-pixel registration (see also section 3(b) on ShiftNet). ",
+        "bbox": [
+            174,
+            233,
+            825,
+            332
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/04649dbc99fb9940f454d04feca04dbe00fd9a6dfadc14377f69db9b33a22593.jpg",
+        "table_caption": [
+            "Table 1: Public and final leaderboard scores for the ESA’s Kelvin competition. Lower score means a better reconstruction. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Public score</td><td>Final score</td></tr><tr><td>SRResNet (Ledig et al., 2017)</td><td>1.0095</td><td>1.0084</td></tr><tr><td>ESA baseline</td><td>1.0000</td><td>1.0000</td></tr><tr><td>SRResNet-1+ shiftNet</td><td>1.0002</td><td>0.9995</td></tr><tr><td>ACT baseline (Märtens et al., 2019)</td><td>0.9874</td><td>0.9879</td></tr><tr><td>SRResNet-6+ shiftNet</td><td>0.9808</td><td>0.9794</td></tr><tr><td>HighRes-net + shiftNet (ours)</td><td>0.9496</td><td>0.9488</td></tr><tr><td>HighRes-net+ shiftNet Ensemble (ours)</td><td>0.94738</td><td>0.94774</td></tr><tr><td>DeepSUM (Molini et al., 2019)</td><td>0.94884</td><td>0.94744</td></tr></table>",
+        "bbox": [
+            258,
+            385,
+            738,
+            517
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4.1 ABLATION STUDY",
+        "text_level": 1,
+        "bbox": [
+            174,
+            544,
+            352,
+            558
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We further ran an ablation study on the available labeled data (1450 image sets), split in $9 0 \\% / \\ 1 0 \\%$ for training and testing. Our results suggest that more low-resolution views benefit the reconstruction error, plateuing after 16 views, see Appendix A.2. Another finding is that registration matters for MFSR, both in co-registering low-res views, and registering-at-the-loss, see Appendix A.3. Finally, selecting the $k$ clearest views for fusion can lead to ovefitting. One remedy is to randomly sample the views with a bias for clearance, see A.4. ",
+        "bbox": [
+            173,
+            568,
+            825,
+            651
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            671,
+            310,
+            688
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.1 THE IMPORTANCE OF GROUNDED DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            702,
+            508,
+            715
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The PROBA-V satellite (Dierckx et al., 2014) was launched by ESA to monitor Earth’s vegetation growth, water resources and agriculture. As a form of data fusion and enrichment, multi-frame super-resolution could enhance the vision of such satellites for scientific and monitoring applications (Carlson & Ripley, 1997; Pettorelli et al., 2005). More broadly, satellite imagery can help NGOs and non-profits monitor the environment and human rights (Cornebise et al., 2018; Helber et al., 2018; Rudner et al., 2019; Rolnick et al., 2019) at scale, from space, ultimately contributing to the UN sustainable development goals. Low-resolution imagery is cheap or sometimes free, and it is frequently updated. However, with the addition of fake or imaginary details, such enhancement wouldn’t be valuable as scientific, legal, or forensic evidence. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            853
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.2 FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            318,
+            883
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Registration matters at the loss stage but also at the fusion stage. The latter is not explicit in our model and the reason why and how it works is less understood. Learning to sample a reference frame and learning to fuse multiple representations with attention could also be a promising approach to extend HighRes-net. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ensuring authenticity of detail is a major challenge and quantifying uncertainty of super-resolved images is an important line of future work for real world applications. Along this line of research, the question of how to evaluate a super-resolved image is important for downstream tasks and, more generally, similarity metrics remain an open question for many computer visions tasks (Bruna et al., 2015; Johnson et al., 2016; Isola et al., 2017; Ledig et al., 2017). ",
+        "bbox": [
+            174,
+            138,
+            825,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6.3 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            226,
+            308,
+            239
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we presented HighRes-net – the first deep learning approach to multi-frame superresolution that learns typical sub-tasks of MFSR in an end-to-end fashion: (i) co-registration, (ii) fusion, (iii) up-sampling, and (iv) registration-at-the-loss. ",
+        "bbox": [
+            174,
+            252,
+            825,
+            294
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "It recursively fuses a variable number of low-resolution views by learning a global fusion operator. The overall fusion also aligns all low-resolution views with an implicit co-registration mechanism through the reference channel. We also introduced ShiftNet-Lanczos, a network that learns to register and align the super-resolved output of HighRes-net with a high-resolution ground-truth. ",
+        "bbox": [
+            174,
+            301,
+            823,
+            356
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Registration is important both to align multiple low-resolution inputs (co-registration) and to compute similarity metrics between shifted signals. Our experiments suggest that an end-to-end cooperative setting (HighRes-net $^ +$ ShiftNet-Lanczos) helps with training and test performance. By design, our approach is fast to train, faster to test, and low in terms of memory-footprint by doing the bulk of the computational work (co-registration $^ +$ fusion) on multiple images while maintaining their low-resolution height & width. ",
+        "bbox": [
+            174,
+            363,
+            823,
+            446
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "There is an ongoing proliferation of low-resolution yet high-revisit low-cost satellite imagery, but they often lack the detailed information of expensive high-resolution imagery. We believe MFSR can raise its potential to NGOs and non-profits that contribute to the UN Sunstainable Development Goals. ",
+        "bbox": [
+            174,
+            454,
+            825,
+            510
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Joan Bruna, Pablo Sprechmann, and Yann LeCun. Super-resolution with deep convolutional sufficient statistics. arXiv preprint arXiv:1511.05666, 2015. ",
+        "bbox": [
+            173,
+            125,
+            823,
+            151
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adrian Bulat, Jing Yang, and Georgios Tzimiropoulos. To learn image super-resolution, use a gan to learn how to do image degradation first. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 185–200, 2018. ",
+        "bbox": [
+            173,
+            159,
+            823,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Capel and Andrew Zisserman. Super-resolution from multiple views using learnt image models. In Proceedings of the 2001 IEEE Computer Society Conference on Computer Vision and Pattern Recognition. CVPR 2001, volume 2, pp. II–II. IEEE, 2001. ",
+        "bbox": [
+            174,
+            207,
+            823,
+            246
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Toby N Carlson and David A Ripley. On the relation between ndvi, fractional vegetation cover, and leaf area index. Remote sensing of Environment, 62(3):241–252, 1997. ",
+        "bbox": [
+            171,
+            253,
+            823,
+            280
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tony F Chan and Chiu-Kwong Wong. Total variation blind deconvolution. IEEE transactions on Image Processing, 7(3):370–375, 1998. ",
+        "bbox": [
+            173,
+            287,
+            823,
+            315
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hong Chang, Dit-Yan Yeung, and Yimin Xiong. Super-resolution through neighbor embedding. In Proceedings of the 2004 IEEE Computer Society Conference on Computer Vision and Pattern Recognition, 2004. CVPR 2004., volume 1, pp. I–I. IEEE, 2004. ",
+        "bbox": [
+            173,
+            321,
+            825,
+            362
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhengping Che, Sanjay Purushotham, Kyunghyun Cho, David Sontag, and Yan Liu. Recurrent neural networks for multivariate time series with missing values. Scientific reports, 8(1):6085, 2018. ",
+        "bbox": [
+            171,
+            369,
+            823,
+            397
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Colin B Clement, Matthew Bierbaum, and James P Sethna. Image registration and super resolution from first principles. arXiv preprint arXiv:1809.05583, 2018. ",
+        "bbox": [
+            171,
+            405,
+            823,
+            433
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Julien Cornebise, Daniel Worrall, Micah Farfour, and Milena Marin. Witnessing atrocities: Quantifying villages destruction in darfur with crowdsourcing and transfer learning. In AI for Social Good NIPS2018 Workshop, Montreal, Canada ´ , 2018. ",
+        "bbox": [
+            173,
+            439,
+            823,
+            479
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel DeTone, Tomasz Malisiewicz, and Andrew Rabinovich. Deep image homography estimation. arXiv preprint arXiv:1606.03798, 2016. ",
+        "bbox": [
+            173,
+            486,
+            823,
+            513
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wouter Dierckx, Sindy Sterckx, Iskander Benhadj, Stefan Livens, Geert Duhoux, Tanja Van Achteren, Michael Francois, Karim Mellab, and Gilbert Saint. Proba-v mission for global vegetation monitoring: standard products and image quality. International Journal of Remote Sensing, 35(7):2589–2614, 2014. ",
+        "bbox": [
+            174,
+            521,
+            821,
+            561
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chao Dong, Chen Change Loy, Kaiming He, and Xiaoou Tang. Learning a deep convolutional network for image super-resolution. In European conference on computer vision, pp. 184–199. Springer, 2014. ",
+        "bbox": [
+            173,
+            569,
+            823,
+            597
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "K Eric Drexler. Reframing superintelligence: Comprehensive ai services as general intelligence, 2019. ",
+        "bbox": [
+            176,
+            603,
+            782,
+            618
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sina Farsiu, M Dirk Robinson, Michael Elad, and Peyman Milanfar. Fast and robust multiframe super resolution. IEEE transactions on image processing, 13(10):1327–1344, 2004. ",
+        "bbox": [
+            173,
+            626,
+            821,
+            654
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "J Michael Fitzpatrick, Derek LG Hill, Calvin R Maurer, et al. Image registration. Handbook of medical imaging, 2:447–513, 2000. ",
+        "bbox": [
+            173,
+            660,
+            823,
+            688
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "William T Freeman, Thouis R Jones, and Egon C Pasztor. Example-based super-resolution. IEEE Computer graphics and Applications, 22(2):56–65, 2002. ",
+        "bbox": [
+            171,
+            695,
+            823,
+            722
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Theresa L. Harris, Jonathan Drake, Jessica M. Wyndham, Susan R. Wolfinbarger, Stephen D. Lott, and Michael Lerner. Geospatial evidence in international human rights litigation: Technical and legal considerations. Technical report, AAAS Scientific Responsibility, Human Rights and Law Program, 2018. ",
+        "bbox": [
+            176,
+            729,
+            823,
+            770
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing humanlevel performance on imagenet classification. In Proceedings of the 2015 IEEE International Conference on Computer Vision (ICCV), ICCV ’15, pp. 1026–1034, Washington, DC, USA, 2015. IEEE Computer Society. ISBN 978-1-4673-8391-2. doi: 10.1109/ICCV.2015.123. URL http://dx.doi.org/10.1109/ ICCV.2015.123. ",
+        "bbox": [
+            173,
+            777,
+            825,
+            842
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            174,
+            849,
+            823,
+            877
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Patrick Helber, Bradley Gram-Hansen, Indhu Varatharajan, Faiza Azam, Alejandro Coca-Castro, Veronika Kopackova, and Piotr Bilinski. Mapping informal settlements in developing countries with multi-resolution, multi-spectral data. arXiv preprint arXiv:1812.00812, 2018. ",
+        "bbox": [
+            176,
+            885,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michal Irani and Shmuel Peleg. Improving resolution by image registration. CVGIP: Graphical models and image processing, 53(3):231–239, 1991. ",
+        "bbox": [
+            173,
+            104,
+            823,
+            131
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1125–1134, 2017. ",
+        "bbox": [
+            174,
+            138,
+            821,
+            179
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Jensen and Jillian Campbell. The promise and peril of a digital ecosystem for the planet, September 2019. URL https://medium.com/@davidedjensen 99356/building-a-digitalecosystem-for-the-planet-557c41225dc2. [Online; posted 11-September-2019]. ",
+        "bbox": [
+            174,
+            186,
+            823,
+            227
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and superresolution. In European conference on computer vision, pp. 694–711. Springer, 2016. ",
+        "bbox": [
+            174,
+            234,
+            820,
+            262
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Michal Kawulok, Pawel Benecki, Krzysztof Hrynczenko, Daniel Kostrzewa, Szymon Piechaczek, Jakub Nalepa, and Bogdan Smolka. Deep learning for fast super-resolution reconstruction from multiple images. In Real-Time Image Processing and Deep Learning 2019, volume 10996, pp. 109960B. International Society for Optics and Photonics, 2019. ",
+        "bbox": [
+            173,
+            268,
+            825,
+            320
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jiwon Kim, Jung Kwon Lee, and Kyoung Mu Lee. Deeply-recursive convolutional network for image superresolution. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1637– 1645, 2016. ",
+        "bbox": [
+            174,
+            330,
+            821,
+            369
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kwang In Kim and Younghee Kwon. Single-image super-resolution using sparse regression and natural image prior. IEEE transactions on pattern analysis and machine intelligence, 32(6):1127–1133, 2010. ",
+        "bbox": [
+            171,
+            377,
+            823,
+            405
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            412,
+            821,
+            439
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Ledig, Lucas Theis, Ferenc Huszar, Jose Caballero, Andrew Cunningham, Alejandro Acosta, Andrew ´ Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, et al. Photo-realistic single image super-resolution using a generative adversarial network. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4681–4690, 2017. ",
+        "bbox": [
+            173,
+            448,
+            825,
+            500
+        ],
+        "page_idx": 11
+    },
+    {
+        "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,
+            507,
+            820,
+            535
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Robert J II Marks. Introduction to Shannon sampling and interpolation theory. Springer Science & Business Media, 2012. ",
+        "bbox": [
+            173,
+            542,
+            821,
+            570
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Marcus Martens, Dario Izzo, Andrej Krzic, and Dani ¨ el Cox. Super-resolution of proba-v images using convo-¨ lutional neural networks. Astrodynamics, 3(4):387–402, Dec 2019. ",
+        "bbox": [
+            173,
+            578,
+            821,
+            606
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrea Bordone Molini, Diego Valsesia, Giulia Fracastoro, and Enrico Magli. Deepsum: Deep neural network for super-resolution of unregistered multitemporal images. arXiv preprint arXiv:1907.06490, 2019. ",
+        "bbox": [
+            171,
+            613,
+            823,
+            641
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Seungjun Nah, Radu Timofte, Sungyong Baik, Seokil Hong, Gyeongsik Moon, Sanghyun Son, and Kyoung Mu Lee. Ntire 2019 challenge on video deblurring: Methods and results. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pp. 0–0, 2019. ",
+        "bbox": [
+            176,
+            648,
+            825,
+            688
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nhat Nguyen, Peyman Milanfar, and Gene Golub. A computationally efficient superresolution image reconstruction algorithm. IEEE transactions on image processing, 10(4):573–583, 2001. ",
+        "bbox": [
+            173,
+            695,
+            821,
+            723
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Harry Nyquist. Certain topics in telegraph transmission theory. Transactions of the American Institute of Electrical Engineers, 47(2):617–644, 1928. ",
+        "bbox": [
+            173,
+            731,
+            823,
+            758
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Athanasios Papoulis. Generalized sampling expansion. IEEE transactions on circuits and systems, 24(11): 652–654, 1977. ",
+        "bbox": [
+            171,
+            766,
+            823,
+            794
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nathalie Pettorelli, Jon Olav Vik, Atle Mysterud, Jean-Michel Gaillard, Compton J Tucker, and Nils Chr Stenseth. Using the satellite-derived ndvi to assess ecological responses to environmental change. Trends in ecology & evolution, 20(9):503–510, 2005. ",
+        "bbox": [
+            173,
+            801,
+            825,
+            842
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lyndsey C Pickup, Stephen J Roberts, and Andrew Zisserman. Optimizing and learning for super-resolution. In BMVC, volume 9, pp. 4–7. Citeseer, 2006. ",
+        "bbox": [
+            173,
+            849,
+            823,
+            876
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Rolnick, Priya L Donti, Lynn H Kaack, Kelly Kochanski, Alexandre Lacoste, Kris Sankaran, Andrew Slavin Ross, Nikola Milojevic-Dupont, Natasha Jaques, Anna Waldman-Brown, et al. Tackling climate change with machine learning. arXiv preprint arXiv:1906.05433, 2019. ",
+        "bbox": [
+            174,
+            885,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tim GJ Rudner, Marc Rußwurm, Jakub Fil, Ramona Pelich, Benjamin Bischke, Veronika Kopackov ˇ a, and ´ Piotr Bilinski. Multi3net: Segmenting flooded buildings via fusion of multiresolution, multisensor, and ´ multitemporal satellite imagery. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 702–709, 2019.   \nMehdi SM Sajjadi, Raviteja Vemulapalli, and Matthew Brown. Frame-recurrent video super-resolution. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 6626–6634, 2018.   \nEduardo Sanchez, Mathieu Serrurier, and Mathias Ortner. Learning disentangled representations of satellite image time series. arXiv preprint arXiv:1903.08863, 2019.   \nClaude Elwood Shannon. Communication in the presence of noise. Proceedings of the IRE, 37(1):10–21, 1949.   \nAssaf Shocher, Nadav Cohen, and Michal Irani. zero-shot super-resolution using deep internal learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3118–3126, 2018.   \nRupesh Kumar Srivastava, Klaus Greff, and Jurgen Schmidhuber. Highway networks. ¨ arXiv preprint arXiv:1505.00387, 2015.   \nXin Tao, Hongyun Gao, Renjie Liao, Jue Wang, and Jiaya Jia. Detail-revealing deep video super-resolution. In Proceedings of the IEEE International Conference on Computer Vision, pp. 4472–4480, 2017.   \nRadu Timofte, Shuhang Gu, Jiqing Wu, Luc Van Gool, Lei Zhang, Ming-Hsuan Yang, Muhammad Haris, et al. Ntire 2018 challenge on single image super-resolution: Methods and results. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR) Workshops, June 2018.   \nRY Tsai. Multiple frame image restoration and registration. Advances in Computer Vision and Image Processing, 1:1715–1984, 1984.   \nKen Turkowski. Filters for common resampling tasks. In Graphics gems, pp. 147–165. Academic Press Professional, Inc., 1990.   \nOriol Vinyals, Samy Bengio, and Manjunath Kudlur. Order matters: Sequence to sequence for sets. arXiv preprint arXiv:1511.06391, 2015.   \nLongguang Wang, Yingqian Wang, Zhengfa Liang, Zaiping Lin, Jungang Yang, Wei An, and Yulan Guo. Learning parallax attention for stereo image super-resolution. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 12250–12259, 2019a.   \nXintao Wang, Kelvin CK Chan, Ke Yu, Chao Dong, and Chen Change Loy. Edvr: Video restoration with enhanced deformable convolutional networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pp. 0–0, 2019b.   \nYingqian Wang, Longguang Wang, Jungang Yang, Wei An, and Yulan Guo. Flickr1024: A large-scale dataset for stereo image super-resolution. In Proceedings of the IEEE International Conference on Computer Vision Workshops, pp. 0–0, 2019c.   \nZhihao Wang, Jian Chen, and Steven CH Hoi. Deep learning for image super-resolution: A survey. arXiv preprint arXiv:1902.06068, 2019d.   \nErwin Wolters, Wouter Dierckx, J Dries, and Else Swinnen. Proba-v products user manual. VITO. http://probav. vgt. vito. be/sites/default/files/Product User Manual. pdf, 2014.   \nLi Xu, Jimmy SJ Ren, Ce Liu, and Jiaya Jia. Deep convolutional neural network for image deconvolution. In Advances in Neural Information Processing Systems, pp. 1790–1798, 2014.   \nBo Yan, Chuming Lin, and Weimin Tan. Frame and feature-context video super-resolution. arXiv preprint arXiv:1909.13057, 2019.   \nJianchao Yang, John Wright, Thomas S Huang, and Yi Ma. Image super-resolution via sparse representation. IEEE transactions on image processing, 19(11):2861–2873, 2010.   \nRoman Zeyde, Michael Elad, and Matan Protter. On single image scale-up using sparse-representations. In International conference on curves and surfaces, pp. 711–730. Springer, 2010. ",
+        "bbox": [
+            169,
+            46,
+            826,
+            871
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.1 EXPERIMENTAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            136,
+            392,
+            150
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We trained our models on low-resolution patches of size 64x64. HighRes-net’s architecture is reported in Table 3. We denote by Conv2d(in, out, k, s, p) a conv2D layer with in and out input/output channels, kernel of size $^ { ( \\mathrm { k } , \\mathrm { k } ) }$ , stride (s,s) and padding p. We used the ADAM optimizer (Kingma & Ba, 2014) with default hyperparameters and trained our models on batches of size 32, for 400 epochs, using $90 \\%$ of the data for training and $10 \\%$ for validation. Our learning rate is initialized to 0.0007, decayed by a factor of 0.97 if the validation loss plateaus for more than 2 epochs. For the regularization of shiftNet, we employed $\\lambda = 0 . 0 0 0 0 0 1$ . ",
+        "bbox": [
+            173,
+            162,
+            825,
+            261
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/4de2709200fc00f79982266fabf2b69c50ae789c5911e307baef5e9600f92147.jpg",
+        "table_caption": [
+            "Table 2: ResidualBlock(h) architecture "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>layerO layer1 layer2 layer3</td><td>Conv2d(in=h,out=h,k3,s1,p1) PReLU Conv2d(in=h,out=h,k3,s1, p1) PReLU</td></tr></table>",
+        "bbox": [
+            351,
+            308,
+            642,
+            367
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/c9896517ee6be3b35ddd7e40eff49deb890d10b177f8d3f7e827674ea5502567.jpg",
+        "table_caption": [
+            "Table 3: HRNet architecture "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Step</td><td>Layers</td><td>Number of params</td></tr><tr><td rowspan=\"4\">encode</td><td>Conv2d(in=2, out=64,k3,s1, p1)</td><td>1216</td></tr><tr><td>PReLU</td><td>1</td></tr><tr><td>ResidualBlock(64)</td><td>73858</td></tr><tr><td>ResidualBlock(64)</td><td>73858</td></tr><tr><td rowspan=\"3\">fuse</td><td>Conv2d(in=64,out=64,k3,s1, p1)</td><td>36928</td></tr><tr><td>ResidualBlock(128) Conv2d(in=128, out=64,k3, s1, p1)</td><td>295170</td></tr><tr><td>PReLU</td><td>73792 1</td></tr><tr><td rowspan=\"2\">decode</td><td>ConvTranspose2d(in=64,out=64,k3, s1) PreLU</td><td>36928</td></tr><tr><td>Conv2d(in=64,out=1,k1, s1)</td><td>1 65</td></tr><tr><td>residual (optional)</td><td>Upsample(scale_factor=3.0, mode=bicubic)</td><td>0</td></tr><tr><td></td><td></td><td>591818 (total)</td></tr></table>",
+        "bbox": [
+            202,
+            430,
+            790,
+            630
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Thanks to weight sharing, HighRes-net super-resolves scenes with 32 views in 5 recursive steps, while requiring less than 600K parameters. ShiftNet has more than 34M parameters (34187648) but is dropped during test time. We report GPU memory requirements in table 4 for reproducibility purposes. ",
+        "bbox": [
+            173,
+            654,
+            825,
+            710
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/e2c3913a584c31f81d2fd3c9402b563b508f376ee52b55020a4e7e1d2fa5cc16.jpg",
+        "table_caption": [
+            "Table 4: GPU memory requirements to train HighRes-net $^ +$ ShiftNet on patches of size $6 4 \\mathrm { x 6 4 }$ with batches of size 32, and a variable number of low-resolution frames. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td># views GPU memory (GB)</td><td>32 27</td><td>16 15</td><td>4 6</td></tr></table>",
+        "bbox": [
+            370,
+            771,
+            622,
+            803
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.2 HOW MANY FRAMES DO YOU NEED? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            840,
+            468,
+            854
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We trained and tested HighRes-net with ShiftNet using 1 to 32 frames. With a single image, our approach performs worse than the ESA baseline. Doubling the number of frames significantly improves both our training and validation scores. After 16 frames, our model’s performance stops increasing as show in Figure 5. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/4e7d47197ce6d9c764083126f46b2e6c722419fc57fa52c2620e750025708518.jpg",
+        "image_caption": [
+            "Figure 5: Public leaderboard scores vs. nviews for HighRes-net $^ +$ ShiftNet. Lower is better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            250,
+            130,
+            710,
+            366
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.3 REGISTRATION MATTERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            431,
+            393,
+            445
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Registered loss The only explicit registration that we perform is at the loss stage, to allow the model partial credit for a solution. This solution can be enhanced but otherwise mis-registered wrt to the ground truth. We trained our base model HighRes-net without ShiftNet-Lanczos and observed a drop in performance as shown in Table 5. Registration matters and aligning outputs with targets helps HighRes-net generate sharper outputs and achieve competitive results. ",
+        "bbox": [
+            173,
+            458,
+            825,
+            529
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/b799ce6179239f999ab6906c6b772c25053b5a6a655f79b2a381ff854794120b.jpg",
+        "table_caption": [
+            "Table 5: Registration matters: Train and validation scores for HighResNet trained with and without ShiftNet-Lanczos. Lower is better. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>HighRes-net +</td><td rowspan=1 colspan=1>train score</td><td rowspan=1 colspan=1>test score</td></tr><tr><td rowspan=1 colspan=1>w/o registrationShiftNet +Lanczos</td><td rowspan=1 colspan=1>0.96160.9501</td><td rowspan=1 colspan=1>0.96710.9532</td></tr></table>",
+        "bbox": [
+            336,
+            584,
+            656,
+            632
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Implicit co-registration The traditional practice in MFSR is to explicitly co-register the LR views prior to super-resolution (Tsai, 1984; Molini et al., 2019). The knowledge of sub-pixel missalignments tells an algorithm what pieces of information to fuse from each LR image for any pixel in the SR output. Contrary to the conventional practice in MFSR, we propose implicit co-registeration by pairing LR views with a reference frame a.k.a. anchor. In this sense, we never explicitly compute the relative shifts between any LR pair. Instead, we simply stack each view with a chosen reference frame as an additional channel to the input. We call this strategy implicit co-registration, We found this strategy to be effective in the following ablation study which addresses the impact of the choice of a reference frame aka anchor. ",
+        "bbox": [
+            173,
+            662,
+            825,
+            789
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We observe the median reference is the most effective in terms of train and test score. We suspect the median performs better than the mean because the median is more robust to outliers and can help denoise the LR views. Interestingly, training and testing without a shared reference performed worse than the ESA baseline. This shows that co-registration (implicit or explicit) matters. This can be due to the fact that the model lacks information to align and fuse the multiple views. ",
+        "bbox": [
+            174,
+            795,
+            825,
+            866
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "ShiftNet architecture ShitNet has 8 layers of (conv2D $^ +$ BatchNorm2d $^ +$ ReLU). Layer 2, 4 and 6 are followed by MaxPool2d. The final output is flattened to a vector $x$ of size 32768. Then, we compute a vector of size 1024, $x = \\operatorname { R e L U } ( \\operatorname { f c 1 } ( \\operatorname { d r o p o u t } ( x ) ) )$ . The final shift prediction is $\\operatorname { f c } 2 ( x )$ of size 2. The bulk of the parameters come from fc1, with $3 2 7 6 8 \\times 1 0 2 4$ weights. These alone, account for $9 9 \\%$ of ShiftNet’s parameters. Adding a MaxPool2d on top of layer 3, 5, 7 or 8 halves the parameters of ShiftNet. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/e34ef22d47b6abe39350fb248512db98eb12f7a133cd766c6efb84bd92e5b6de.jpg",
+        "table_caption": [
+            "Table 6: Train and validation scores for HighRes-net $^ +$ ShiftNet-Lanczos trained and tested with different references as input. Lower is better. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Reference</td><td>train score</td><td>test score</td></tr><tr><td>None (no co-registration)</td><td>1.0131</td><td>1.0088</td></tr><tr><td>Mean of 9 LRs</td><td>0.9636</td><td>0.9690</td></tr><tr><td>Median or 9 LRs (base)</td><td>0.9501</td><td>0.9532</td></tr></table>",
+        "bbox": [
+            316,
+            146,
+            676,
+            208
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            239,
+            825,
+            281
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.4 TOWARDS PERMUTATION INVARIANCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            299,
+            483,
+            314
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A desirable property of a fusion model acting on an un-ordered set of images, is permutationinvariance: the output of the model should be invariant to the order in which the LR views are fused. An easy approach to encourage permutation invariant neural networks is to randomly shuffle the inputs at training time before feeding them to a model (Vinyals et al., 2015). ",
+        "bbox": [
+            173,
+            324,
+            825,
+            381
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In addition to randomization, we still want to give more importance to clear LR views (with high clearance score), which can be done by sorting them by clearance. A good trade-off between uniform sampling and deterministic sorting by clearance, is to sample $k$ LR views without replacement and with a bias towards higher clearance: ",
+        "bbox": [
+            173,
+            387,
+            825,
+            444
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f22302f460a37dccd5e6d9a56e46c37cf1d97dfc628c747bcbb5338b53a78061.jpg",
+        "text": "$$\np ( i \\mid C _ { 1 } , \\ldots , C _ { k } ) = { \\frac { e ^ { \\beta C _ { i } } } { \\sum _ { j = 1 } ^ { k } e ^ { \\beta C _ { j } } } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            460,
+            609,
+            501
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "where $k$ is the total number of LR views, $C _ { i }$ is the clearance score of $\\mathrm { L R } _ { i }$ and $\\beta$ regulates the bias towards higher clearance scores, ",
+        "bbox": [
+            174,
+            502,
+            823,
+            531
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "When $\\beta = 0$ , this sampling strategy corresponds to uniform sampling and when $\\beta = + i n f$ , this corresponds to picking the $\\mathbf { k }$ -clearest views in a deterministic way. Our default model was trained with $\\beta = 5 0$ and our experiments are reported in Table 7. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            580
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/1f935f0a8710cf7a6091c56e394b7f96f75384097f08c6476da1e2d1a5fbb760.jpg",
+        "table_caption": [
+            "Table 7: Validation scores vs. nviews for HighRes-net $^ +$ ShiftNet. Lower is better. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Sampling strategy</td><td rowspan=1 colspan=1>train score</td><td rowspan=1 colspan=1>test score</td></tr><tr><td rowspan=1 colspan=1>β=∞ (k-clearest)β = 0 (uniform-k)β= 50 (base)</td><td rowspan=1 colspan=1>0.93860.96380.9501</td><td rowspan=1 colspan=1>0.96870.96750.9532</td></tr></table>",
+        "bbox": [
+            338,
+            625,
+            655,
+            686
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "From Table 7, $\\beta = \\infty$ reaches best training score and worst testing score. For $\\beta = 5 0$ and $\\beta = 0$ , the train/test gap is much more reduced. This suggests that the deterministic strategy is overfitting and randomness prevents overfitting (diversity matters). On the other hand, $\\beta = 5 0$ performs significantly better than $\\beta = 0$ suggesting that biasing a model towards higher clearances could be beneficial i.e., clouds matter too. ",
+        "bbox": [
+            173,
+            707,
+            825,
+            777
+        ],
+        "page_idx": 15
+    }
+]

parse/train/_89s8ViNwwj/_89s8ViNwwj.md

@@ -0,0 +1,269 @@
+# Parameterized Knowledge Transfer for Personalized Federated Learning
+
+Jie Zhang1, Song $\mathbf { G u o } ^ { 1 , * }$ , Xiaosong $\mathbf { M } \mathbf { a } ^ { 1 }$ , Haozhao Wang2, Wencao $\mathbf { X } \mathbf { u } ^ { 1 }$ , and Feijie $\mathbf { W } \mathbf { u } ^ { 1 }$
+
+1Department of Computing, The Hong Kong Polytechnic University 2Department of Computer Science and Technology, HUST {jieaa.zhang,harli.wu}@connect.polyu.hk, hz_wang@hust.edu.cn, {song.guo,xiaosma,wenchao.xu}@polyu.edu.hk
+
+# Abstract
+
+In recent years, personalized federated learning (pFL) has attracted increasing attention for its potential in dealing with statistical heterogeneity among clients. However, the state-of-the-art pFL methods rely on model parameters aggregation at the server side, which require all models to have the same structure and size, and thus limits the application for more heterogeneous scenarios. To deal with such model constraints, we exploit the potentials of heterogeneous model settings and propose a novel training framework to employ personalized models for different clients. Specifically, we formulate the aggregation procedure in original pFL into a personalized group knowledge transfer training algorithm, namely, KT-pFL, which enables each client to maintain a personalized soft prediction at the server side to guide the others’ local training. KT-pFL updates the personalized soft prediction of each client by a linear combination of all local soft predictions using a knowledge coefficient matrix, which can adaptively reinforce the collaboration among clients who own similar data distribution. Furthermore, to quantify the contributions of each client to others’ personalized training, the knowledge coefficient matrix is parameterized so that it can be trained simultaneously with the models. The knowledge coefficient matrix and the model parameters are alternatively updated in each round following the gradient descent way. Extensive experiments on various datasets (EMNIST, Fashion_MNIST, CIFAR-10) are conducted under different settings (heterogeneous models and data distributions). It is demonstrated that the proposed framework is the first federated learning paradigm that realizes personalized model training via parameterized group knowledge transfer while achieving significant performance gain comparing with state-of-the-art algorithms.
+
+# 1 Introduction
+
+Federated Learning (FL) [1] has emerged as an efficient paradigm to collaboratively train a shared machine learning model among multiple clients without directly accessing their private data. By periodically aggregating parameters from the clients for global model updating, it can converge to high accuracy and strong generalization. FL has shown its capability to protect user privacy while there remains a crucial challenge that significantly degrades the learning performance, i.e., statistic heterogeneity in users’ local datasets. Given the Non-Independent and Identically Distributed (Non-IID) user data, the trained global model often cannot be generalized well over each client [2–5].
+
+To deal with the above issues, employing personalized models appears to be an effective solution in FL, i.e., personalized federated learning (pFL). Recent works regarding pFL include regularizationbased methods [6–8] (i.e., pFedMe [6], L2SGD [7], FedAMP [8]), meta-learning-based Per-FedAvg [9] and cluster-based IFCA [10, 11]. However, in order to aggregate the parameters from all clients, it is inevitable for them to have identical model structure and size. Such constraints would prevent status quo pFL methods from further application in practical scenarios, where clients are often willing to own unique models, i.e., with customized neural architectures to adapt to heterogeneous capacities in computation, communication and storage space, etc. Motivated by the paradigm of Knowledge Distillation (KD) [12–16] that knowledge can be transferred from a neural network to another via exchanging soft predictions instead of using the whole model parameters, KD-based FL training methods have been studied [12, 14–19] to collaboratively train heterogeneous models in a privacy-preserving way. However, these works have neglected the further personalization requirement of FL clients, which can be well satisfied via the personalized knowledge transfer for heterogeneous FL users.
+
+In this paper, we seek to develop a novel training framework that can accommodate heterogeneous model structures for each client and achieve personalized knowledge transfer in each FL training round. To this end, we formulate the aggregation phase in FL to a personalized group knowledge transfer training algorithm dubbed KT-pFL, whose main idea is to allow each client to maintain a personalized soft prediction at the server that can be updated by a linear combination of all clients’ local soft predictions using a knowledge coefficient matrix. The principle of doing so is to reinforce the collaboration between clients with similar data distributions. Furthermore, to quantify the contribution of each client to other’s personalized soft prediction, we parameterize the knowledge coefficient matrix so that it can be trained simultaneously with the models following an alternating way in each iteration round.
+
+We show that KT-pFL not only breaks down the barriers of homogeneous model restriction, which requires to transfer the entire parameters set in each round, whose data volume is much larger than that of the soft prediction, but also improves the training efficiency by using a parameterized update mechanism. Experimental results on different datasets and models show that our method can significantly improve the training efficiency and reduce the communication overhead. Our contributions are:
+
+• To the best of our knowledge, this paper is the first to study the personalized knowledge transfer in FL. We propose a novel training framework, namely, KT-pFL, that maintains a personalized soft prediction for each client in the server to transfer knowledge among all clients. • To encourage clients with similar data distribution to collaborate with each other during the training process, we propose the ‘knowledge coefficient matrix’ to identify the contribution from one client to others’ local training. To show the efficiency of the parameterized method, we compared KT-pFL with two non-parameterized learning methods, i.e., TopK-pFL and Sim-pFL, which calculate the knowledge coefficient matrix on the cosine similarity between different model parameters. • We provide theoretical performance guarantee for KT-pFL and conduct extensive experiments over various deep learning models and datasets. The efficiency superiority of KT-pFL is demonstrated by comparing our proposed training framework with traditional pFL methods.
+
+# 2 Related Work
+
+Personalized FL with Homogeneous Models. Recently, various approaches have been proposed to realize personalized FL with homogeneous local model structure, which can be categorized into three types according to the number of global models applied in the server, i.e., single global model, multiple global models and no global model.
+
+single global model type is a close variety of conventional FL, e.g., FedAvg [1], that combine global model optimization process with additional local model customization, and consist of four different kinds of approaches: local fine-tuning [20–23], regularization (e.g., pFedMe [6], L2SGD [7, 24], Ditto [25]), hybrid local and global models [11, 26, 27] and meta learning [9, 28]. All of these pFL methods apply a single global model, and thus limit the customized level of the local model at the client side. Therefore, some researchers [8, 10, 11] propose to train multiple global models at the server, where clients are clustered into several groups according to their similarity and different models are trained for each group. FedAMP [8] and FedFomo [29] can be regarded as special cases of the clustered-based method that each client owns a personalized global model at the server side. As a contrast, some literature waive the global model to deal with the heterogeneity problem [30, 31], such as multi-task learning based (i.e., MOCHA [31]) and hypernetwork-based framework (i.e.,
+
+FedHN [30]). However, all these methods require aggregating the model parameters from the clients, who have to apply identical model structure and size, which hinders further personalization, e.g., employing personalized model architectures for heterogeneous clients is not feasible.
+
+Heterogeneous FL and Knowledge Distillation. To enable heterogeneous model architectures in FL, Diao et al. [32] propose to upload a different subset of global model to the server for aggregation with the objective to produce a single global inference model. Another way of personalization is to use Knowledge Distillation (KD) in heterogeneous FL systems ([12, 14, 15, 17–19, 33, 34]). The principle is to aggregate local soft-predictions instead of local model parameters in the server, whereby each client can update the local model to approach the averaged global predictions. As KD is independent with model structure, some literature [13, 16] are proposed to take advantage of such independence to implement personalized FL with heterogeneous models at client sides. For example, Li et al. [13] propose FedMD to perform ensemble distillation for each client to learn well-personalized models. Different from FedMD that exchanging soft-predictions between the clients and the server, FedDF [16] first aggregates local model parameters for model averaging at the server side. Then, the averaged global models can be updated by performing knowledge transfer from all received (heterogeneous) client models.
+
+To sum up, most of these schemes construct an ensembling teacher by simply averaging the teachers’ soft predictions, or by heuristically combining the output of the teacher models, which are far away from producing optimal combination of teachers. In our framework, KD is used in a more efficient way that the weights of the clients’ soft predictions are updated together with the model parameters during every FL training iteration.
+
+# 3 Problem Formulation
+
+We aim to collaboratively train personalized models for a set of clients applying different model structures in FL. Consider supervised learning whose goal is to learn a function that maps every input data to the correct class out of $\mathcal { C }$ possible options. We assume that there are $N$ clients, and each client $n$ can only access to his private dataset $\mathbf { \widetilde { D } } _ { n } : = \{ x _ { i } ^ { n } , y _ { i } \}$ , where $x _ { i }$ is the $i$ -th input data sample, $y _ { i }$ is the corresponding label of $x _ { i }$ , $y _ { i } \in \{ 1 , 2 , \cdots , \dot { C } \}$ . The number of data samples in dataset $\mathbb { D } _ { n }$ is denoted by $D _ { n }$ . $\mathbb { D } = \{ \mathbb { D } _ { 1 } , \mathbb { D } _ { 2 } , \cdot \cdot \cdot , \mathbb { D } _ { N } \}$ , $\begin{array} { r } { D = \sum _ { n = 1 } ^ { N } D _ { n } } \end{array}$ . In conventional $\mathrm { F L }$ , the goal of the learning system is to learn a global model w that minimizes the total empirical loss over the entire dataset $\mathbb { D }$ :
+
+$$
+\underset { \mathbf { w } } { \mathop { \operatorname* { m i n } } } \mathcal { L } ( \mathbf { w } ) : = \sum _ { n = 1 } ^ { N } \frac { D _ { n } } { D } \mathcal { L } _ { n } ( \mathbf { w } ) , \mathrm { ~ w h e r e ~ } \mathcal { L } _ { n } ( \mathbf { w } ) = \frac { 1 } { D _ { n } } \sum _ { i = 1 } ^ { D _ { n } } \mathcal { L } _ { C E } ( \mathbf { w } ; x _ { i } , y _ { i } ) ,
+$$
+
+where $\mathcal { L } _ { n } ( \mathbf { w } )$ is the $n$ -th client’s local loss function that measures the local empirical risk over the private dataset $\mathbb { D } _ { n }$ and $\mathcal { L } _ { C E }$ is the cross-entropy loss function that measures the difference between the predicted values and the ground truth labels.
+
+However, this formulation requires all local clients to have a unified model structure, which cannot be extended to more general cases where each client applies a unique model. Therefore, we need to reformulate the above optimization problem to break the barrier of homogeneous model structure. Besides, given the Non-IID clients’ datasets, it is inappropriate to just minimize the total empirical loss (i.e., $\begin{array} { r } { \operatorname* { m i n } _ { \mathbf { w } ^ { 1 } , \cdots , \mathbf { w } ^ { N } } \mathcal { L } ( \mathbf { w } ^ { 1 } , \cdots , \mathbf { w } ^ { N } ) : = \sum _ { n = 1 } ^ { N } \frac { D _ { n } } { D } \bar { L } _ { n } ( \mathbf { w } ^ { n } ) ) } \end{array}$ . To that end, we propose the following training framework:
+
+Definition 3.1. Let $s ( \mathbf { w } ^ { n } , \hat { x } )$ denote the collaborative knowledge from client $n$ , and $\hat { x }$ denote a data sample from a public dataset $\mathbb { D } _ { r }$ that all clients can access to. Define the personalized loss function of client $n$ as
+
+$$
+\mathcal { L } _ { p e r , n } ( \mathbf { w } ^ { n } ) : = \mathcal { L } _ { n } ( \mathbf { w } ^ { n } ) + \lambda \sum _ { \hat { x } \in \mathbb { D } _ { r } } \mathcal { L } _ { K L } \left( \sum _ { m = 1 } ^ { N } c _ { m n } \cdot s ( \mathbf { w } ^ { m } , \hat { x } ) , s ( \mathbf { w } ^ { n } , \hat { x } ) \right) ,
+$$
+
+where $\lambda > 0$ is a hyper-parameters, $\mathcal { L } _ { K L }$ stands for Kullback–Leibler (KL) Divergence function and is added to the loss function to transfer personalized knowledge from a teacher to another. $c _ { m n }$ is the knowledge coefficient which is used to estimate the contribution from client $m$ to $n$ . The second term in (2) allows each client to build his own personalized aggregated knowledge in the server and enhance the collaboration effect between clients with large c. The concept of collaborative knowledge can either refer to soft predictions or model parameters depending on the definition in different situations. For example, $s ( \mathbf { w } ^ { n } , \hat { x } )$ can be deemed to be a soft prediction of the client $n$ , which are calculated with the softmax of logits $z ^ { n }$ , i.e., $\begin{array} { r } { s ( \mathbf { w } ^ { n } , \hat { x } ) = \frac { \exp ( z _ { c } ^ { n } / T ) } { \sum _ { c = 1 } ^ { C } \exp ( z _ { c } ^ { n } / T ) } } \end{array}$ , logits $z ^ { n }$ is the output of the last fully connected layer on client $n$ ’s model, $T$ is the temperature hyperparameter of the softmax function.
+
+![](images/d660a020c4cc893c460788d8aac599c2ab7f9b98990ecfe742760411704b1e9e.jpg)  
+Figure 1: Illustration of the KT-pFL framework. The workflow includes 6 steps: $\textcircled{1}$ local training on private data; $\textcircled{2}$ , $\textcircled{3}$ each client outputs the local soft prediction on public data and sends it to the server; $\textcircled{4}$ the server calculates each client’s personalized soft prediction via a linear combination of local soft predictions and knowledge coefficient matrix; $\textcircled{5}$ each client downloads the personalized soft prediction to perform distillation phase; $\textcircled{6}$ the server updates the knowledge coefficient matrix.
+
+Definition 3.2. We define $\mathbf { c } \in \mathbb { R } ^ { N \times N }$ as the knowledge coefficient matrix:
+
+$$
+\mathbf { c } = \left. \begin{array} { c c c c } { c _ { 1 1 } } & { c _ { 1 2 } } & { \cdots } & { c _ { 1 N } } \\ { c _ { 2 1 } } & { c _ { 2 2 } } & { \cdots } & { c _ { 2 N } } \\ { \vdots } & { \vdots } & { \ddots } & { \vdots } \\ { c _ { N 1 } } & { c _ { N 2 } } & { \cdots } & { c _ { N N } } \end{array} \right. .
+$$
+
+Our objective is to minimize
+
+$$
+\operatorname* { m i n } _ { \mathbf { w } , \mathbf { c } } \mathcal { L } ( \mathbf { w } , \mathbf { c } ) : = \sum _ { n = 1 } ^ { N } \frac { D _ { n } } { D } \mathcal { L } _ { p e r , n } ( \mathbf { w } ^ { n } ) + \rho \| \mathbf { c } - \frac { \mathbf { 1 } } { N } \| ^ { 2 } ,
+$$
+
+where $\mathbf { w } = [ \mathbf { w } ^ { 1 } , \cdots , \mathbf { w } ^ { N } ] \in \mathbb { R } ^ { \sum _ { n = 1 } ^ { N } d _ { n } }$ is the concatenated vector of all weights, $d _ { n }$ represents the dimensions of model parameter $\mathbf { w } ^ { n }$ . $\mathbf { 1 } \in \mathbb { R } ^ { n ^ { 2 } }$ is the identity matrix whose elements are all equal to 1. The second term in (4) is a regularization term that ensures generalization ability of the whole learning system. Without the regularization term, a client with a completely different data distribution tends to set large values of the knowledge coefficient (i.e., equal to 1), and no collaboration will be conducted during training in this case. $\rho$ is a regularization parameter that is larger than 0.
+
+# 4 KT-pFL Algorithm
+
+In this section, we introduce the proposed KT-pFL algorithm, where the local model parameters and knowledge coefficient matrix are updated alternatively. To enable personalized knowledge transfer in FL, we train personalized models locally according to the related collaborative knowledge. Insert (2) into (4), and we can design an alternating optimization approach to solve (4), that in each round we fix either w or c by turns, and optimize the unfixed one following an alternating way until a convergence point is reached.
+
+Update w: In each communication round, we first fix c and optimize (train) w for several epochs locally. In this case, updating w depends on both the private data (i.e., $\mathcal { L } _ { C E }$ on $\mathbb { D } _ { n } , n \in [ 1 , \cdots , N ] )$ , that can only be accessed by the corresponding client, and the public data (i.e., $\mathcal { L } _ { K L }$ on $\mathbb { D } _ { r }$ ), which is accessible for all clients. We propose a two-stage updating framework for w:
+
+# Algorithm 1 KT-pFL Algorithm
+
+Input: $\mathbb { D }$ , $\mathbb { D } _ { r }$ , $\eta _ { 1 } , \eta _ { 2 } , \eta _ { 3 }$ and $T$   
+Output: $\mathbf { w } = [ \mathbf { w } ^ { 1 } , \cdots , \mathbf { w } ^ { N } ]$   
+1: Initialize $\mathbf { w } _ { 0 }$ and $\mathbf { c } _ { 0 }$   
+2: procedure SERVER-SIDE OPTIMIZATION   
+3: Distribute $\mathbf { w } _ { 0 }$ and $\mathbf { c } _ { 0 }$ to each client   
+4: for each communication round $t \in \{ 1 , 2 , . . . , T \}$ do   
+5: for each client $n$ in parallel do   
+6: $\mathbf { w } _ { t + 1 } ^ { n }  C l i e n t L o c a l U p d a t e ( n , \mathbf { w } _ { t } ^ { n } , \mathbf { c } _ { t , n } )$   
+7: Update knowledge coefficient matrix c via (7)   
+8: Distribute $\mathbf { c } _ { t + 1 }$ to all clients   
+9: procedure CLIENTLOCALUPDATE $\mathbf { \Delta } _ { : } ( n , \mathbf { w } _ { t } ^ { n } , \mathbf { c } _ { t , n } )$   
+10: Client $n$ receives $\mathbf { w } _ { t } ^ { n }$ and $\mathbf { c } _ { n }$ from the server   
+11: for each local epoch $i$ from 1 to $E$ do   
+12: for mini-batch $\xi _ { t } \subseteq \mathbb { D } _ { n }$ do   
+13: Local Training: update model parameters on private data via (5)   
+14: for each distillation step $j$ from 1 to $R$ do   
+15: for mini-batch $\xi _ { r , t } \subseteq \mathbb { D } _ { r }$ do   
+16: Distillation: update model parameters on public data via (6)   
+return local parameters $\mathbf { w } _ { t + 1 } ^ { n }$
+
+• Local Training: Train w on each client’s private data by applying a gradient descent step:
+
+$$
+\begin{array} { r } { \mathbf { w } ^ { n }  \mathbf { w } ^ { n } - \eta _ { 1 } \nabla _ { \mathbf { w } ^ { n } } \mathcal { L } _ { n } ( \mathbf { w } ^ { n } ; \boldsymbol { \xi } _ { n } ) , } \end{array}
+$$
+
+where $\xi _ { n }$ denotes the mini-batch of data $\mathbb { D } _ { n }$ used in local training, $\eta _ { 1 }$ is the learning rate.
+
+• Distillation: Transfer knowledge from personalized soft prediction to each local client based on public dataset:
+
+$$
+\mathbf { w } ^ { n }  \mathbf { w } ^ { n } - \eta _ { 2 } \nabla _ { \mathbf { w } ^ { n } } \mathcal { L } _ { K L } ( \sum _ { m = 1 } ^ { N } \mathbf { c } _ { m } ^ { * , T } \cdot s ( \mathbf { w } ^ { m } , \boldsymbol { \xi } _ { r } ) , s ( \mathbf { w } ^ { n } , \boldsymbol { \xi } _ { r } ) ) ,
+$$
+
+where $\xi _ { r }$ denotes the mini-batch of public data $\mathbb { D } _ { r }$ , and $\eta _ { 2 }$ is the learning rate. c ∗m $\mathrm { ~ \bf ~ c ~ } _ { m } ^ { * } =$ $[ c _ { m 1 } , c _ { m 2 } , \cdots , c _ { m N } ]$ is the knowledge coefficient vector for client $m$ , which can be found in $m$ -th row of $\mathbf { c }$ . Note that all collaborative knowledge and knowledge coefficient matrix are required to obtain the personalized soft prediction in this stage, which can be collected in the server.
+
+Update c: After updating w locally for several epochs, we turn to fix w and update $\mathbf { c }$ in the server.
+
+$$
+\mathbf { c } \gets \mathbf { c } - \eta _ { 3 } \lambda \sum _ { n = 1 } ^ { N } \frac { D _ { n } } { D } \nabla _ { \mathbf { c } } \mathcal { L } _ { K L } \left( \sum _ { m = 1 } ^ { N } \mathbf { c } _ { m } \cdot s ( \mathbf { w } ^ { m , * } , \boldsymbol { \xi } _ { r } ) , s ( \mathbf { w } ^ { n , * } , \boldsymbol { \xi } _ { r } ) \right) - 2 \eta _ { 3 } \rho ( \mathbf { c } - \frac { 1 } { N } ) ,
+$$
+
+where $\eta _ { 3 }$ is the learning rate for updating c.
+
+Algorithm 1 demonstrates the proposed KT-pFL algorithm and the idea behind it is shown in Figure 1. In every communication round of training, the clients use local SGD to train several epochs based on the private data and then send the collaborative knowledge (e.g., soft predictions on public data) to the server. When the server receives the collaborative knowledge from each client, it aggregates them to form the personalized soft predictions according to the knowledge coefficient matrix. The server then sends back the personalized soft prediction to each client to perform local distillation. The clients then iterate for multiple steps over public dataset 2. After that, the knowledge coefficient matrix is updated in the server while fixing the model parameters w.
+
+Performance Guarantee. Theorem 4.1 provides the performance analysis of the personalized model when each client owns Non-IID data. Detailed description and derivations are deferred to Appendix A.
+
+Theorem 4.1. Denote the n-th local distribution and its empirical distribution by $\mathcal { D } _ { n }$ and $\hat { \mathcal { D } } _ { n }$ respectively, and the hypothesis $h \in \mathcal H$ trained on $\hat { \mathcal { D } } _ { n }$ by $h _ { \hat { \mathcal { D } } _ { n } }$ . There always exist $c _ { m , n } ^ { * } , m = 1 , \ldots , N ,$ uch that the expected loss of the personalized ensemble model for the dais not larger than that of the single model only trained with local data: $\mathcal { D } _ { n }$ $n$ $\begin{array} { r } { \mathcal { L } _ { \mathcal { D } _ { n } } ( \sum _ { m = 1 } ^ { N } c _ { m , n } ^ { * } h _ { \hat { D } _ { m } } ) ^ { } \leq } \end{array}$ $\mathcal { L } _ { D _ { n } } ( h _ { \hat { D } _ { n } } )$ . Besides, there exist some problems where the personalized ensemble model is strictly better, i.e., $\begin{array} { r } { \mathcal { L } _ { \mathcal { D } _ { n } } ( \sum _ { m = 1 } ^ { N } c _ { m , n } ^ { * } h _ { \hat { \mathcal { D } } _ { m } } ) < \mathcal { L } _ { \mathcal { D } _ { n } } ( h _ { \hat { \mathcal { D } } _ { n } } ) , } \end{array}$ .
+
+Theorem 4.1 indicates that the performance of the personalized ensemble model under some suitable coefficient matrices is better than that of the model only trained on its local private data, which theoretically demonstrates the necessity of the parameterized personalization. However, it is challenging to find such matrices due to the complexity and diversity of machine learning models and data distributions. In this paper, our designed algorithm KT-pFL can find the desired coefficient matrix in a gradient descent manner, hence achieving the performance boost. Besides, we have the similar claim for the relationship between the personalized ensemble model and average ensemble model.
+
+Remark 4.1. There always exist $c _ { m , n } ^ { * } , m = 1 , \ldots , N$ , such that the expected loss of the personalized ensemble model for the data distribution $\mathcal { D } _ { n }$ of client $n$ is not larger than that of the average ensemble model: $\begin{array} { r } { \ L \dot { \mathcal L } _ { \mathcal D _ { n } } ( \sum _ { m = 1 } ^ { N } c _ { m , n } ^ { * } h _ { \hat { \mathcal D } _ { m } } ) \leq { \mathcal L } _ { \mathcal D _ { n } } ( \frac { 1 } { N } \sum _ { m = 1 } ^ { N } h _ { \hat { \mathcal D } _ { m } } ) } \end{array}$ . Besides, there exist some problems where the personalized ensemble model is strictly better, i.e., $\begin{array} { r } { \mathcal { L } _ { \mathcal { D } _ { n } } ( \sum _ { m = 1 } ^ { N } c _ { m , n } ^ { * } h _ { \hat { D } _ { m } } ) ^ { } < } \end{array}$ $\begin{array} { r } { \mathcal { L } _ { \mathcal { D } _ { n } } \big ( \frac { 1 } { N } \sum _ { m = 1 } ^ { N } h _ { \hat { \mathcal { D } } _ { m } } \big ) } \end{array}$ .
+
+# 5 Evaluations
+
+# 5.1 Experimental Setup
+
+Task and Datasets We evaluate our proposed training framework on three different image classification tasks: EMNIST [35], Fashion_MNIST [36] and CIFAR-10 [37]. For each dataset, we apply two different Non-IID data settings: 1) each client only contains two classes of samples; 2) each client contains all classes of samples, while the number of samples for each class is different from that of a different client. All datasets are split randomly with $7 5 \%$ and $2 5 \%$ for training and testing, respectively. The testing data on each client has the same distribution with its training data. For all methods, we record the average test accuracy of all local models for evaluation.
+
+Model Structure: Four different lightweight model structures including LeNet [38], AlexNet [39], ResNet-18 [40], and ShuffleNetV2 [41] are adopted in our experiments. Our pFL system has 20 clients, who are assigned with four different model structures, i.e., five clients per model.
+
+Baselines: Although KT-pFL is designed for effective personalized federated learning, it can be applied to both heterogeneous and homogeneous model cases. We first conduct experiments on heterogeneous systems where the neural architecture of the local models are different among clients. We compare the performance of KT-pFL to the non-personalized distillation-based methods: FedMD [13], FedDF [16] and the personalized distillation-based method pFedDF3 and other simple versions of KT-pFL including Sim-pFL and TopK-pFL. Sim-pFL calculates the knowledge coefficient by using cosine similarity between two local soft predictions. Instead of combining the knowledge from all clients, TopK-pFL obtains the personalized soft predictions only from $K$ clients4 who have higher value of cosine similarity.
+
+To demonstrate the generalization and effectiveness of our proposed training framework, we further compare KT-pFL to FedAvg [1] and state-of-the-art pFL methods including Per-Fedavg [9], FedavgLocal FT[23], pFedMe [6], FedAMP [8], FedFomo[29] and FedHN[30] under the homogeneous model setting. Note that Per-FedAvg is a MAML-based method which aims to optimize the one-step gradient update for its personalized model. pFedMe and FedAMP are two regularized-based methods. The former one obtains personalized models by controlling the distance between local model and global model, while the later one facilitates the collaboration of clients with similar data distribution.
+
+Implementation The experiments are implemented in PyTorch. We simulate a set of clients and a centralized server on one deep learning workstation (i.e., Intel(R) Core(TM) i9-9900KF CPU $@$ 3.6GHz with one NVIDIA GeForce RTX 2080Ti GPU).
+
+![](images/74af6526f3592c8b260ec54e74a7327e932c5a1ed7046ae4b72d1e54771f20d9.jpg)  
+Figure 2: Performance comparison of FedMD, FedDF, pFedDF, TopK-pFD, Sim-pFD, and KT-pFL in average test accuracy on three datasets (Non-IID case 1: each client contains all labels).
+
+![](images/6a57aa1bb45a428a65357e2d48250d3b650620ead399beba7a9a58475c028e0b.jpg)  
+Figure 3: Performance comparison of FedMD, FedDF, pFedDF, TopK-pFD, Sim-pFD, and KT-pFL in average test accuracy on three datasets (Non-IID case 2: each client contains only two labels).
+
+# 5.2 Results
+
+Subject to space constraints, we only report the most important experimental results in this section. Please refer to Appendix B for the details of different Non-IID data settings on EMNIST, Fashion_MNIST and CIFAR10, the implementation details and the hyperparameter settings of all the methods, and also extra results about the convergence and robustness analysis. In our experiments, we run each experiment multiple times and record the average results.
+
+Table 1: The comparison of final test accuracy $( \% )$ on different datasets with heterogeneous models (i.e., Lenet, AlexNet, ResNet-18 and ShuffleNetV2).   
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">EMNIST</td><td colspan="2">Fashion_MNIST</td><td colspan="2">CIFAR-10</td></tr><tr><td>Non-IID_1</td><td>Non-IID_2</td><td>Non-IID_1</td><td>Non-IID_2</td><td>Non-IID_1</td><td>Non-IID_2</td></tr><tr><td>FedMD [13]</td><td>71.37</td><td>70.15</td><td>68.02</td><td>66.10</td><td>39.14</td><td>35.56</td></tr><tr><td>FedDF[16]</td><td>71.92</td><td>72.79</td><td>70.32</td><td>70.83</td><td>40.19</td><td>37.81</td></tr><tr><td>pFedDF</td><td>78.59</td><td>75.72</td><td>72.69</td><td>73.45</td><td>42.83</td><td>39.54</td></tr><tr><td>Sim-pFD</td><td>82.72</td><td>74.42</td><td>72.82</td><td>72.71</td><td>42.50</td><td>39.90</td></tr><tr><td>TopK-pFD</td><td>83.00</td><td>73.91</td><td>72.24</td><td>73.39</td><td>42.58</td><td>39.34</td></tr><tr><td>KT-pFL</td><td>84.65</td><td>76.30</td><td>75.48</td><td>75.60</td><td>43.82</td><td>41.04</td></tr></table>
+
+# 5.2.1 Performance Comparison
+
+Heterogeneous FL. For all the methods and all the data settings, the batch size on private data and public data are 128 and 256, respectively, the number of local epochs is 20 and the distillation steps is 1 in each communication round of pFL training. Unless mentioned, otherwise the public data used for EMNIST and Fashion_MNIST is MNIST, and the public data used for CIFAR-10 is CIFAR-100. the size of public data used in each communication round is 3000, the learning rate is set to 0.01 for EMNIST and Fashion_MNIST, and 0.02 for CIFAR-10.
+
+Figure 2 and 3 show the curves of the average test accuracy during the training process on four different models with three datasets, which include the results of FedMD, FedDF, pFedDF, Sim-pFL,
+
+![](images/1942cb395f74e84ecf698ebc6c71d40acecfbfd316ff33397347abd9661434af.jpg)  
+Figure 4: Performance comparison of FedAvg, Per-Fedavg, Fedavg-Local FT, pFedMe, FedAMP, FedFomo, FedHN and KT-pFL in average test accuracy on three datasets. The Non-IID data setting: each client contains all labels. 20 clients with homogeneous models: CNN [1]. Learning rate: 0.005.
+
+Table 2: The comparison of final test accuracy $( \% )$ on different datasets with different number of homogeneous models (i.e., the same CNN architecture as [1]). For large-scale FL system with 100 clients, we set the client sampling rate as 0.1.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">EMNIST</td><td colspan="2">Fashion_MNIST</td><td colspan="2">CIFAR-10</td></tr><tr><td>20 clients</td><td>100 clients</td><td>20 clients</td><td>100 clients</td><td>20 clients</td><td>100 clients</td></tr><tr><td>Fedavg [1]</td><td>85.86</td><td>76.84</td><td>80.69</td><td>72.36</td><td>51.94</td><td>43.56</td></tr><tr><td>Per-Fedavg [9]</td><td>86.16</td><td>82.87</td><td>85.91</td><td>77.93</td><td>55.61</td><td>49.82</td></tr><tr><td>Fedavg-Local FT[23]</td><td>86.59</td><td>84.55</td><td>90.17</td><td>80.93</td><td>42.88</td><td>50.91</td></tr><tr><td>pFedMe [6]</td><td>84.26</td><td>86.14</td><td>90.97</td><td>84.02</td><td>62.79</td><td>52.46</td></tr><tr><td>FedAMP[8]</td><td>88.51</td><td>85.63</td><td>90.79</td><td>84.72</td><td>60.75</td><td>51.26</td></tr><tr><td>FedFomo [29]</td><td>92.58</td><td>90.08</td><td>88.33</td><td>87.76</td><td>63.11</td><td>55.73</td></tr><tr><td>pFedHN[30]</td><td>94.27</td><td>92.21</td><td>92.22</td><td>89.14</td><td>65.31</td><td>57.38</td></tr><tr><td>KT-pFL</td><td>94.40</td><td>92.50</td><td>93.93</td><td>90.37</td><td>66.96</td><td>58.29</td></tr></table>
+
+TopK-pFL and KT-pFL. We also summarize the final average test accuracy in Table 1. In two cases of Non-IID settings, KT-pFL obtains comparable or even better accuracy performance than others. The performances of FedMD, FedDF, pFedDF are worse than the other three methods. The reason is that taking the global aggregation of all local soft predictions trained on the Non-IID data from different clients produces only one global soft prediction, which cannot be well adapted to each client. The other two personalized methods, i.e., Sim-pFL and TopK-pFL, achieve comparably performance on most of cases with pFedDF. Our proposed method KT-pFL has the best performance, because each client can adaptively aggregate all local soft predictions to form a personalized one instead of being restricted to a global soft prediction.
+
+Homogeneous FL. Apart from heterogeneous system, we further extend KT-pFL to homogeneous model setting. To conduct fair comparison with baselines, we exchange model parameters with the server to perform knowledge transfer. Specifically, each client maintains a personalized global model at the server side and each personalized global model is aggregated by a linear combination of local model parameters and knowledge coefficient matrix (Appendix C). In this case, we compare the performance of homogeneous-version of KT-pFL with FedAvg, Per-Fedavg, Fedavg-Local FT, pFedMe, FedAMP, FedFomo and FedHN. Figure 4 and Table 2 show the curve of the average test accuracy during training and the final average test accuracy on three different datasets, respectively. For all datasets, KT-pFL dominates the other seven methods on average test accuracy with less variance. Besides, the concept of FedAMP and FedFomo is similar with our proposed method KT-pFL. The difference is that the weights for each local model during personalized aggregation phase are updated in a gradient descent manner in KT-pFL.
+
+To verify the efficiency of KT-pFL on large-scale FL system, we conduct experiments on 100 clients and apply the same client selection mechanism as other baselines. Specifically, in KT-pFL, only partial of elements in the knowledge coefficient matrix c will be updated in each communication round on large-scale FL systems. From the results in Table 2, it is obvious that our proposed method can work well both on small-scale and large-scale FL systems.
+
+Table 3: The comparison of final test accuracy on different setting of local epochs $E$ and distillation steps $R$ .   
+
+<table><tr><td rowspan="2">Dataset</td><td colspan="4"># Local epochs (E)</td><td colspan="4"># Distillation steps (R)</td></tr><tr><td>5</td><td>10</td><td>15</td><td>20</td><td>1</td><td>2</td><td>3</td><td>5</td></tr><tr><td>EMNIST (%)</td><td>90.15</td><td>92.76</td><td>91.03</td><td>90.15</td><td>91.76</td><td>91.40</td><td>91.18</td><td>91.54</td></tr><tr><td>Fashion_MNIST (%)</td><td>88.73</td><td>89.14</td><td>88.58</td><td>89.42</td><td>89.14</td><td>89.90</td><td>89.07</td><td>88.08</td></tr><tr><td>CIFAR-10 (%)</td><td>58.30</td><td>59.38</td><td>59.34</td><td>59.24</td><td>59.24</td><td>57.99</td><td>59.22</td><td>58.91</td></tr></table>
+
+Table 4: The comparison of final test accuracy on different setting of regularization parameter $\rho$   
+
+<table><tr><td rowspan="2">Dataset</td><td colspan="4"># Regularization parameter p</td></tr><tr><td>0.1</td><td>0.3</td><td>0.5</td><td>0.7</td></tr><tr><td>EMNIST (%)</td><td>90.96</td><td>90.66</td><td>90.88</td><td>91.76</td></tr><tr><td>Fashion_MNIST (%)</td><td>89.49</td><td>89.30</td><td>89.56</td><td>89.14</td></tr><tr><td>CIFAR-10 (%)</td><td>59.08</td><td>58.52</td><td>59.56</td><td>58.40</td></tr></table>
+
+# 5.2.2 Effect of hyperparameters
+
+To understand how different hyperparameters such as $E$ , $R$ , $\rho$ , and $\left| \mathbb { D } _ { r } \right|$ can affect the training performance of KT-pFL in different settings, we conduct various experiments on three datasets with η1 = η2 = η3 = 0.01.
+
+Effect of Local Epochs $E$ . To reduce communication overhead, the server tends to allow clients to have more local computation steps, which can lead to less global updates and thus faster convergence. Therefore, we monitor the behavior of KT-pFL using a number of values of $E$ , whose results are given in Table 3. The results show that larger values of $E$ can benefit the convergence of the personalized models. There is, nevertheless, a trade-off between the computations and communications, i.e., while larger $E$ requires more computations at local clients, smaller $E$ needs more global communication rounds to converge. To do such trade-off, we fix $E = 2 0$ and evaluate the effect of other hyperparameters accordingly.
+
+Effect of Distillation Steps $R$ . As the performance of the knowledge transfer is directly related to the number of distillation steps $R$ , we compare the performance of KT-pFL under different setting of distillation steps (e.g., $R = 1 , 2 , 3 , 5$ ). The number of local epochs is set to 20. The results show that larger value of $R$ cannot always lead to better performance, which means a moderate number of the distillation steps is necessary to approach to the optimal performance.
+
+Effect of $\rho$ . As mentioned in Eq (4), $\rho$ is the regularization term to do the trade-off between personalization ability and generalization ability. For example, larger value of $\rho$ means that the knowledge coefficient of each local soft prediction should approach to $\scriptstyle { \frac { 1 } { N } }$ , and thus more generalization ability should be guaranteed. Table 4 shows the results of $\mathrm { K T - p F L }$ with different value of $\rho$ . In most settings, a significantly large value of $\rho$ will hurt the performance of KT-pFL.
+
+Table 5: Performance of KT-pFL under different setting of public dataset (Task: Fashion_MNIST; Unlabeled Open Dataset: divided from Fashion_MNIST).   
+
+<table><tr><td>Public dataset</td><td>Test Accuracy</td></tr><tr><td>MNIST</td><td>89.14 (± 0.15)</td></tr><tr><td>EMNIST</td><td>88.76(± 0.21)</td></tr><tr><td>Unlabeled Open Dataset</td><td>89.03 (± 0.11)</td></tr></table>
+
+Effect of different public dataset. Besides, we compare the performance of our proposed method on different public datasets (Table 5). From the experimental results, we can observe that different settings of the public dataset have little effect on the training performance.
+
+Effect of $\left| \mathbb { D } _ { r } \right|$ . Table 6 demonstrates the effect of public data size $\left| \mathbb { D } _ { r } \right|$ used in local distillation phase. When the size of the public data is increased, KT-pFL has higher average test accuracy. However, very large $\left| \mathbb { D } _ { r } \right|$ will not only slow down the convergence of KT-pFL but also incur higher computation time at the clients. During the experiments, the value of $\left| \mathbb { D } _ { r } \right|$ is configured to 3000.
+
+Table 6: The comparison of final test accuracy on different setting of the public data size $\left| \mathbb { D } _ { r } \right|$ .   
+
+<table><tr><td rowspan="2">Dataset</td><td colspan="6"># Size of public data (IDrl)</td></tr><tr><td>10</td><td>100</td><td>500</td><td>1000</td><td>3000</td><td>5000</td></tr><tr><td>EMNIST (%)</td><td>56.19</td><td>73.44</td><td>91.25</td><td>91.47</td><td>91.66</td><td>91.32</td></tr><tr><td>Fashion_MNIST (%)</td><td>50.80</td><td>67.43</td><td>88.08</td><td>89.40</td><td>89.50</td><td>89.14</td></tr><tr><td>CIFAR-10 (%)</td><td>39.08</td><td>47.70</td><td>58.93</td><td>58.79</td><td>58.91</td><td>58.40</td></tr></table>
+
+# 5.2.3 Efficiency Evaluation
+
+To evaluate the communication overhead, we record three aspects information: Data (batch size used in distillation phase), Param (model parameters) and Soft Prediction without using data compression techniques. The results are shown in Figure 5. Compared with conventional parameter-based pFL methods, the communication overhead on soft prediction-based KT-pFL is far less than Conv-pFL.
+
+![](images/bc13c78aa8e4f23da5348d1de234aed7c4a4c7e3ae05e8fbb2ece64067909405.jpg)  
+Figure 5: Communication Efficiency (X-axis units: MBytes) on three datasets. KL-pFL: soft prediction-based personalized federated learning; Conv-pFL: conventional parameter-based personalized federated learning. (20 models, 30 communication rounds for all datasets. In this experiment, the public dataset is stored on the server.)
+
+# Broader Impact
+
+FL has been emerged as new paradigm to collaboratively train models among multiple clients in a privacy-preserving manner. Due to the diversity of users (e.g., statistical and systematic heterogeneity, etc.), applying personalization in FL is essential for future trend. Our method KT-pFL not only breaks the barriers of homogeneous model constraint, which can significantly reduce the communication overhead during training, but also improves the training efficiency via a parameterized update mechanism without additional computation overhead at the client side. This research has the potential to enable various devices to cooperatively train ML tasks based on customized neural network architectures.
+
+# Acknowledgements
+
+This research was supported by the funding from Hong Kong RGC Research Impact Fund (RIF) with the Project No. R5060-19, General Research Fund (GRF) with the Project No. 152221/19E and 15220320/20E, the National Natural Science Foundation of China (61872310), and Shenzhen Science and Technology Innovation Commission (R2020A045).
+
+# References
+
+[1] Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Agüera y Arcas. Communication-efficient learning of deep networks from decentralized data. In Proceedings of the 20th International Conference on Artificial Intelligence and Statistics, AISTATS, 2017.
+
+[2] Tian Li, Anit Kumar Sahu, Manzil Zaheer, Maziar Sanjabi, Ameet Talwalkar, and Virginia Smith. Federated optimization in heterogeneous networks. In Proceedings of Machine Learning and Systems, MLSys, 2020.   
+[3] Mehryar Mohri, Gary Sivek, and Ananda Theertha Suresh. Agnostic federated learning. In Proceedings of International Conference on Machine Learning, ICML, pages 4615–4625, 2019.   
+[4] Sai Praneeth Karimireddy, Satyen Kale, Mehryar Mohri, Sashank Reddi, Sebastian Stich, and Ananda Theertha Suresh. Scaffold: Stochastic controlled averaging for federated learning. In Proceedings of International Conference on Machine Learning, ICML, pages 5132–5143, 2020.   
+[5] Tian Li, Maziar Sanjabi, Ahmad Beirami, and Virginia Smith. Fair resource allocation in federated learning. In Proceedings of 8th International Conference on Learning Representations, ICLR, 2020.   
+[6] Canh T. Dinh, Nguyen H. Tran, and Tuan Dung Nguyen. Personalized federated learning with moreau envelopes. In Proceedings of Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems, NeurIPS, 2020.   
+[7] Filip Hanzely and Peter Richtárik. Federated learning of a mixture of global and local models. arXiv preprint arXiv:2002.05516, 2020.   
+[8] Yutao Huang, Lingyang Chu, Zirui Zhou, Lanjun Wang, Jiangchuan Liu, Jian Pei, and Yong Zhang. Personalized cross-silo federated learning on non-iid data. In Proceedings of the AAAI Conference on Artificial Intelligence, AAAI, 2021.   
+[9] Alireza Fallah, Aryan Mokhtari, and Asuman E. Ozdaglar. Personalized federated learning with theoretical guarantees: A model-agnostic meta-learning approach. In Proceedings of Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems, NeurIPS, 2020.   
+[10] Avishek Ghosh, Jichan Chung, Dong Yin, and Kannan Ramchandran. An efficient framework for clustered federated learning. In Proceedings of Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems, NeurIPS, 2020.   
+[11] Yishay Mansour, Mehryar Mohri, Jae Ro, and Ananda Theertha Suresh. Three approaches for personalization with applications to federated learning. arXiv preprint arXiv:2002.10619, 2020.   
+[12] Eunjeong Jeong, Seungeun Oh, Hyesung Kim, Jihong Park, Mehdi Bennis, and Seong-Lyun Kim. Communication-efficient on-device machine learning: Federated distillation and augmentation under non-iid private data. arXiv preprint arXiv:1811.11479, 2018.   
+[13] Daliang Li and Junpu Wang. FedMD: Heterogenous federated learning via model distillation. arXiv, oct 2019.   
+[14] Hongyan Chang, Virat Shejwalkar, Reza Shokri, and Amir Houmansadr. Cronus: Robust and heterogeneous collaborative learning with black-box knowledge transfer. arXiv preprint arXiv:1912.11279, 2019.   
+[15] Sohei Itahara, Takayuki Nishio, Yusuke Koda, Masahiro Morikura, and Koji Yamamoto. Distillation-based semi-supervised federated learning for communication-efficient collaborative training with non-iid private data. arXiv preprint arXiv:2008.06180, 2020.   
+[16] Tao Lin, Lingjing Kong, Sebastian U. Stich, and Martin Jaggi. Ensemble distillation for robust model fusion in federated learning. In Proceedings of Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems, NeurIPS, 2020.   
+[17] Hong-You Chen and Wei-Lun Chao. Fedbe: Making bayesian model ensemble applicable to federated learning. In 9th International Conference on Learning Representations, ICLR 2021, Virtual Event, Austria, May 3-7, 2021. OpenReview.net, 2021.   
+[18] Yanlin Zhou, George Pu, Xiyao Ma, Xiaolin Li, and Dapeng Wu. Distilled one-shot federated learning. CoRR, abs/2009.07999, 2020.   
+[19] Lichao Sun and Lingjuan Lyu. Federated model distillation with noise-free differential privacy. In Zhi-Hua Zhou, editor, Proceedings of the Thirtieth International Joint Conference on Artificial Intelligence, IJCAI 2021, pages 1563–1570. ijcai.org, 2021.   
+[20] Kangkang Wang, Rajiv Mathews, Chloé Kiddon, Hubert Eichner, Françoise Beaufays, and Daniel Ramage. Federated evaluation of on-device personalization. arXiv preprint arXiv:1910.10252, 2019.   
+[21] Johannes Schneider and Michail Vlachos. Personalization of deep learning. arXiv preprint arXiv:1909.02803, 2019.   
+[22] Manoj Ghuhan Arivazhagan, Vinay Aggarwal, Aaditya Kumar Singh, and Sunav Choudhary. Federated learning with personalization layers. arXiv preprint arXiv:1912.00818, 2019.   
+[23] Tao Yu, Eugene Bagdasaryan, and Vitaly Shmatikov. Salvaging federated learning by local adaptation. CoRR, abs/2002.04758, 2020.   
+[24] Filip Hanzely, Slavomír Hanzely, Samuel Horváth, and Peter Richtárik. Lower bounds and optimal algorithms for personalized federated learning. In Proceedings of Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems, NeurIPS, 2020.   
+[25] Tian Li, Shengyuan Hu, Ahmad Beirami, and Virginia Smith. Ditto: Fair and robust federated learning through personalization. In International Conference on Machine Learning, pages 6357–6368. PMLR, 2021.   
+[26] Yuyang Deng, Mohammad Mahdi Kamani, and Mehrdad Mahdavi. Adaptive personalized federated learning. arXiv preprint arXiv:2003.13461, 2020.   
+[27] Matthias Reisser, Christos Louizos, Efstratios Gavves, and Max Welling. Federated mixture of experts. arXiv preprint arXiv:2107.06724, 2021.   
+[28] Yihan Jiang, Jakub Konecnˇ y, Keith Rush, and Sreeram Kannan. Improving federated learning \` personalization via model agnostic meta learning. arXiv preprint arXiv:1909.12488, 2019.   
+[29] Michael Zhang, Karan Sapra, Sanja Fidler, Serena Yeung, and Jose M. Alvarez. Personalized federated learning with first order model optimization. In 9th International Conference on Learning Representations, ICLR 2021. OpenReview.net, 2021.   
+[30] Aviv Shamsian, Aviv Navon, Ethan Fetaya, and Gal Chechik. Personalized federated learning using hypernetworks. In Marina Meila and Tong Zhang, editors, Proceedings of the 38th International Conference on Machine Learning, ICML 2021, volume 139, pages 9489–9502. PMLR, 2021.   
+[31] Virginia Smith, Chao-Kai Chiang, Maziar Sanjabi, and Ameet S. Talwalkar. Federated multitask learning. In Proceedings of Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems, NeurIPS, 2017.   
+[32] Enmao Diao, Jie Ding, and Vahid Tarokh. Heterofl: Computation and communication efficient federated learning for heterogeneous clients. In 9th International Conference on Learning Representations, ICLR 2021. OpenReview.net, 2021.   
+[33] Neel Guha, Ameet Talwalkar, and Virginia Smith. One-shot federated learning. CoRR, abs/1902.11175, 2019.   
+[34] Chaoyang He, Salman Avestimehr, and Murali Annavaram. Group knowledge transfer: Collaborative training of large cnns on the edge. arXiv preprint arXiv:2007.14513, 2020.   
+[35] Gregory Cohen, Saeed Afshar, Jonathan Tapson, and André van Schaik. EMNIST: extending MNIST to handwritten letters. In Proceedings of 2017 International Joint Conference on Neural Networks, IJCNN, 2017.   
+[36] Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017.   
+[37] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.   
+[38] Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   
+[39] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In Proceedings of Advances in Neural Information Processing Systems 25: 26th Annual Conference on Neural Information Processing Systems, NeurIPS, pages 1106–1114, 2012.   
+[40] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of 2016 IEEE Conference on Computer Vision and Pattern Recognition, CVPR, pages 770–778, 2016.   
+[41] 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, pages 116–131, 2018.

parse/train/_89s8ViNwwj/_89s8ViNwwj_content_list.json

@@ -0,0 +1,1149 @@
+[
+    {
+        "type": "text",
+        "text": "Parameterized Knowledge Transfer for Personalized Federated Learning ",
+        "text_level": 1,
+        "bbox": [
+            183,
+            122,
+            816,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jie Zhang1, Song $\\mathbf { G u o } ^ { 1 , * }$ , Xiaosong $\\mathbf { M } \\mathbf { a } ^ { 1 }$ , Haozhao Wang2, Wencao $\\mathbf { X } \\mathbf { u } ^ { 1 }$ , and Feijie $\\mathbf { W } \\mathbf { u } ^ { 1 }$ ",
+        "bbox": [
+            189,
+            224,
+            803,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Department of Computing, The Hong Kong Polytechnic University 2Department of Computer Science and Technology, HUST {jieaa.zhang,harli.wu}@connect.polyu.hk, hz_wang@hust.edu.cn, {song.guo,xiaosma,wenchao.xu}@polyu.edu.hk ",
+        "bbox": [
+            243,
+            242,
+            756,
+            297
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            333,
+            535,
+            349
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In recent years, personalized federated learning (pFL) has attracted increasing attention for its potential in dealing with statistical heterogeneity among clients. However, the state-of-the-art pFL methods rely on model parameters aggregation at the server side, which require all models to have the same structure and size, and thus limits the application for more heterogeneous scenarios. To deal with such model constraints, we exploit the potentials of heterogeneous model settings and propose a novel training framework to employ personalized models for different clients. Specifically, we formulate the aggregation procedure in original pFL into a personalized group knowledge transfer training algorithm, namely, KT-pFL, which enables each client to maintain a personalized soft prediction at the server side to guide the others’ local training. KT-pFL updates the personalized soft prediction of each client by a linear combination of all local soft predictions using a knowledge coefficient matrix, which can adaptively reinforce the collaboration among clients who own similar data distribution. Furthermore, to quantify the contributions of each client to others’ personalized training, the knowledge coefficient matrix is parameterized so that it can be trained simultaneously with the models. The knowledge coefficient matrix and the model parameters are alternatively updated in each round following the gradient descent way. Extensive experiments on various datasets (EMNIST, Fashion_MNIST, CIFAR-10) are conducted under different settings (heterogeneous models and data distributions). It is demonstrated that the proposed framework is the first federated learning paradigm that realizes personalized model training via parameterized group knowledge transfer while achieving significant performance gain comparing with state-of-the-art algorithms. ",
+        "bbox": [
+            232,
+            363,
+            764,
+            680
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            704,
+            310,
+            722
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Federated Learning (FL) [1] has emerged as an efficient paradigm to collaboratively train a shared machine learning model among multiple clients without directly accessing their private data. By periodically aggregating parameters from the clients for global model updating, it can converge to high accuracy and strong generalization. FL has shown its capability to protect user privacy while there remains a crucial challenge that significantly degrades the learning performance, i.e., statistic heterogeneity in users’ local datasets. Given the Non-Independent and Identically Distributed (Non-IID) user data, the trained global model often cannot be generalized well over each client [2–5]. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To deal with the above issues, employing personalized models appears to be an effective solution in FL, i.e., personalized federated learning (pFL). Recent works regarding pFL include regularizationbased methods [6–8] (i.e., pFedMe [6], L2SGD [7], FedAMP [8]), meta-learning-based Per-FedAvg [9] and cluster-based IFCA [10, 11]. However, in order to aggregate the parameters from all clients, it is inevitable for them to have identical model structure and size. Such constraints would prevent status quo pFL methods from further application in practical scenarios, where clients are often willing to own unique models, i.e., with customized neural architectures to adapt to heterogeneous capacities in computation, communication and storage space, etc. Motivated by the paradigm of Knowledge Distillation (KD) [12–16] that knowledge can be transferred from a neural network to another via exchanging soft predictions instead of using the whole model parameters, KD-based FL training methods have been studied [12, 14–19] to collaboratively train heterogeneous models in a privacy-preserving way. However, these works have neglected the further personalization requirement of FL clients, which can be well satisfied via the personalized knowledge transfer for heterogeneous FL users. ",
+        "bbox": [
+            176,
+            838,
+            821,
+            881
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we seek to develop a novel training framework that can accommodate heterogeneous model structures for each client and achieve personalized knowledge transfer in each FL training round. To this end, we formulate the aggregation phase in FL to a personalized group knowledge transfer training algorithm dubbed KT-pFL, whose main idea is to allow each client to maintain a personalized soft prediction at the server that can be updated by a linear combination of all clients’ local soft predictions using a knowledge coefficient matrix. The principle of doing so is to reinforce the collaboration between clients with similar data distributions. Furthermore, to quantify the contribution of each client to other’s personalized soft prediction, we parameterize the knowledge coefficient matrix so that it can be trained simultaneously with the models following an alternating way in each iteration round. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            387
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We show that KT-pFL not only breaks down the barriers of homogeneous model restriction, which requires to transfer the entire parameters set in each round, whose data volume is much larger than that of the soft prediction, but also improves the training efficiency by using a parameterized update mechanism. Experimental results on different datasets and models show that our method can significantly improve the training efficiency and reduce the communication overhead. Our contributions are: ",
+        "bbox": [
+            174,
+            393,
+            825,
+            477
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• To the best of our knowledge, this paper is the first to study the personalized knowledge transfer in FL. We propose a novel training framework, namely, KT-pFL, that maintains a personalized soft prediction for each client in the server to transfer knowledge among all clients. • To encourage clients with similar data distribution to collaborate with each other during the training process, we propose the ‘knowledge coefficient matrix’ to identify the contribution from one client to others’ local training. To show the efficiency of the parameterized method, we compared KT-pFL with two non-parameterized learning methods, i.e., TopK-pFL and Sim-pFL, which calculate the knowledge coefficient matrix on the cosine similarity between different model parameters. • We provide theoretical performance guarantee for KT-pFL and conduct extensive experiments over various deep learning models and datasets. The efficiency superiority of KT-pFL is demonstrated by comparing our proposed training framework with traditional pFL methods. ",
+        "bbox": [
+            173,
+            484,
+            826,
+            636
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            661,
+            321,
+            679
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Personalized FL with Homogeneous Models. Recently, various approaches have been proposed to realize personalized FL with homogeneous local model structure, which can be categorized into three types according to the number of global models applied in the server, i.e., single global model, multiple global models and no global model. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            752
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "single global model type is a close variety of conventional FL, e.g., FedAvg [1], that combine global model optimization process with additional local model customization, and consist of four different kinds of approaches: local fine-tuning [20–23], regularization (e.g., pFedMe [6], L2SGD [7, 24], Ditto [25]), hybrid local and global models [11, 26, 27] and meta learning [9, 28]. All of these pFL methods apply a single global model, and thus limit the customized level of the local model at the client side. Therefore, some researchers [8, 10, 11] propose to train multiple global models at the server, where clients are clustered into several groups according to their similarity and different models are trained for each group. FedAMP [8] and FedFomo [29] can be regarded as special cases of the clustered-based method that each client owns a personalized global model at the server side. As a contrast, some literature waive the global model to deal with the heterogeneity problem [30, 31], such as multi-task learning based (i.e., MOCHA [31]) and hypernetwork-based framework (i.e., ",
+        "bbox": [
+            174,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "FedHN [30]). However, all these methods require aggregating the model parameters from the clients, who have to apply identical model structure and size, which hinders further personalization, e.g., employing personalized model architectures for heterogeneous clients is not feasible. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Heterogeneous FL and Knowledge Distillation. To enable heterogeneous model architectures in FL, Diao et al. [32] propose to upload a different subset of global model to the server for aggregation with the objective to produce a single global inference model. Another way of personalization is to use Knowledge Distillation (KD) in heterogeneous FL systems ([12, 14, 15, 17–19, 33, 34]). The principle is to aggregate local soft-predictions instead of local model parameters in the server, whereby each client can update the local model to approach the averaged global predictions. As KD is independent with model structure, some literature [13, 16] are proposed to take advantage of such independence to implement personalized FL with heterogeneous models at client sides. For example, Li et al. [13] propose FedMD to perform ensemble distillation for each client to learn well-personalized models. Different from FedMD that exchanging soft-predictions between the clients and the server, FedDF [16] first aggregates local model parameters for model averaging at the server side. Then, the averaged global models can be updated by performing knowledge transfer from all received (heterogeneous) client models. ",
+        "bbox": [
+            173,
+            138,
+            826,
+            319
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To sum up, most of these schemes construct an ensembling teacher by simply averaging the teachers’ soft predictions, or by heuristically combining the output of the teacher models, which are far away from producing optimal combination of teachers. In our framework, KD is used in a more efficient way that the weights of the clients’ soft predictions are updated together with the model parameters during every FL training iteration. ",
+        "bbox": [
+            173,
+            325,
+            825,
+            395
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Problem Formulation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            414,
+            387,
+            431
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We aim to collaboratively train personalized models for a set of clients applying different model structures in FL. Consider supervised learning whose goal is to learn a function that maps every input data to the correct class out of $\\mathcal { C }$ possible options. We assume that there are $N$ clients, and each client $n$ can only access to his private dataset $\\mathbf { \\widetilde { D } } _ { n } : = \\{ x _ { i } ^ { n } , y _ { i } \\}$ , where $x _ { i }$ is the $i$ -th input data sample, $y _ { i }$ is the corresponding label of $x _ { i }$ , $y _ { i } \\in \\{ 1 , 2 , \\cdots , \\dot { C } \\}$ . The number of data samples in dataset $\\mathbb { D } _ { n }$ is denoted by $D _ { n }$ . $\\mathbb { D } = \\{ \\mathbb { D } _ { 1 } , \\mathbb { D } _ { 2 } , \\cdot \\cdot \\cdot , \\mathbb { D } _ { N } \\}$ , $\\begin{array} { r } { D = \\sum _ { n = 1 } ^ { N } D _ { n } } \\end{array}$ . In conventional $\\mathrm { F L }$ , the goal of the learning system is to learn a global model w that minimizes the total empirical loss over the entire dataset $\\mathbb { D }$ : ",
+        "bbox": [
+            173,
+            444,
+            826,
+            559
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aa5e51535d9091dfbb7900157c5f26809a599de1346200aeac92d5daaf12b484.jpg",
+        "text": "$$\n\\underset { \\mathbf { w } } { \\mathop { \\operatorname* { m i n } } } \\mathcal { L } ( \\mathbf { w } ) : = \\sum _ { n = 1 } ^ { N } \\frac { D _ { n } } { D } \\mathcal { L } _ { n } ( \\mathbf { w } ) , \\mathrm { ~ w h e r e ~ } \\mathcal { L } _ { n } ( \\mathbf { w } ) = \\frac { 1 } { D _ { n } } \\sum _ { i = 1 } ^ { D _ { n } } \\mathcal { L } _ { C E } ( \\mathbf { w } ; x _ { i } , y _ { i } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            256,
+            561,
+            738,
+            606
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { L } _ { n } ( \\mathbf { w } )$ is the $n$ -th client’s local loss function that measures the local empirical risk over the private dataset $\\mathbb { D } _ { n }$ and $\\mathcal { L } _ { C E }$ is the cross-entropy loss function that measures the difference between the predicted values and the ground truth labels. ",
+        "bbox": [
+            174,
+            609,
+            823,
+            652
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "However, this formulation requires all local clients to have a unified model structure, which cannot be extended to more general cases where each client applies a unique model. Therefore, we need to reformulate the above optimization problem to break the barrier of homogeneous model structure. Besides, given the Non-IID clients’ datasets, it is inappropriate to just minimize the total empirical loss (i.e., $\\begin{array} { r } { \\operatorname* { m i n } _ { \\mathbf { w } ^ { 1 } , \\cdots , \\mathbf { w } ^ { N } } \\mathcal { L } ( \\mathbf { w } ^ { 1 } , \\cdots , \\mathbf { w } ^ { N } ) : = \\sum _ { n = 1 } ^ { N } \\frac { D _ { n } } { D } \\bar { L } _ { n } ( \\mathbf { w } ^ { n } ) ) } \\end{array}$ . To that end, we propose the following training framework: ",
+        "bbox": [
+            173,
+            657,
+            825,
+            744
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 3.1. Let $s ( \\mathbf { w } ^ { n } , \\hat { x } )$ denote the collaborative knowledge from client $n$ , and $\\hat { x }$ denote a data sample from a public dataset $\\mathbb { D } _ { r }$ that all clients can access to. Define the personalized loss function of client $n$ as ",
+        "bbox": [
+            174,
+            747,
+            825,
+            790
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6dad1b5c5449f5bede2081b88fe38d63aeb5916ec6d42f33b8df520e39ce3154.jpg",
+        "text": "$$\n\\mathcal { L } _ { p e r , n } ( \\mathbf { w } ^ { n } ) : = \\mathcal { L } _ { n } ( \\mathbf { w } ^ { n } ) + \\lambda \\sum _ { \\hat { x } \\in \\mathbb { D } _ { r } } \\mathcal { L } _ { K L } \\left( \\sum _ { m = 1 } ^ { N } c _ { m n } \\cdot s ( \\mathbf { w } ^ { m } , \\hat { x } ) , s ( \\mathbf { w } ^ { n } , \\hat { x } ) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            792,
+            745,
+            837
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda > 0$ is a hyper-parameters, $\\mathcal { L } _ { K L }$ stands for Kullback–Leibler (KL) Divergence function and is added to the loss function to transfer personalized knowledge from a teacher to another. $c _ { m n }$ is the knowledge coefficient which is used to estimate the contribution from client $m$ to $n$ . The second term in (2) allows each client to build his own personalized aggregated knowledge in the server and enhance the collaboration effect between clients with large c. The concept of collaborative knowledge can either refer to soft predictions or model parameters depending on the definition in different situations. For example, $s ( \\mathbf { w } ^ { n } , \\hat { x } )$ can be deemed to be a soft prediction of the client $n$ , which are calculated with the softmax of logits $z ^ { n }$ , i.e., $\\begin{array} { r } { s ( \\mathbf { w } ^ { n } , \\hat { x } ) = \\frac { \\exp ( z _ { c } ^ { n } / T ) } { \\sum _ { c = 1 } ^ { C } \\exp ( z _ { c } ^ { n } / T ) } } \\end{array}$ , logits $z ^ { n }$ is the output of the last fully connected layer on client $n$ ’s model, $T$ is the temperature hyperparameter of the softmax function. ",
+        "bbox": [
+            173,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/d660a020c4cc893c460788d8aac599c2ab7f9b98990ecfe742760411704b1e9e.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of the KT-pFL framework. The workflow includes 6 steps: $\\textcircled{1}$ local training on private data; $\\textcircled{2}$ , $\\textcircled{3}$ each client outputs the local soft prediction on public data and sends it to the server; $\\textcircled{4}$ the server calculates each client��s personalized soft prediction via a linear combination of local soft predictions and knowledge coefficient matrix; $\\textcircled{5}$ each client downloads the personalized soft prediction to perform distillation phase; $\\textcircled{6}$ the server updates the knowledge coefficient matrix. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            88,
+            812,
+            256
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            357,
+            826,
+            435
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 3.2. We define $\\mathbf { c } \\in \\mathbb { R } ^ { N \\times N }$ as the knowledge coefficient matrix: ",
+        "bbox": [
+            174,
+            439,
+            661,
+            455
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e440efd1e386297335fa8fdce15133cd94f5648af5c98ae9dda3183d08b37bed.jpg",
+        "text": "$$\n\\mathbf { c } = \\left. \\begin{array} { c c c c } { c _ { 1 1 } } & { c _ { 1 2 } } & { \\cdots } & { c _ { 1 N } } \\\\ { c _ { 2 1 } } & { c _ { 2 2 } } & { \\cdots } & { c _ { 2 N } } \\\\ { \\vdots } & { \\vdots } & { \\ddots } & { \\vdots } \\\\ { c _ { N 1 } } & { c _ { N 2 } } & { \\cdots } & { c _ { N N } } \\end{array} \\right. .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            465,
+            609,
+            532
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our objective is to minimize ",
+        "bbox": [
+            173,
+            541,
+            362,
+            555
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/70cfcbe05619bc003624726758fbaf2e9a022995c390a2657c3488a94ff429b2.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\mathbf { w } , \\mathbf { c } } \\mathcal { L } ( \\mathbf { w } , \\mathbf { c } ) : = \\sum _ { n = 1 } ^ { N } \\frac { D _ { n } } { D } \\mathcal { L } _ { p e r , n } ( \\mathbf { w } ^ { n } ) + \\rho \\| \\mathbf { c } - \\frac { \\mathbf { 1 } } { N } \\| ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            564,
+            671,
+            607
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { w } = [ \\mathbf { w } ^ { 1 } , \\cdots , \\mathbf { w } ^ { N } ] \\in \\mathbb { R } ^ { \\sum _ { n = 1 } ^ { N } d _ { n } }$ is the concatenated vector of all weights, $d _ { n }$ represents the dimensions of model parameter $\\mathbf { w } ^ { n }$ . $\\mathbf { 1 } \\in \\mathbb { R } ^ { n ^ { 2 } }$ is the identity matrix whose elements are all equal to 1. The second term in (4) is a regularization term that ensures generalization ability of the whole learning system. Without the regularization term, a client with a completely different data distribution tends to set large values of the knowledge coefficient (i.e., equal to 1), and no collaboration will be conducted during training in this case. $\\rho$ is a regularization parameter that is larger than 0. ",
+        "bbox": [
+            173,
+            616,
+            826,
+            707
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 KT-pFL Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            733,
+            366,
+            751
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce the proposed KT-pFL algorithm, where the local model parameters and knowledge coefficient matrix are updated alternatively. To enable personalized knowledge transfer in FL, we train personalized models locally according to the related collaborative knowledge. Insert (2) into (4), and we can design an alternating optimization approach to solve (4), that in each round we fix either w or c by turns, and optimize the unfixed one following an alternating way until a convergence point is reached. ",
+        "bbox": [
+            173,
+            765,
+            825,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Update w: In each communication round, we first fix c and optimize (train) w for several epochs locally. In this case, updating w depends on both the private data (i.e., $\\mathcal { L } _ { C E }$ on $\\mathbb { D } _ { n } , n \\in [ 1 , \\cdots , N ] )$ , that can only be accessed by the corresponding client, and the public data (i.e., $\\mathcal { L } _ { K L }$ on $\\mathbb { D } _ { r }$ ), which is accessible for all clients. We propose a two-stage updating framework for w: ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 KT-pFL Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            390,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Input: $\\mathbb { D }$ , $\\mathbb { D } _ { r }$ , $\\eta _ { 1 } , \\eta _ { 2 } , \\eta _ { 3 }$ and $T$   \nOutput: $\\mathbf { w } = [ \\mathbf { w } ^ { 1 } , \\cdots , \\mathbf { w } ^ { N } ]$   \n1: Initialize $\\mathbf { w } _ { 0 }$ and $\\mathbf { c } _ { 0 }$   \n2: procedure SERVER-SIDE OPTIMIZATION   \n3: Distribute $\\mathbf { w } _ { 0 }$ and $\\mathbf { c } _ { 0 }$ to each client   \n4: for each communication round $t \\in \\{ 1 , 2 , . . . , T \\}$ do   \n5: for each client $n$ in parallel do   \n6: $\\mathbf { w } _ { t + 1 } ^ { n }  C l i e n t L o c a l U p d a t e ( n , \\mathbf { w } _ { t } ^ { n } , \\mathbf { c } _ { t , n } )$   \n7: Update knowledge coefficient matrix c via (7)   \n8: Distribute $\\mathbf { c } _ { t + 1 }$ to all clients   \n9: procedure CLIENTLOCALUPDATE $\\mathbf { \\Delta } _ { : } ( n , \\mathbf { w } _ { t } ^ { n } , \\mathbf { c } _ { t , n } )$   \n10: Client $n$ receives $\\mathbf { w } _ { t } ^ { n }$ and $\\mathbf { c } _ { n }$ from the server   \n11: for each local epoch $i$ from 1 to $E$ do   \n12: for mini-batch $\\xi _ { t } \\subseteq \\mathbb { D } _ { n }$ do   \n13: Local Training: update model parameters on private data via (5)   \n14: for each distillation step $j$ from 1 to $R$ do   \n15: for mini-batch $\\xi _ { r , t } \\subseteq \\mathbb { D } _ { r }$ do   \n16: Distillation: update model parameters on public data via (6)   \nreturn local parameters $\\mathbf { w } _ { t + 1 } ^ { n }$ ",
+        "bbox": [
+            178,
+            108,
+            705,
+            381
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Local Training: Train w on each client’s private data by applying a gradient descent step: ",
+        "bbox": [
+            173,
+            409,
+            771,
+            424
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b0c7bf7041855e94cfb6cbd5f80cce399d13a091bf5fa682267b57fdfcf0e726.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { w } ^ { n }  \\mathbf { w } ^ { n } - \\eta _ { 1 } \\nabla _ { \\mathbf { w } ^ { n } } \\mathcal { L } _ { n } ( \\mathbf { w } ^ { n } ; \\boldsymbol { \\xi } _ { n } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            429,
+            617,
+            445
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\xi _ { n }$ denotes the mini-batch of data $\\mathbb { D } _ { n }$ used in local training, $\\eta _ { 1 }$ is the learning rate. ",
+        "bbox": [
+            183,
+            450,
+            769,
+            465
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Distillation: Transfer knowledge from personalized soft prediction to each local client based on public dataset: ",
+        "bbox": [
+            173,
+            468,
+            826,
+            497
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a268301261f72a998089e3e56c593254d40a2ebf6f2507f38711c13f1284bc29.jpg",
+        "text": "$$\n\\mathbf { w } ^ { n }  \\mathbf { w } ^ { n } - \\eta _ { 2 } \\nabla _ { \\mathbf { w } ^ { n } } \\mathcal { L } _ { K L } ( \\sum _ { m = 1 } ^ { N } \\mathbf { c } _ { m } ^ { * , T } \\cdot s ( \\mathbf { w } ^ { m } , \\boldsymbol { \\xi } _ { r } ) , s ( \\mathbf { w } ^ { n } , \\boldsymbol { \\xi } _ { r } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            502,
+            717,
+            545
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\xi _ { r }$ denotes the mini-batch of public data $\\mathbb { D } _ { r }$ , and $\\eta _ { 2 }$ is the learning rate. c ∗m $\\mathrm { ~ \\bf ~ c ~ } _ { m } ^ { * } =$ $[ c _ { m 1 } , c _ { m 2 } , \\cdots , c _ { m N } ]$ is the knowledge coefficient vector for client $m$ , which can be found in $m$ -th row of $\\mathbf { c }$ . Note that all collaborative knowledge and knowledge coefficient matrix are required to obtain the personalized soft prediction in this stage, which can be collected in the server. ",
+        "bbox": [
+            184,
+            549,
+            825,
+            604
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Update c: After updating w locally for several epochs, we turn to fix w and update $\\mathbf { c }$ in the server. ",
+        "bbox": [
+            174,
+            606,
+            820,
+            619
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/550ff9693ace039723b2be5f91e5d150324f039b2b159a52b3ad8f0b41099d43.jpg",
+        "text": "$$\n\\mathbf { c } \\gets \\mathbf { c } - \\eta _ { 3 } \\lambda \\sum _ { n = 1 } ^ { N } \\frac { D _ { n } } { D } \\nabla _ { \\mathbf { c } } \\mathcal { L } _ { K L } \\left( \\sum _ { m = 1 } ^ { N } \\mathbf { c } _ { m } \\cdot s ( \\mathbf { w } ^ { m , * } , \\boldsymbol { \\xi } _ { r } ) , s ( \\mathbf { w } ^ { n , * } , \\boldsymbol { \\xi } _ { r } ) \\right) - 2 \\eta _ { 3 } \\rho ( \\mathbf { c } - \\frac { 1 } { N } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            625,
+            782,
+            669
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\eta _ { 3 }$ is the learning rate for updating c. ",
+        "bbox": [
+            174,
+            671,
+            459,
+            686
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 demonstrates the proposed KT-pFL algorithm and the idea behind it is shown in Figure 1. In every communication round of training, the clients use local SGD to train several epochs based on the private data and then send the collaborative knowledge (e.g., soft predictions on public data) to the server. When the server receives the collaborative knowledge from each client, it aggregates them to form the personalized soft predictions according to the knowledge coefficient matrix. The server then sends back the personalized soft prediction to each client to perform local distillation. The clients then iterate for multiple steps over public dataset 2. After that, the knowledge coefficient matrix is updated in the server while fixing the model parameters w. ",
+        "bbox": [
+            173,
+            691,
+            826,
+            804
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Performance Guarantee. Theorem 4.1 provides the performance analysis of the personalized model when each client owns Non-IID data. Detailed description and derivations are deferred to Appendix A. ",
+        "bbox": [
+            174,
+            809,
+            826,
+            852
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 4.1. Denote the n-th local distribution and its empirical distribution by $\\mathcal { D } _ { n }$ and $\\hat { \\mathcal { D } } _ { n }$ respectively, and the hypothesis $h \\in \\mathcal H$ trained on $\\hat { \\mathcal { D } } _ { n }$ by $h _ { \\hat { \\mathcal { D } } _ { n } }$ . There always exist $c _ { m , n } ^ { * } , m = 1 , \\ldots , N ,$ uch that the expected loss of the personalized ensemble model for the dais not larger than that of the single model only trained with local data: $\\mathcal { D } _ { n }$ $n$ $\\begin{array} { r } { \\mathcal { L } _ { \\mathcal { D } _ { n } } ( \\sum _ { m = 1 } ^ { N } c _ { m , n } ^ { * } h _ { \\hat { D } _ { m } } ) ^ { } \\leq } \\end{array}$ $\\mathcal { L } _ { D _ { n } } ( h _ { \\hat { D } _ { n } } )$ . Besides, there exist some problems where the personalized ensemble model is strictly better, i.e., $\\begin{array} { r } { \\mathcal { L } _ { \\mathcal { D } _ { n } } ( \\sum _ { m = 1 } ^ { N } c _ { m , n } ^ { * } h _ { \\hat { \\mathcal { D } } _ { m } } ) < \\mathcal { L } _ { \\mathcal { D } _ { n } } ( h _ { \\hat { \\mathcal { D } } _ { n } } ) , } \\end{array}$ . ",
+        "bbox": [
+            176,
+            856,
+            823,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            160
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 4.1 indicates that the performance of the personalized ensemble model under some suitable coefficient matrices is better than that of the model only trained on its local private data, which theoretically demonstrates the necessity of the parameterized personalization. However, it is challenging to find such matrices due to the complexity and diversity of machine learning models and data distributions. In this paper, our designed algorithm KT-pFL can find the desired coefficient matrix in a gradient descent manner, hence achieving the performance boost. Besides, we have the similar claim for the relationship between the personalized ensemble model and average ensemble model. ",
+        "bbox": [
+            173,
+            169,
+            825,
+            267
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Remark 4.1. There always exist $c _ { m , n } ^ { * } , m = 1 , \\ldots , N$ , such that the expected loss of the personalized ensemble model for the data distribution $\\mathcal { D } _ { n }$ of client $n$ is not larger than that of the average ensemble model: $\\begin{array} { r } { \\ L \\dot { \\mathcal L } _ { \\mathcal D _ { n } } ( \\sum _ { m = 1 } ^ { N } c _ { m , n } ^ { * } h _ { \\hat { \\mathcal D } _ { m } } ) \\leq { \\mathcal L } _ { \\mathcal D _ { n } } ( \\frac { 1 } { N } \\sum _ { m = 1 } ^ { N } h _ { \\hat { \\mathcal D } _ { m } } ) } \\end{array}$ . Besides, there exist some problems where the personalized ensemble model is strictly better, i.e., $\\begin{array} { r } { \\mathcal { L } _ { \\mathcal { D } _ { n } } ( \\sum _ { m = 1 } ^ { N } c _ { m , n } ^ { * } h _ { \\hat { D } _ { m } } ) ^ { } < } \\end{array}$ $\\begin{array} { r } { \\mathcal { L } _ { \\mathcal { D } _ { n } } \\big ( \\frac { 1 } { N } \\sum _ { m = 1 } ^ { N } h _ { \\hat { \\mathcal { D } } _ { m } } \\big ) } \\end{array}$ . ",
+        "bbox": [
+            173,
+            271,
+            825,
+            358
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Evaluations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            375,
+            303,
+            391
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 Experimental Setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            405,
+            351,
+            420
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Task and Datasets We evaluate our proposed training framework on three different image classification tasks: EMNIST [35], Fashion_MNIST [36] and CIFAR-10 [37]. For each dataset, we apply two different Non-IID data settings: 1) each client only contains two classes of samples; 2) each client contains all classes of samples, while the number of samples for each class is different from that of a different client. All datasets are split randomly with $7 5 \\%$ and $2 5 \\%$ for training and testing, respectively. The testing data on each client has the same distribution with its training data. For all methods, we record the average test accuracy of all local models for evaluation. ",
+        "bbox": [
+            173,
+            431,
+            825,
+            529
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Model Structure: Four different lightweight model structures including LeNet [38], AlexNet [39], ResNet-18 [40], and ShuffleNetV2 [41] are adopted in our experiments. Our pFL system has 20 clients, who are assigned with four different model structures, i.e., five clients per model. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            577
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines: Although KT-pFL is designed for effective personalized federated learning, it can be applied to both heterogeneous and homogeneous model cases. We first conduct experiments on heterogeneous systems where the neural architecture of the local models are different among clients. We compare the performance of KT-pFL to the non-personalized distillation-based methods: FedMD [13], FedDF [16] and the personalized distillation-based method pFedDF3 and other simple versions of KT-pFL including Sim-pFL and TopK-pFL. Sim-pFL calculates the knowledge coefficient by using cosine similarity between two local soft predictions. Instead of combining the knowledge from all clients, TopK-pFL obtains the personalized soft predictions only from $K$ clients4 who have higher value of cosine similarity. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            708
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the generalization and effectiveness of our proposed training framework, we further compare KT-pFL to FedAvg [1] and state-of-the-art pFL methods including Per-Fedavg [9], FedavgLocal FT[23], pFedMe [6], FedAMP [8], FedFomo[29] and FedHN[30] under the homogeneous model setting. Note that Per-FedAvg is a MAML-based method which aims to optimize the one-step gradient update for its personalized model. pFedMe and FedAMP are two regularized-based methods. The former one obtains personalized models by controlling the distance between local model and global model, while the later one facilitates the collaboration of clients with similar data distribution. ",
+        "bbox": [
+            173,
+            714,
+            826,
+            811
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation The experiments are implemented in PyTorch. We simulate a set of clients and a centralized server on one deep learning workstation (i.e., Intel(R) Core(TM) i9-9900KF CPU $@$ 3.6GHz with one NVIDIA GeForce RTX 2080Ti GPU). ",
+        "bbox": [
+            174,
+            818,
+            823,
+            859
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/74af6526f3592c8b260ec54e74a7327e932c5a1ed7046ae4b72d1e54771f20d9.jpg",
+        "image_caption": [
+            "Figure 2: Performance comparison of FedMD, FedDF, pFedDF, TopK-pFD, Sim-pFD, and KT-pFL in average test accuracy on three datasets (Non-IID case 1: each client contains all labels). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            102,
+            812,
+            233
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/6a57aa1bb45a428a65357e2d48250d3b650620ead399beba7a9a58475c028e0b.jpg",
+        "image_caption": [
+            "Figure 3: Performance comparison of FedMD, FedDF, pFedDF, TopK-pFD, Sim-pFD, and KT-pFL in average test accuracy on three datasets (Non-IID case 2: each client contains only two labels). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            290,
+            812,
+            422
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 Results ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            479,
+            264,
+            493
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Subject to space constraints, we only report the most important experimental results in this section. Please refer to Appendix B for the details of different Non-IID data settings on EMNIST, Fashion_MNIST and CIFAR10, the implementation details and the hyperparameter settings of all the methods, and also extra results about the convergence and robustness analysis. In our experiments, we run each experiment multiple times and record the average results. ",
+        "bbox": [
+            174,
+            505,
+            826,
+            574
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/880a1eb2c0c6ac19aae115d44db25ab3f190a22d3fb499d57c6f0497fb534365.jpg",
+        "table_caption": [
+            "Table 1: The comparison of final test accuracy $( \\% )$ on different datasets with heterogeneous models (i.e., Lenet, AlexNet, ResNet-18 and ShuffleNetV2). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">EMNIST</td><td colspan=\"2\">Fashion_MNIST</td><td colspan=\"2\">CIFAR-10</td></tr><tr><td>Non-IID_1</td><td>Non-IID_2</td><td>Non-IID_1</td><td>Non-IID_2</td><td>Non-IID_1</td><td>Non-IID_2</td></tr><tr><td>FedMD [13]</td><td>71.37</td><td>70.15</td><td>68.02</td><td>66.10</td><td>39.14</td><td>35.56</td></tr><tr><td>FedDF[16]</td><td>71.92</td><td>72.79</td><td>70.32</td><td>70.83</td><td>40.19</td><td>37.81</td></tr><tr><td>pFedDF</td><td>78.59</td><td>75.72</td><td>72.69</td><td>73.45</td><td>42.83</td><td>39.54</td></tr><tr><td>Sim-pFD</td><td>82.72</td><td>74.42</td><td>72.82</td><td>72.71</td><td>42.50</td><td>39.90</td></tr><tr><td>TopK-pFD</td><td>83.00</td><td>73.91</td><td>72.24</td><td>73.39</td><td>42.58</td><td>39.34</td></tr><tr><td>KT-pFL</td><td>84.65</td><td>76.30</td><td>75.48</td><td>75.60</td><td>43.82</td><td>41.04</td></tr></table>",
+        "bbox": [
+            196,
+            622,
+            802,
+            747
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2.1 Performance Comparison ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            770,
+            405,
+            785
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Heterogeneous FL. For all the methods and all the data settings, the batch size on private data and public data are 128 and 256, respectively, the number of local epochs is 20 and the distillation steps is 1 in each communication round of pFL training. Unless mentioned, otherwise the public data used for EMNIST and Fashion_MNIST is MNIST, and the public data used for CIFAR-10 is CIFAR-100. the size of public data used in each communication round is 3000, the learning rate is set to 0.01 for EMNIST and Fashion_MNIST, and 0.02 for CIFAR-10. ",
+        "bbox": [
+            173,
+            792,
+            826,
+            877
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 and 3 show the curves of the average test accuracy during the training process on four different models with three datasets, which include the results of FedMD, FedDF, pFedDF, Sim-pFL, ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/1942cb395f74e84ecf698ebc6c71d40acecfbfd316ff33397347abd9661434af.jpg",
+        "image_caption": [
+            "Figure 4: Performance comparison of FedAvg, Per-Fedavg, Fedavg-Local FT, pFedMe, FedAMP, FedFomo, FedHN and KT-pFL in average test accuracy on three datasets. The Non-IID data setting: each client contains all labels. 20 clients with homogeneous models: CNN [1]. Learning rate: 0.005. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            102,
+            816,
+            232
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/a2f670b154f4d8cdc80db691eb3609620a574ad83b09d8dc8fc73cab8581b4a4.jpg",
+        "table_caption": [
+            "Table 2: The comparison of final test accuracy $( \\% )$ on different datasets with different number of homogeneous models (i.e., the same CNN architecture as [1]). For large-scale FL system with 100 clients, we set the client sampling rate as 0.1. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">EMNIST</td><td colspan=\"2\">Fashion_MNIST</td><td colspan=\"2\">CIFAR-10</td></tr><tr><td>20 clients</td><td>100 clients</td><td>20 clients</td><td>100 clients</td><td>20 clients</td><td>100 clients</td></tr><tr><td>Fedavg [1]</td><td>85.86</td><td>76.84</td><td>80.69</td><td>72.36</td><td>51.94</td><td>43.56</td></tr><tr><td>Per-Fedavg [9]</td><td>86.16</td><td>82.87</td><td>85.91</td><td>77.93</td><td>55.61</td><td>49.82</td></tr><tr><td>Fedavg-Local FT[23]</td><td>86.59</td><td>84.55</td><td>90.17</td><td>80.93</td><td>42.88</td><td>50.91</td></tr><tr><td>pFedMe [6]</td><td>84.26</td><td>86.14</td><td>90.97</td><td>84.02</td><td>62.79</td><td>52.46</td></tr><tr><td>FedAMP[8]</td><td>88.51</td><td>85.63</td><td>90.79</td><td>84.72</td><td>60.75</td><td>51.26</td></tr><tr><td>FedFomo [29]</td><td>92.58</td><td>90.08</td><td>88.33</td><td>87.76</td><td>63.11</td><td>55.73</td></tr><tr><td>pFedHN[30]</td><td>94.27</td><td>92.21</td><td>92.22</td><td>89.14</td><td>65.31</td><td>57.38</td></tr><tr><td>KT-pFL</td><td>94.40</td><td>92.50</td><td>93.93</td><td>90.37</td><td>66.96</td><td>58.29</td></tr></table>",
+        "bbox": [
+            181,
+            354,
+            815,
+            503
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "TopK-pFL and KT-pFL. We also summarize the final average test accuracy in Table 1. In two cases of Non-IID settings, KT-pFL obtains comparable or even better accuracy performance than others. The performances of FedMD, FedDF, pFedDF are worse than the other three methods. The reason is that taking the global aggregation of all local soft predictions trained on the Non-IID data from different clients produces only one global soft prediction, which cannot be well adapted to each client. The other two personalized methods, i.e., Sim-pFL and TopK-pFL, achieve comparably performance on most of cases with pFedDF. Our proposed method KT-pFL has the best performance, because each client can adaptively aggregate all local soft predictions to form a personalized one instead of being restricted to a global soft prediction. ",
+        "bbox": [
+            173,
+            537,
+            826,
+            662
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Homogeneous FL. Apart from heterogeneous system, we further extend KT-pFL to homogeneous model setting. To conduct fair comparison with baselines, we exchange model parameters with the server to perform knowledge transfer. Specifically, each client maintains a personalized global model at the server side and each personalized global model is aggregated by a linear combination of local model parameters and knowledge coefficient matrix (Appendix C). In this case, we compare the performance of homogeneous-version of KT-pFL with FedAvg, Per-Fedavg, Fedavg-Local FT, pFedMe, FedAMP, FedFomo and FedHN. Figure 4 and Table 2 show the curve of the average test accuracy during training and the final average test accuracy on three different datasets, respectively. For all datasets, KT-pFL dominates the other seven methods on average test accuracy with less variance. Besides, the concept of FedAMP and FedFomo is similar with our proposed method KT-pFL. The difference is that the weights for each local model during personalized aggregation phase are updated in a gradient descent manner in KT-pFL. ",
+        "bbox": [
+            173,
+            670,
+            825,
+            835
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To verify the efficiency of KT-pFL on large-scale FL system, we conduct experiments on 100 clients and apply the same client selection mechanism as other baselines. Specifically, in KT-pFL, only partial of elements in the knowledge coefficient matrix c will be updated in each communication round on large-scale FL systems. From the results in Table 2, it is obvious that our proposed method can work well both on small-scale and large-scale FL systems. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/6d475cb8c07f64ea6bf36e938c1694b07946570e17a396e2de4cf0a15940cbb9.jpg",
+        "table_caption": [
+            "Table 3: The comparison of final test accuracy on different setting of local epochs $E$ and distillation steps $R$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Dataset</td><td colspan=\"4\"># Local epochs (E)</td><td colspan=\"4\"># Distillation steps (R)</td></tr><tr><td>5</td><td>10</td><td>15</td><td>20</td><td>1</td><td>2</td><td>3</td><td>5</td></tr><tr><td>EMNIST (%)</td><td>90.15</td><td>92.76</td><td>91.03</td><td>90.15</td><td>91.76</td><td>91.40</td><td>91.18</td><td>91.54</td></tr><tr><td>Fashion_MNIST (%)</td><td>88.73</td><td>89.14</td><td>88.58</td><td>89.42</td><td>89.14</td><td>89.90</td><td>89.07</td><td>88.08</td></tr><tr><td>CIFAR-10 (%)</td><td>58.30</td><td>59.38</td><td>59.34</td><td>59.24</td><td>59.24</td><td>57.99</td><td>59.22</td><td>58.91</td></tr></table>",
+        "bbox": [
+            214,
+            125,
+            782,
+            212
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/4272abbcb857768d785d7905e4b21e8c6edd1a2c91941b7a171e4c3cbdf4cd39.jpg",
+        "table_caption": [
+            "Table 4: The comparison of final test accuracy on different setting of regularization parameter $\\rho$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Dataset</td><td colspan=\"4\"># Regularization parameter p</td></tr><tr><td>0.1</td><td>0.3</td><td>0.5</td><td>0.7</td></tr><tr><td>EMNIST (%)</td><td>90.96</td><td>90.66</td><td>90.88</td><td>91.76</td></tr><tr><td>Fashion_MNIST (%)</td><td>89.49</td><td>89.30</td><td>89.56</td><td>89.14</td></tr><tr><td>CIFAR-10 (%)</td><td>59.08</td><td>58.52</td><td>59.56</td><td>58.40</td></tr></table>",
+        "bbox": [
+            318,
+            251,
+            678,
+            338
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2.2 Effect of hyperparameters ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            367,
+            408,
+            382
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To understand how different hyperparameters such as $E$ , $R$ , $\\rho$ , and $\\left| \\mathbb { D } _ { r } \\right|$ can affect the training performance of KT-pFL in different settings, we conduct various experiments on three datasets with η1 = η2 = η3 = 0.01. ",
+        "bbox": [
+            176,
+            390,
+            825,
+            433
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effect of Local Epochs $E$ . To reduce communication overhead, the server tends to allow clients to have more local computation steps, which can lead to less global updates and thus faster convergence. Therefore, we monitor the behavior of KT-pFL using a number of values of $E$ , whose results are given in Table 3. The results show that larger values of $E$ can benefit the convergence of the personalized models. There is, nevertheless, a trade-off between the computations and communications, i.e., while larger $E$ requires more computations at local clients, smaller $E$ needs more global communication rounds to converge. To do such trade-off, we fix $E = 2 0$ and evaluate the effect of other hyperparameters accordingly. ",
+        "bbox": [
+            173,
+            439,
+            826,
+            551
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effect of Distillation Steps $R$ . As the performance of the knowledge transfer is directly related to the number of distillation steps $R$ , we compare the performance of KT-pFL under different setting of distillation steps (e.g., $R = 1 , 2 , 3 , 5$ ). The number of local epochs is set to 20. The results show that larger value of $R$ cannot always lead to better performance, which means a moderate number of the distillation steps is necessary to approach to the optimal performance. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            626
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effect of $\\rho$ . As mentioned in Eq (4), $\\rho$ is the regularization term to do the trade-off between personalization ability and generalization ability. For example, larger value of $\\rho$ means that the knowledge coefficient of each local soft prediction should approach to $\\scriptstyle { \\frac { 1 } { N } }$ , and thus more generalization ability should be guaranteed. Table 4 shows the results of $\\mathrm { K T - p F L }$ with different value of $\\rho$ . In most settings, a significantly large value of $\\rho$ will hurt the performance of KT-pFL. ",
+        "bbox": [
+            173,
+            632,
+            826,
+            702
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/5624d6e1bdd823b4f4704bc4e583cd2af20b3376bc2992af95d4cc5f3e99c8cf.jpg",
+        "table_caption": [
+            "Table 5: Performance of KT-pFL under different setting of public dataset (Task: Fashion_MNIST; Unlabeled Open Dataset: divided from Fashion_MNIST). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Public dataset</td><td>Test Accuracy</td></tr><tr><td>MNIST</td><td>89.14 (± 0.15)</td></tr><tr><td>EMNIST</td><td>88.76(± 0.21)</td></tr><tr><td>Unlabeled Open Dataset</td><td>89.03 (± 0.11)</td></tr></table>",
+        "bbox": [
+            346,
+            750,
+            647,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effect of different public dataset. Besides, we compare the performance of our proposed method on different public datasets (Table 5). From the experimental results, we can observe that different settings of the public dataset have little effect on the training performance. ",
+        "bbox": [
+            174,
+            835,
+            825,
+            877
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effect of $\\left| \\mathbb { D } _ { r } \\right|$ . Table 6 demonstrates the effect of public data size $\\left| \\mathbb { D } _ { r } \\right|$ used in local distillation phase. When the size of the public data is increased, KT-pFL has higher average test accuracy. However, very large $\\left| \\mathbb { D } _ { r } \\right|$ will not only slow down the convergence of KT-pFL but also incur higher computation time at the clients. During the experiments, the value of $\\left| \\mathbb { D } _ { r } \\right|$ is configured to 3000. ",
+        "bbox": [
+            173,
+            882,
+            823,
+            912
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/0db24725b13d79bd11d04a000ae33a02bb34a5ef0e26c8c414fa880c39a9947f.jpg",
+        "table_caption": [
+            "Table 6: The comparison of final test accuracy on different setting of the public data size $\\left| \\mathbb { D } _ { r } \\right|$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Dataset</td><td colspan=\"6\"># Size of public data (IDrl)</td></tr><tr><td>10</td><td>100</td><td>500</td><td>1000</td><td>3000</td><td>5000</td></tr><tr><td>EMNIST (%)</td><td>56.19</td><td>73.44</td><td>91.25</td><td>91.47</td><td>91.66</td><td>91.32</td></tr><tr><td>Fashion_MNIST (%)</td><td>50.80</td><td>67.43</td><td>88.08</td><td>89.40</td><td>89.50</td><td>89.14</td></tr><tr><td>CIFAR-10 (%)</td><td>39.08</td><td>47.70</td><td>58.93</td><td>58.79</td><td>58.91</td><td>58.40</td></tr></table>",
+        "bbox": [
+            266,
+            112,
+            730,
+            199
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            233,
+            821,
+            262
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.2.3 Efficiency Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            280,
+            374,
+            295
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the communication overhead, we record three aspects information: Data (batch size used in distillation phase), Param (model parameters) and Soft Prediction without using data compression techniques. The results are shown in Figure 5. Compared with conventional parameter-based pFL methods, the communication overhead on soft prediction-based KT-pFL is far less than Conv-pFL. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            361
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/bc13c78aa8e4f23da5348d1de234aed7c4a4c7e3ae05e8fbb2ece64067909405.jpg",
+        "image_caption": [
+            "Figure 5: Communication Efficiency (X-axis units: MBytes) on three datasets. KL-pFL: soft prediction-based personalized federated learning; Conv-pFL: conventional parameter-based personalized federated learning. (20 models, 30 communication rounds for all datasets. In this experiment, the public dataset is stored on the server.) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            378,
+            820,
+            467
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Broader Impact ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            563,
+            310,
+            580
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "FL has been emerged as new paradigm to collaboratively train models among multiple clients in a privacy-preserving manner. Due to the diversity of users (e.g., statistical and systematic heterogeneity, etc.), applying personalization in FL is essential for future trend. Our method KT-pFL not only breaks the barriers of homogeneous model constraint, which can significantly reduce the communication overhead during training, but also improves the training efficiency via a parameterized update mechanism without additional computation overhead at the client side. This research has the potential to enable various devices to cooperatively train ML tasks based on customized neural network architectures. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            707
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            731,
+            338,
+            747
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This research was supported by the funding from Hong Kong RGC Research Impact Fund (RIF) with the Project No. R5060-19, General Research Fund (GRF) with the Project No. 152221/19E and 15220320/20E, the National Natural Science Foundation of China (61872310), and Shenzhen Science and Technology Innovation Commission (R2020A045). ",
+        "bbox": [
+            176,
+            763,
+            825,
+            819
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            843,
+            266,
+            859
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Agüera y Arcas. Communication-efficient learning of deep networks from decentralized data. In Proceedings of the 20th International Conference on Artificial Intelligence and Statistics, AISTATS, 2017. ",
+        "bbox": [
+            183,
+            869,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[2] Tian Li, Anit Kumar Sahu, Manzil Zaheer, Maziar Sanjabi, Ameet Talwalkar, and Virginia Smith. Federated optimization in heterogeneous networks. In Proceedings of Machine Learning and Systems, MLSys, 2020.   \n[3] Mehryar Mohri, Gary Sivek, and Ananda Theertha Suresh. Agnostic federated learning. In Proceedings of International Conference on Machine Learning, ICML, pages 4615–4625, 2019.   \n[4] Sai Praneeth Karimireddy, Satyen Kale, Mehryar Mohri, Sashank Reddi, Sebastian Stich, and Ananda Theertha Suresh. Scaffold: Stochastic controlled averaging for federated learning. In Proceedings of International Conference on Machine Learning, ICML, pages 5132–5143, 2020.   \n[5] Tian Li, Maziar Sanjabi, Ahmad Beirami, and Virginia Smith. Fair resource allocation in federated learning. In Proceedings of 8th International Conference on Learning Representations, ICLR, 2020.   \n[6] Canh T. Dinh, Nguyen H. Tran, and Tuan Dung Nguyen. Personalized federated learning with moreau envelopes. In Proceedings of Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems, NeurIPS, 2020.   \n[7] Filip Hanzely and Peter Richtárik. Federated learning of a mixture of global and local models. arXiv preprint arXiv:2002.05516, 2020.   \n[8] Yutao Huang, Lingyang Chu, Zirui Zhou, Lanjun Wang, Jiangchuan Liu, Jian Pei, and Yong Zhang. Personalized cross-silo federated learning on non-iid data. In Proceedings of the AAAI Conference on Artificial Intelligence, AAAI, 2021.   \n[9] Alireza Fallah, Aryan Mokhtari, and Asuman E. Ozdaglar. Personalized federated learning with theoretical guarantees: A model-agnostic meta-learning approach. In Proceedings of Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems, NeurIPS, 2020.   \n[10] Avishek Ghosh, Jichan Chung, Dong Yin, and Kannan Ramchandran. An efficient framework for clustered federated learning. In Proceedings of Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems, NeurIPS, 2020.   \n[11] Yishay Mansour, Mehryar Mohri, Jae Ro, and Ananda Theertha Suresh. Three approaches for personalization with applications to federated learning. arXiv preprint arXiv:2002.10619, 2020.   \n[12] Eunjeong Jeong, Seungeun Oh, Hyesung Kim, Jihong Park, Mehdi Bennis, and Seong-Lyun Kim. Communication-efficient on-device machine learning: Federated distillation and augmentation under non-iid private data. arXiv preprint arXiv:1811.11479, 2018.   \n[13] Daliang Li and Junpu Wang. FedMD: Heterogenous federated learning via model distillation. arXiv, oct 2019.   \n[14] Hongyan Chang, Virat Shejwalkar, Reza Shokri, and Amir Houmansadr. Cronus: Robust and heterogeneous collaborative learning with black-box knowledge transfer. arXiv preprint arXiv:1912.11279, 2019.   \n[15] Sohei Itahara, Takayuki Nishio, Yusuke Koda, Masahiro Morikura, and Koji Yamamoto. Distillation-based semi-supervised federated learning for communication-efficient collaborative training with non-iid private data. arXiv preprint arXiv:2008.06180, 2020.   \n[16] Tao Lin, Lingjing Kong, Sebastian U. Stich, and Martin Jaggi. Ensemble distillation for robust model fusion in federated learning. In Proceedings of Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems, NeurIPS, 2020.   \n[17] Hong-You Chen and Wei-Lun Chao. Fedbe: Making bayesian model ensemble applicable to federated learning. In 9th International Conference on Learning Representations, ICLR 2021, Virtual Event, Austria, May 3-7, 2021. OpenReview.net, 2021.   \n[18] Yanlin Zhou, George Pu, Xiyao Ma, Xiaolin Li, and Dapeng Wu. Distilled one-shot federated learning. CoRR, abs/2009.07999, 2020.   \n[19] Lichao Sun and Lingjuan Lyu. Federated model distillation with noise-free differential privacy. In Zhi-Hua Zhou, editor, Proceedings of the Thirtieth International Joint Conference on Artificial Intelligence, IJCAI 2021, pages 1563–1570. ijcai.org, 2021.   \n[20] Kangkang Wang, Rajiv Mathews, Chloé Kiddon, Hubert Eichner, Françoise Beaufays, and Daniel Ramage. Federated evaluation of on-device personalization. arXiv preprint arXiv:1910.10252, 2019.   \n[21] Johannes Schneider and Michail Vlachos. Personalization of deep learning. arXiv preprint arXiv:1909.02803, 2019.   \n[22] Manoj Ghuhan Arivazhagan, Vinay Aggarwal, Aaditya Kumar Singh, and Sunav Choudhary. Federated learning with personalization layers. arXiv preprint arXiv:1912.00818, 2019.   \n[23] Tao Yu, Eugene Bagdasaryan, and Vitaly Shmatikov. Salvaging federated learning by local adaptation. CoRR, abs/2002.04758, 2020.   \n[24] Filip Hanzely, Slavomír Hanzely, Samuel Horváth, and Peter Richtárik. Lower bounds and optimal algorithms for personalized federated learning. In Proceedings of Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems, NeurIPS, 2020.   \n[25] Tian Li, Shengyuan Hu, Ahmad Beirami, and Virginia Smith. Ditto: Fair and robust federated learning through personalization. In International Conference on Machine Learning, pages 6357–6368. PMLR, 2021.   \n[26] Yuyang Deng, Mohammad Mahdi Kamani, and Mehrdad Mahdavi. Adaptive personalized federated learning. arXiv preprint arXiv:2003.13461, 2020.   \n[27] Matthias Reisser, Christos Louizos, Efstratios Gavves, and Max Welling. Federated mixture of experts. arXiv preprint arXiv:2107.06724, 2021.   \n[28] Yihan Jiang, Jakub Konecnˇ y, Keith Rush, and Sreeram Kannan. Improving federated learning \\` personalization via model agnostic meta learning. arXiv preprint arXiv:1909.12488, 2019.   \n[29] Michael Zhang, Karan Sapra, Sanja Fidler, Serena Yeung, and Jose M. Alvarez. Personalized federated learning with first order model optimization. In 9th International Conference on Learning Representations, ICLR 2021. OpenReview.net, 2021.   \n[30] Aviv Shamsian, Aviv Navon, Ethan Fetaya, and Gal Chechik. Personalized federated learning using hypernetworks. In Marina Meila and Tong Zhang, editors, Proceedings of the 38th International Conference on Machine Learning, ICML 2021, volume 139, pages 9489–9502. PMLR, 2021.   \n[31] Virginia Smith, Chao-Kai Chiang, Maziar Sanjabi, and Ameet S. Talwalkar. Federated multitask learning. In Proceedings of Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems, NeurIPS, 2017.   \n[32] Enmao Diao, Jie Ding, and Vahid Tarokh. Heterofl: Computation and communication efficient federated learning for heterogeneous clients. In 9th International Conference on Learning Representations, ICLR 2021. OpenReview.net, 2021.   \n[33] Neel Guha, Ameet Talwalkar, and Virginia Smith. One-shot federated learning. CoRR, abs/1902.11175, 2019.   \n[34] Chaoyang He, Salman Avestimehr, and Murali Annavaram. Group knowledge transfer: Collaborative training of large cnns on the edge. arXiv preprint arXiv:2007.14513, 2020.   \n[35] Gregory Cohen, Saeed Afshar, Jonathan Tapson, and André van Schaik. EMNIST: extending MNIST to handwritten letters. In Proceedings of 2017 International Joint Conference on Neural Networks, IJCNN, 2017.   \n[36] Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017.   \n[37] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.   \n[38] Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   \n[39] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In Proceedings of Advances in Neural Information Processing Systems 25: 26th Annual Conference on Neural Information Processing Systems, NeurIPS, pages 1106–1114, 2012.   \n[40] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of 2016 IEEE Conference on Computer Vision and Pattern Recognition, CVPR, pages 770–778, 2016.   \n[41] 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, pages 116–131, 2018. ",
+        "bbox": [
+            171,
+            49,
+            828,
+            921
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            60,
+            826,
+            914
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            89,
+            828,
+            325
+        ],
+        "page_idx": 12
+    }
+]

parse/train/rk6H0ZbRb/rk6H0ZbRb_content_list.json

@@ -0,0 +1,1708 @@
+[
+    {
+        "type": "text",
+        "text": "INTRIGUING PROPERTIES OF ADVERSARIAL EXAM-PLES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            821,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "It is becoming increasingly clear that many machine learning classifiers are vulnerable to adversarial examples. In attempting to explain the origin of adversarial examples, previous studies have typically focused on the fact that neural networks operate on high dimensional data, they overfit, or they are too linear. Here we show that distributions of logit differences have a universal functional form. This functional form is independent of architecture, dataset, and training protocol; nor does it change during training. This leads to adversarial error having a universal scaling, as a power-law, with respect to the size of the adversarial perturbation. We show that this universality holds for a broad range of datasets (MNIST, CIFAR10, ImageNet, and random data), models (including state-of-the-art deep networks, linear models, adversarially trained networks, and networks trained on randomly shuffled labels), and attacks (FGSM, step l.l., PGD). Motivated by these results, we study the effects of reducing prediction entropy on adversarial robustness. Finally, we study the effect of network architectures on adversarial sensitivity. To do this, we use neural architecture search with reinforcement learning to find adversarially robust architectures on CIFAR10. Our resulting architecture is more robust to white and black box attacks compared to previous attempts. ",
+        "bbox": [
+            233,
+            263,
+            764,
+            500
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            525,
+            336,
+            540
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "An intriguing aspect of deep learning models in computer vision is that while they can classify images with high accuracy, they fail catastrophically when those same images are perturbed slightly in an adversarial fashion (Szegedy et al., 2013; Goodfellow et al., 2014). The prevalence of adversarial examples presents challenges to our understanding of how deep networks generalize and pose security risks in real world applications (Papernot et al., 2016a; Kurakin et al., 2016a). Several techniques have been proposed to defend against adversarial examples. Adversarial training (Goodfellow et al., 2014) augments the training data with adversarial examples. It has been shown that using stronger adversarial attacks in adversarial training can increase the robustness to stronger attacks, but at the cost of a decrease in clean accuracy (i.e. accuracy on samples that have not been adversarially perturbed) (Madry et al., 2017). Defensive distillation (Papernot et al., 2016b), feature squeezing (Xu et al., 2017), and Parseval training (Cisse et al., 2017) have also been shown to make models more robust against adversarial attacks. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            722
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The goal of this work is to study the common properties of adversarial examples. We calculate the adversarial error, defined as the difference between clean accuracy and adversarial accuracy at a given size of adversarial perturbation (\u000f). Surprisingly, adversarial error has a similar dependence on small values of $\\epsilon$ for all network models and datasets we studied, including linear, fully-connected, simple convolutional networks, Inception v3 (Szegedy et al., 2016), Inception-ResNet v2, Inception v4 (Szegedy et al., 2017), ResNet v1, ResNet v2 (He et al., 2016), NasNet-A (Zoph & Le, 2016; Zoph et al., 2017), adversarially trained Inception v3 (Kurakin et al., 2016b) and Inception-ResNet v2 (Tramer et al., 2017), and networks trained on randomly shuffled labels of MNIST. Adversarial \\` error due to the Fast Gradient Sign Method (FGSM), its L2-norm variant, and Projected Gradient Descent (PGD) attack grows as a power-law like $A \\epsilon ^ { B }$ with $B$ between 0.9 and 1.3. By contrast, we find that adversarial error caused by one-step least likely class method (step l.l.) also scales as a power-law where $B$ is between 1.8 and 2.5 for small $\\epsilon$ . This observed universality points to a mysterious commonality between these models and datasets, despite the different number of channels, pixels, and classes present. Adversarial error caused by FGSM on the training set of randomly shuffled labels of MNIST (LeCun & Cortes) also has the power-law form where $B = 1 . 2$ , which implies that the universality is not a result of the specific content of these datasets nor the ability of the model to generalize. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To discover the mechanism behind this universality we show how, at small $\\epsilon$ , the success of an adversarial attack depends on the input-logit Jacobian of the model and on the logits of the network. We demonstrate that the susceptibility of a model to FGSM and PGD attacks is in large part dictated by the cumulative distribution of the difference between the most likely logit and the second most likely logit. We observe that this cumulative distribution has a universal form among all datasets and models studied, including randomly produced data. Together, we believe these results provide a compelling story regarding the susceptibility of machine learning models to adversarial examples at small $\\epsilon$ . ",
+        "bbox": [
+            173,
+            152,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We show that training with single-step adversarial examples offers protection against large $\\epsilon$ attacks (between 0.2 and 32), but does not help appreciably at defending against small $\\epsilon$ attacks (below 0.2). At $\\epsilon = 0 . 2$ , all ImageNet models we studied incur 10 to $2 5 \\%$ adversarial error, and surprisingly, vanilla NASNet-A (best clean accuracy in our study) has a lower adversarial error than adversarially trained Inception-ResNet v2 or Inception v3 (Kurakin et al., 2016b) (Fig. 1(a)). In light of these results, we explore a different avenue to adversarial robustness through architecture selection. We perform neural architecture search (NAS) using reinforcement learning (Zoph & Le, 2016; Zoph et al., 2017). These techniques allow us to find several architectures that are especially robust to adversarial perturbations. In addition, by analyzing the adversarial robustness of the tens-of-thousands of architectures constructed by NAS, we gain insights into the relationship between size of a model, its clean accuracy, and its adversarial robustness. In summary, the key contributions of our work are: ",
+        "bbox": [
+            173,
+            270,
+            825,
+            424
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We study the functional form of adversarial error and logit differences across several models and datasets, which turn out to be universal. We analytically derive the commonality in the power-law tails of the logit differences, and show how it leads to the commonality in the form of adversarial error.   \n• We observe that although the qualitative form of logit differences and adversarial error is universal, it can be quantitatively improved with entropy regularization and better network architectures.   \n• We study the dependence of adversarial robustness on the network architecture via NAS. We show that while adversarial accuracy is strongly correlated with clean accuracy, it is only weakly correlated with model size. Our work leads to architectures that are more robust to white-box and black-box attacks on CIFAR10 (Krizhevsky & Hinton, 2009) than previous studies. ",
+        "bbox": [
+            215,
+            435,
+            825,
+            611
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 SURPRISING UNIVERSALITY OF ADVERSARIAL ERROR AT SMALL \u000f ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            631,
+            764,
+            647
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "FGSM computes adversarial examples as: ",
+        "bbox": [
+            176,
+            662,
+            449,
+            676
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ee4fc3a993d64022dfb418f2443b310305b31504a1be922be748c9fb8fc5918b.jpg",
+        "text": "$$\n\\boldsymbol { x } ^ { \\mathrm { a d v } } = \\boldsymbol { x } + \\epsilon \\mathrm { s i g n } \\left( \\nabla _ { \\boldsymbol { x } } L ( \\boldsymbol { x } , \\boldsymbol { y } ) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            683,
+            606,
+            702
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $x$ is the clean image, $y$ is the correct label for that image, $x ^ { \\mathrm { a d v } }$ is the adversarial image, $\\epsilon$ is the size of the adversarial perturbation, and $L ( x , y )$ is the loss function. $\\epsilon$ values are specified in range [0,255]. We only study white-box attacks in this section. ",
+        "bbox": [
+            174,
+            705,
+            823,
+            748
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We begin with a preliminary examination of the architectural dependence of adversarial robustness. To that end, in Fig. 1 (a) we plot the test set adversarial error due to an FGSM attack as a function of $\\epsilon$ for several models on ImageNet (Russakovsky et al., 2015). We note that for $\\epsilon < 0 . 2$ , the adversarial error follows a power law form with an exponent between 0.9 and 1.1 for all models studied. Even adversarially trained models Kurakin et al. (2016b), while adversarially much more robust for larger values of $\\epsilon$ , follow a similar form and reach as large as $20 \\%$ adversarial error at smaller $\\epsilon$ . ",
+        "bbox": [
+            173,
+            755,
+            825,
+            852
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In light of the surprising commonality in adversarial error at small- $\\epsilon$ , we investigate whether there is any way to get a different form for the adversarial error. To do this, we evaluate the adversarial error due to step l.l. attack, which is computed as: ",
+        "bbox": [
+            174,
+            859,
+            823,
+            901
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bac45d99e231345e5fd76c3c19f34c8e15235c45cb49294bdccbdcff86c73393.jpg",
+        "text": "$$\nx ^ { \\mathrm { a d v } } = x - \\epsilon \\mathrm { s i g n } \\left( \\nabla _ { x } L ( x , y _ { l . l . } ) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            907,
+            614,
+            925
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $y _ { l . l . }$ is least likely class predicted by the network on clean image $x$ (Kurakin et al., 2016b). The adversarial error also follows a power law, however with a larger exponent. The exponents range from 1.8 to 2.2 for ImageNet models (Fig. 1(b)), and 1.8 to 2.5 for models trained on MNIST (Fig. 2(c)) and CIFAR10. Thus, we see that attack protocol can change the exponent of the observed power-law. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/96e44a0d4a3fd367b209184ba9b25c3986431a5b883e6cfe8c25726059b999c8.jpg",
+        "image_caption": [
+            "Figure 1: Test set adversarial error as a function of $\\epsilon$ for models trained on ImageNet due to FGSM and step l.l. attack in (a) and (b), respectively. adv. tr. denotes models that are adversarially trained (Kurakin et al., 2016b). In (b), we also show two of the power law fits with straight lines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            188,
+            808,
+            397
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To test the limits of the universality observed in Fig. 1, we perform a number of more extensive tests. First, we investigate the effect of architecture by stochastically sampling thousands of different neural networks and train them on MNIST. We then measure their adversarial error due to FGSM on the test set. The architectures we sample are either fully-connected networks with 1-4 hidden layers and 30-2000 hidden nodes in each layer, or simple convolutional networks with dropout rates between 0-0.5. The adversarial error of representative linear, fully-connected, and convolutional networks are shown in Fig. 2 (a). As above, these models all have the same form of adversarial error with a powerlaw dependence on $\\epsilon$ with exponents between 0.9 and 1.2. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            587
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "See Fig. 9 in the Appendix for a plot with all of the generated networks. We perform the same analysis on a 32-layer ResNet trained on CIFAR10 (He et al., 2016), which achieves a $9 2 . 6 \\%$ clean accuracy on the test set. The result is shown in Appendix Fig. 10, where the adversarial error follows a power law with an exponent of 0.99 up to an $\\epsilon$ of 1. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            650
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Next, we probe the relationship between generalization and adversarial robustness following a similar approach to Zhang et al. (2016). In particular, we train a fully connected network on MNIST with shuffled labels until it reaches perfect accuracy on the training set. The adversarial error on the training set is shown in Fig. 2(b). Once again we see that the adversarial error follows an almost identical power-law form at small $\\epsilon$ with an exponent of 1.2. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            727
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, we further investigate the dependence of adversarial robustness on attack protocol. We plot in Fig. 2 (c) the adversarial error on MNIST with an $L _ { \\infty }$ -normalized FGSM attack, an $L _ { 2 }$ - normalized FGSM attack, and a 20-step projected gradient descent (PGD) attack (Madry et al., 2017). We see that despite the anomalous exponent observed for step-l.l. attacks, the other attack methods display the same universality with exponents of 1.1, 1.2, and 1.3 for L2-norm, FGSM, and PGD attacks, respectively. step-l.l. attack on MNIST has an exponent of 2.3. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            816
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 A MEAN-FIELD THEORY OF ADVERSARIAL PERTURBATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            837,
+            710,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 LINEAR RESPONSE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            348,
+            883
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now offer a theoretical explanation for the observed universal behavior of adversarial error. The breadth of these observations shows that adversarial error for small adversarial perturbations does not depend on the specifics of the neural network, which implies that we can understand the small $\\epsilon$ regime by making simplifying approximations. We begin by considering the linear response of a neural network to adversarial perturbations. Another approach to adversarial examples that considers the linear response of the network can be found in Nayebi & Ganguli (2017). The effect of margins on adversarial robustness has been brought up in ?. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/71a2d3a2071be278b30c68ebe087ca022a4b5a62472b42ec80cadf2f1fe43425.jpg",
+        "image_caption": [
+            "Figure 2: Points represent adversarial error as a function of $\\epsilon$ for models trained on MNIST. Straight lines are power-law fits. (a) FGSM attack on fully-connected 3-layer network (FC), a linear model, and a convolutional network (b) FGSM attack on FC trained on randomly shuffled labels (evaluated on the training set). (c) Different attacks on FC. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            99,
+            758,
+            253
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            356,
+            825,
+            428
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We will study an $L _ { 2 }$ -variant of the FGSM attack. Here, the adversarial perturbation is given by, ",
+        "bbox": [
+            171,
+            433,
+            797,
+            449
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/89a058f54157f96e89fd0f0f168a0659681a84443e4a91aba48c1252a01d34cd.jpg",
+        "text": "$$\nx ^ { \\mathrm { a d v } } = x + \\epsilon \\frac { \\nabla _ { x } L } { | | \\nabla _ { x } L | | _ { 2 } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            454,
+            576,
+            488
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "instead of the more commonly used $\\ell _ { \\infty }$ variant. As shown above, the form and exponent of adversarial error is qualitatively insensitive to this choice (see Fig. 2(c)). We will now attempt to compute the minimum $\\epsilon$ , that we call $\\hat { \\epsilon } ( x )$ , required before the class assigned to an input, $x$ , changes. Assuming the network was able to perfectly classify clean images, the adversarial error rate will then be $P ( \\bar { \\hat { \\epsilon } } < \\epsilon )$ . While perfect classification will not be achieved in practice, the insensitivity of the form of adversarial error to clean accuracy demonstrated above for many systems suggests that this approximation is sound. ",
+        "bbox": [
+            173,
+            494,
+            825,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Notationally, we will refer to the output of the network as ${ \\hat { y } } _ { i } ( x )$ and the corresponding logits as $h _ { i } ( x )$ . The class prediction of the network will then be arg $\\operatorname* { m a x } ( \\hat { y } ( x ) ) = \\operatorname { a r g m a x } ( h ( x ) )$ . For simplicity we will choose an ordering of the logits such that $h _ { 1 } ( x ) \\geq h _ { 2 } ( x ) \\geq \\cdot \\cdot \\cdot \\geq h _ { N } ( x )$ . We can then enumerate a set of logit-differences, $\\Delta _ { i j } ( x ) = h _ { i } ( x ) - \\dot { h _ { j } } ( x )$ . If an adversarial perturbation is to successfully cause the network to make an erroneous prediction, then it must be true that $h _ { 1 } ( x ^ { \\mathrm { a d v } } ) < h _ { j } ( \\dot { x } ^ { \\mathrm { a d v } } )$ for at least one $j$ . ",
+        "bbox": [
+            173,
+            598,
+            825,
+            684
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We calculate the response of the logits to adversarial perturbation. We consider the linearized response of the network and find that in the limit of small $\\epsilon$ (see Appendix 6.2.1), ",
+        "bbox": [
+            173,
+            689,
+            821,
+            718
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/02b23f9e0d4e909285a17ec2e547a7f7c0258a1bbde35751e7a7e98da8b28ae1.jpg",
+        "text": "$$\nh ( x ^ { \\mathrm { a d v } } ) = h ( x ) + \\epsilon \\frac { J ^ { T } J \\delta } { | | J \\delta | | _ { 2 } } + \\mathcal { O } ( \\epsilon ^ { 2 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            724,
+            620,
+            761
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $J _ { i j } = \\partial h _ { j } / \\partial x _ { i }$ is the input-logit Jacobian of the network and $\\delta _ { i } = \\partial L / \\partial h _ { i }$ is the error of the outputs of the network. For notational convenience we will define $\\Gamma ( x ) = J ^ { T } J \\delta / | J \\delta | | _ { 2 }$ . In this linear model we therefore predict that the logit-differences will scale as follows, ",
+        "bbox": [
+            174,
+            767,
+            825,
+            811
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8d6dd80c2659cd4407fb34f15c5a837f8948c0ff64daff4f79a7443a2bc82267.jpg",
+        "text": "$$\n\\Delta _ { i j } ( x ^ { \\mathrm { a d v } } ) \\approx \\Delta _ { i j } ( x ) + \\epsilon ( \\Gamma _ { i } ( x ) - \\Gamma _ { j } ( x ) ) + \\mathcal { O } ( \\epsilon ^ { 2 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            819,
+            671,
+            838
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Recall that the adversarial perturbation will successfully cause the network to just barely misclassify an input precisely when $\\Delta _ { 1 j } ( x ^ { \\mathrm { a d v } } ) = 0$ for at least one $j$ . We can predict per-class $\\epsilon$ -thresholds beyond which the network will misclassify a given point, ",
+        "bbox": [
+            174,
+            844,
+            825,
+            887
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/49339a63104700778ae511cc796404946992954b0b0a35ea0f2d76af0bb3130c.jpg",
+        "text": "$$\n\\hat { \\epsilon } _ { j } ( x ) = \\frac { \\Delta _ { 1 j } ( x ) } { \\Gamma _ { j } ( x ) - \\Gamma _ { 1 } ( x ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            893,
+            583,
+            928
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Together this allows us to compute a linear approximation to $\\hat { \\epsilon }$ given by $\\hat { \\epsilon } _ { \\mathrm { l i n e a r } } ( x ) = \\operatorname* { m i n } _ { j } ( \\epsilon _ { j } ( x ) )$ ",
+        "bbox": [
+            171,
+            103,
+            813,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We can confirm that the change in the logits for small changes in the inputs is well-described by this linear model. This is shown in fig. 3 (a) where we see the logits for a single example upon perturbation over a range of $\\epsilon$ . In particular, for small $\\epsilon$ we see an excellent agreement between the linear approximation and the true logit dynamics. We also see that the $\\epsilon$ where the first and second logit cross is well-approximated by the linear prediction. In Fig. 3 (b) we plot $\\hat { \\epsilon } _ { \\mathrm { l i n e a r } } ( x )$ against $\\hat { \\epsilon } ( x )$ evaluated on every MNIST example in the test set. The white dashed line is the line $\\hat { \\epsilon } ( x ) = \\hat { \\epsilon } _ { \\mathrm { l i n e a r } } ( x )$ . We see that when $\\hat { \\epsilon } ( x )$ is small the $\\hat { \\epsilon } _ { \\mathrm { l i n e a r } } ( x )$ concentrate increasingly around the $\\hat { \\epsilon } ( x )$ . Together these results show that the linear response predictions are valid for small adversarial perturbations. ",
+        "bbox": [
+            174,
+            125,
+            823,
+            154
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/85f4e581191d1aa2d9b2fce3b1c7c6baf8327e01427ec09910818f8323319cd2.jpg",
+        "image_caption": [
+            "Figure 3: Linear approximation for the response of the logits to adversarial perturbation. (a) The dynamics of logits to an adversarial perturbation as a function of size $\\epsilon$ for a single training example. Dashed lines show the linear approximation. Colors indicate the ranking of the logit from largest (red) to smallest (blue). (b) The smallest $\\epsilon$ needed to fool the network (\u000fˆ) for individual test examples compared with the prediction from the linear theory. (c) Mean field prediction of $\\hat { \\epsilon }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            166,
+            813,
+            332
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            430,
+            825,
+            529
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While the linear model outlined above gives excellent agreement in the $\\epsilon  0$ limit, the $\\Gamma _ { i } ( x )$ are themselves complicated objects (being functions of the Jacobian). This makes the analytic evaluation of Eq. (6) challenging. We therefore introduce a “mean-field” approximation to Eq. (6) by replacing $\\Gamma _ { i } ( x )$ by its average over the dataset, $\\langle \\Gamma _ { i } ( x ) \\rangle$ . Similar independence approximations have previously been successful in analyzing the expressivity and trainability of neural networks (Schoenholz et al., 2016; Poole et al., 2016). Finally, we observe that the vast majority of the time (for example, more than $9 5 \\%$ of successful FGSM attacks for $\\epsilon < 5 0$ ), it is $\\Delta _ { 1 2 } ( x ^ { \\mathrm { a d v } } )$ that goes to zero before any of the other $\\Delta _ { 1 j }$ . We therefore assume that this will be the dominant failure mode for neural networks and write down a mean-field estimate for $\\hat { \\epsilon }$ , ",
+        "bbox": [
+            173,
+            535,
+            825,
+            661
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3e9032f94e3d1193fa8152b698b894a339195d5cb541cd0ff4da22be17b25a8f.jpg",
+        "text": "$$\n\\hat { \\epsilon } _ { \\mathrm { M . F . } } = \\frac { \\Delta _ { 1 2 } ( x ) } { \\langle \\Gamma _ { 2 } \\rangle - \\langle \\Gamma _ { 1 } \\rangle } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            661,
+            575,
+            696
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We show in Fig. 3 (c) that this approximation continues to be strongly correlated with \u000fˆ. Together these results suggest that the adversarial error rate for perturbations of size $\\epsilon$ will be ",
+        "bbox": [
+            174,
+            698,
+            823,
+            726
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2fa0c4ecc0fba1c0b9fe140425c5bf14bb91d78fe04805f099529f99fe7dd273.jpg",
+        "text": "$$\nP ( \\hat { \\epsilon } \\le \\epsilon ) \\approx P \\left[ \\Delta _ { 1 2 } \\le \\epsilon ( \\langle \\Gamma _ { 2 } \\rangle - \\langle \\Gamma _ { 1 } \\rangle ) \\right] = P ( \\Delta _ { 1 2 } \\le \\tilde { \\epsilon } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            728,
+            679,
+            746
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where we have defined $\\tilde { \\epsilon } = \\epsilon ( \\left. \\Gamma _ { 2 } \\right. - \\left. \\Gamma _ { 1 } \\right. )$ to be a network-specific rescaling of $\\epsilon$ . We therefore expect the adversarial error rate at small $\\epsilon$ to be dictated by the cumulative distribution of $\\Delta _ { 1 2 }$ for attacks that effectively target the second most likely class (e.g. FGSM, PGD ...etc.). ",
+        "bbox": [
+            174,
+            747,
+            825,
+            791
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 UNIVERSAL PROPERTIES OF THE LOGIT DIFFERENCE DISTRIBUTION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            806,
+            691,
+            821
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "With the results from the preceding section in hand, we now investigate the distribution of logit differences, $P ( \\Delta _ { 1 j } )$ . Since we are particularly interested in the small $\\epsilon$ regime, we seek to compute $P ( \\Delta _ { 1 j } )$ for small $\\Delta _ { 1 j }$ . To make progress we will again make a mean field approximation and assume that each of the logits are i.i.d. with arbitrary distribution. With this approximation we find that for small $\\Delta _ { 1 j }$ (see Appendix 6.2.2), ",
+        "bbox": [
+            174,
+            832,
+            825,
+            904
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c4cb124acc4750670e68e8ef9e1ffeaf9d98078ea703f1803deadb81f4f303b2.jpg",
+        "text": "$$\nP ( \\Delta _ { 1 j } ) = C \\Delta _ { 1 j } ^ { j - 2 } + \\mathcal { O } ( \\Delta _ { 1 j } ^ { j - 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            905,
+            604,
+            928
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $C$ is a network specific constant. An interesting consequence of this result is that the difference that we are particularly interested in, $P ( \\Delta _ { 1 2 } )$ , scales as $\\mathcal { O } ( 1 )$ as $\\Delta _ { 1 2 }  0$ . This implies that, generically, we expect the most likely logit and second most likely logit to have a finite probability of being arbitrarily close together. We interpret this as an inherent uncertainty in the predictions of neural networks. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While it is not obvious that the assumption of a factorial logit distribution is valid here, we will see that Eq. (9) captures the universal features of the distribution at small values of the logit difference. Indeed, from the previous section we see that the form of Eq. (9) implies that the adversarial error rate should scale as follows ",
+        "bbox": [
+            174,
+            180,
+            825,
+            236
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c04d3fef2ff4b4316758f65df464f22ce83f99ff6b248eb3663c2282fd72b19b.jpg",
+        "text": "$$\nP ( \\hat { \\epsilon } < \\epsilon ) \\approx P ( \\Delta _ { 1 2 } < \\tilde { \\epsilon } ) \\approx C \\tilde { \\epsilon } + \\mathcal { O } ( \\tilde { \\epsilon } ^ { 2 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            239,
+            633,
+            258
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "as was broadly observed in the previous section. ",
+        "bbox": [
+            174,
+            262,
+            488,
+            277
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To further test whether or not the mean field approximation is valid, we evaluate $\\Delta _ { 1 j }$ for a number of different neural network architectures and datasets. We find that on all datasets and models studied, the $\\Delta _ { 1 j }$ distributions have power-law tails. As predicted, $\\Delta _ { 1 2 }$ has a power-law tail with an exponent of about 0, and $\\Delta _ { 1 j }$ for $j > 2$ have power-law tails with positive exponents increasing with $j$ . We note, however, that the powers are typically not integral for large $j$ . It seems likely that this breakdown is the result of correlations between the logits. In Fig. 4, we compare distribution of $\\Delta _ { 1 j }$ with $j = 2 , 3 , 4$ for ImageNet and logits that are independently sampled from a uniform distribution for 5 million samples with 10 classes. In Fig. 6 we see similar results for MNIST. Together these results verify our predictions over a vast set of networks and datasets. ",
+        "bbox": [
+            174,
+            284,
+            825,
+            410
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The empirical results above show that adversarial error has a power-law form for well-studied and random datasets, simple full connected networks as well as complicated state-of-the-art models. It follows that the prevalence and commonality of adversarial examples is not due to the depth of the model (for example, see the linear model in Fig. 2 (a)), or the high-dimensionality of the datasets. Rather, they are due to the fact that lots of examples have small $\\Delta _ { 1 2 }$ values. This makes it easy to find examples to fool the model at test-time. ",
+        "bbox": [
+            174,
+            415,
+            825,
+            500
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "It is interesting that the distribution of $\\Delta _ { 1 j }$ , at small $\\Delta _ { 1 j }$ , for trained models is essentially identical to that of i.i.d. random logits (especially for $j = 2$ ). This suggests that while our training procedures are good at modifying the largest logit in a way that leads to good clean accuracies, these procedures do not induce strong enough correlations between the logits to disrupt the essential scaling uncovered above. This problem is reminiscent of the problem distillation (Hinton et al., 2015) attempts to solve, by incorporating information about ratios of incorrect classes. This might be one of the reasons defensive distillation improves adversarial robustness. It would be interesting to study the distributions of logit differences during training of distillation networks. ",
+        "bbox": [
+            173,
+            506,
+            825,
+            618
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/dfac972faeb31b0e791b25975de81e491597615df9ab61798b0539d59233dbbe.jpg",
+        "image_caption": [
+            "Figure 4: (a) Distribution of $\\Delta _ { 1 j }$ of NASNet-A trained on ImageNet. (b) Distribution of $\\Delta _ { 1 j }$ for logits that are sampled independently from a uniform random distribution for 5 million samples with 10 classes. $\\Delta _ { 1 j }$ of other models are in Appendix Fig. 14 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            631,
+            758,
+            756
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Given the large density of small more robust. Our proposed los $\\Delta _ { 1 2 }$ values, we study an entronction can be written as: $\\begin{array} { r } { \\mathrm { \\bar { l o s s } } = \\mathrm { o l d } \\mathrm { \\bar { l o s s } } - \\lambda \\sum _ { i = 1 } ^ { n } p _ { i } \\log p _ { i } } \\end{array}$ where is a hyperparameter, $n$ is the number of classes, and $p _ { i }$ are the outputs of the neural network. This regularization term has been used by Miyato et al. (2017) for semi-supervised learning tasks. It aims to increase the confidence of the network on each sample, which is the opposite of previous regularization attempts that penalized confidence to increase generalization accuracy (Pereyra et al., ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2017; Szegedy et al., 2015). By penalizing the entropy of the softmax outputs, we aim to increase the logit differences. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 5, we show that entropy regularization with a $\\lambda = 4 . 5$ increases the adversarial robustness both for regularly trained networks and step l.l. adversarially trained networks, and both for permutation invariant and regular MNIST. We note that the same qualitative results hold for other values of $\\lambda$ we tried. Despite the increase in adversarial accuracy, the permutation invariant MNIST model has $0 . 8 \\%$ lower clean accuracy when trained with the entropy penalty. In Appendix Fig. 11, we show that a wide ResNet trained with the entropy regularizer has improved robustness with no loss in clean accuracy. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            236
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c1869225e39aa09f2326fc23af8d98fa31a28439eb1d8da0aed3cd53b95f57fc.jpg",
+        "image_caption": [
+            "Figure 5: Step l.l. attack adversarial accuracy as a function of $\\epsilon$ for CNN and permutation invariant MNIST in (a) and (b), respectively. Regular training (purple), entropy regularization (red), adversarial training (green), and adversarial training with entropy regularization (blue) have been implemented. Adversarial training was done using the step l.l. method. In (c), we show the PGD attack adversarial accuracy on permutation invariant MNIST trained with and without step l.l. adversarial training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            252,
+            790,
+            364
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We investigate whether the increased adversarial robustness is due to increased logit differences. In Fig. 6, we plot the distribution of $\\Delta _ { 1 j }$ for $j$ up to 4, for two networks trained on permutation invariant MNIST, with and without entropy regularization. As expected, margins are shifted to larger values and density of samples with small $\\Delta _ { 1 j }$ are reduced. The tails still follow a power-law form with the same exponents, however there are fewer samples with small margins compared to a regularly trained network. Although entropy regularization made our networks white-box attacks, it did not lead to a significant improvement against black-box attacks. For this reason, we focus on the influence of network architectures on adversarial sensitivity below. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            597
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/77dfdc0bb5f0bde75a3a7b36d8a17c63ceb148055a493141d5e6090904603350.jpg",
+        "image_caption": [
+            "Figure 6: Distribution of $\\Delta _ { 1 j }$ up to $j = 5$ for permutation invariant MNIST trained with and without entropy regularization in red and purple, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            608,
+            792,
+            722
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 ROLE OF NETWORK ARCHITECTURES IN ADVERSARIAL ROBUSTNESS ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            808,
+            787,
+            824
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Several recent papers observe that larger networks are more robust against adversarial examples, regardless if they are adversarially trained or not (Kurakin et al., 2016b; Madry et al., 2017). However, it is not clear if network architectures play an important role in adversarial robustness. Are larger models more robust because they have more trainable parameters, or simply because they have higher clean accuracy? Is it possible to find more robust network architectures that do not necessarily have more parameters? We run several experiments to answer these questions, as well as to find an adversarially more robust model on CIFAR10. We perform neural architecture search (NAS) with reinforcement learning. Our search space and procedure are almost exactly the same as in Zoph et al. (2017). One difference is that we restrict the search space so that the normal cell must be the same as the reduction cell. This reduces the complexity of the search space as now we have only half as many predictions. Finally, we increase the number of prediction steps from 5 to 7 to slightly gain back the complexity that was lost when we restricted the normal cell to be equal to the reduction cell. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We carry out two experiments: ",
+        "bbox": [
+            176,
+            208,
+            375,
+            223
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• Experiment 1: NAS where child models are trained with clean and step l.l. adversarial examples and the reward is computed on the validation set with FGSM adversarial accuracy at $\\epsilon = 8$ .   \n• Experiment 2: NAS where child models are trained with clean and PGD adversarial examples and the reward is computed on the validation set with FGSM adversarial accuracy at $\\epsilon = 8$ . ",
+        "bbox": [
+            215,
+            234,
+            825,
+            324
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In both experiments, child models are trained for 10 epochs on a training set of 25 thousand samples. Child models are trained on mini-batches where half of the samples are adversarially perturbed, following the procedure in (Kurakin et al., 2016b). At the end of each experiment, we pick the child model with the highest FGSM adversarial accuracy at $\\epsilon = 8$ on the validation set of 5000 samples, and scale up the number of filters. We train the enlarged models for 100 epochs on the full training set of 45000 samples for 12 different hyperparameter sets, and pick the one with the highest adversarial accuracy on the validation set. Finally, we report below the performance of these models on a held-out test set of 10 thousand samples. To provide a comparison with the results of our two experiments, we also run a vanilla NAS where the reward is clean validation accuracy. We will refer to the best architecture from vanilla NAS as NAS Baseline. When trained using the setup above only on clean examples, NAS Baseline reaches a test set accuracy of $9 5 . 3 \\%$ . ",
+        "bbox": [
+            173,
+            337,
+            825,
+            489
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/45725418240ff962864ee69771205d42909fa7e90b2d0a5a3159452fdd5e53aa.jpg",
+        "image_caption": [
+            "Figure 7: (a) step l.l. adversarial accuracy of NAS Baseline trained with and without step l.l. adversarial examples in green and red, respectively. Best model from Experiment 1 is shown in blue. (b) PGD adversarial accuracy of NAS Baseline trained with and without PGD adversarial examples in green and red, respectively. Best model from Experiment 2 is shown in blue. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            505,
+            825,
+            659
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We present the results of Experiment 1 in Fig 7(a). Here the green curve is the adversarial accuracy NAS Baseline. The blue curve is the adversarial accuracy of a network architecture that was found by Experiment 1. Both of these architectures are trained with the same adversarial training procedure. We try the same sets of hyperparameters and report here the models with best adversarial accuracy at $\\epsilon = 8$ on the validation set. Adversarial training reduced the clean accuracy by $0 . 2 \\%$ . Adversarially trained models both have clean accuracy of $9 5 . 1 \\%$ on the test set, whereas the model that was trained without adversarial training reached $9 5 . 3 \\%$ accuracy. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We next use PGD adversarial examples in the training of child models, to find architectures that are more robust to any adversarial attack within an $\\epsilon$ ball (Madry et al., 2017). Following the training procedure by Madry et al. (2017), we use 7 steps of size 2, for a total $\\epsilon = 8$ . We present the results of Experiment 2 in Fig. 7(b). As was the case in Experiment 1, the architecture found by adversarial NAS leads to a more robust model. At $\\epsilon = 8$ , the architecture from Experiment 2 reaches a $17 \\%$ higher adversarial accuracy on PGD examples. We compare our results to the results by Madry et al. (2017). Madry et al. (2017) trained only on PGD examples, whereas half of our minibatches are clean examples. Despite this, we match their accuracy on white-box PGD attacks. Against other white- and black-box attacks our model is more robust, and our clean accuracy is $5 . 9 \\%$ higher. We also note that NAS Baseline model has 4.9 million trainable parameters, whereas the model from Experiments 1 and 2 have 2.3 million and 3.5 million parameters, respectively. NAS found an adversarially more robust architecture with many fewer parameters. Best architecture from Experiment 2 and NAS Baseline are presented in Appendix Fig. 16. Finally, we study the performance statistics of child models during NAS. In Fig. 8, we report the results for 9360 child models that were trained during Experiment 1. As explained above, these models are only trained for 10 epochs. In Fig. 8(a), we see that the correlation between adversarialy accuracy and the number of trainable parameters of the model is not very strong. On the other hand, adversarial accuracy is strongly correlated with clean accuracy (Fig. 8(b)). We hypothesize that this is the reason both Madry et al. (2017) and Kurakin et al. (2016b) found that making networks larger increased adversarial robustness, because it also increased the clean accuracy. This implies that commonly used architectures, like Inception v3 and ResNet, benefit from having more parameters. This however was not the case for most child models during NAS. On the other hand, having a high clean accuracy is not sufficient for adversarial robustness. As seen in Fig. 8(c), there is a large variance in the adversarial accuracy of models with good clean accuracy. The range of adversarial accuracies in the histogram of models with larger than $85 \\%$ clean accuracy is $22 \\%$ and the standard deviation is $2 . 6 \\%$ . For this reason, our experiments led to more robust architectures than NAS Baseline. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/df88ee6134798336365d02a51543f0225263a6aa4260d013eef95c68aa7be7bc.jpg",
+        "table_caption": [
+            "Table 1: Performance of our best architecture from Experiment 2 at $\\epsilon = 8$ . Black-box attacks are sourced from a copy of the network independently initialized and trained. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=3>White-box</td><td rowspan=1 colspan=3>Black-box</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Clean</td><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>step 1.1.</td><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>step 1.1.</td><td rowspan=1 colspan=1>PGD</td></tr><tr><td rowspan=1 colspan=1>Madry et al. (2017)</td><td rowspan=1 colspan=1>87.3%</td><td rowspan=1 colspan=1>56.1%</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>50.0%</td><td rowspan=1 colspan=1>67.0 %</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>64.2%</td></tr><tr><td rowspan=1 colspan=1>This work</td><td rowspan=1 colspan=1>93.2%</td><td rowspan=1 colspan=1>63.6%</td><td rowspan=1 colspan=1>77.9%</td><td rowspan=1 colspan=1>50.1%</td><td rowspan=1 colspan=1>78.1 %</td><td rowspan=1 colspan=1>84.9%</td><td rowspan=1 colspan=1>75.0%</td></tr></table>",
+        "bbox": [
+            174,
+            101,
+            777,
+            161
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            233,
+            825,
+            345
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/0207438d01698c7a498a79f722099d8aa9424e42d55368ce98b83ff84f3350d9.jpg",
+        "image_caption": [
+            "Figure 8: Performance of child models on the validation set. FGSM adversarial accuracy at $\\epsilon = 8$ vs. number of trainable parameters and clean accuracy in (a) and (b), respectively. Black dots represent each child model, purple line is a running average. Figure (c) is the histogram of the adversarial accuracy for models with clean accuracy larger than $85 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            254,
+            366,
+            743,
+            507
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            606,
+            825,
+            801
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            830,
+            318,
+            847
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper we studied common properties of adversarial examples across different models and datasets. We theoretically derived a universality in logit differences and adversarial error of machine learning models. We showed that architecture plays an important role in adversarial robustness, which correlates strongly with clean accuracy. ",
+        "bbox": [
+            176,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Moustapha Cisse, Piotr Bojanowski, Edouard Grave, Yann Dauphin, and Nicolas Usunier. Parseval networks: Improving robustness to adversarial examples. In International Conference on Machine Learning, pp. 854–863, 2017. ",
+        "bbox": [
+            176,
+            126,
+            823,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014. ",
+        "bbox": [
+            171,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "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,
+            217,
+            823,
+            260
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015. ",
+        "bbox": [
+            173,
+            268,
+            821,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            171,
+            308,
+            821,
+            324
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016a. ",
+        "bbox": [
+            173,
+            333,
+            821,
+            363
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016b. ",
+        "bbox": [
+            173,
+            372,
+            823,
+            401
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun and Corinna Cortes. The mnist database of handwritten digits. http://yann. lecun. com/exdb/mnist/. ",
+        "bbox": [
+            173,
+            410,
+            823,
+            440
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017. ",
+        "bbox": [
+            173,
+            449,
+            825,
+            491
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. arXiv preprint arXiv:1704.03976, 2017. ",
+        "bbox": [
+            173,
+            502,
+            821,
+            545
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aran Nayebi and Surya Ganguli. Biologically inspired protection of deep networks from adversarial attacks. arXiv preprint arXiv:1703.09202, 2017. ",
+        "bbox": [
+            169,
+            554,
+            823,
+            584
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. arXiv preprint arXiv:1602.02697, 2016a. ",
+        "bbox": [
+            173,
+            593,
+            823,
+            636
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In Security and Privacy (SP), 2016 IEEE Symposium on, pp. 582–597. IEEE, 2016b. ",
+        "bbox": [
+            173,
+            645,
+            825,
+            689
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Pereyra, George Tucker, Jan Chorowski, Łukasz Kaiser, and Geoffrey Hinton. Regularizing neural networks by penalizing confident output distributions. arXiv preprint arXiv:1701.06548, 2017. ",
+        "bbox": [
+            173,
+            698,
+            826,
+            741
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ben Poole, Subhaneil Lahiri, Maithreyi Raghu, Jascha Sohl-Dickstein, and Surya Ganguli. Exponential expressivity in deep neural networks through transient chaos. In Advances In Neural Information Processing Systems, pp. 3360–3368, 2016. ",
+        "bbox": [
+            174,
+            751,
+            823,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015. ",
+        "bbox": [
+            176,
+            803,
+            823,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samuel S Schoenholz, Justin Gilmer, Surya Ganguli, and Jascha Sohl-Dickstein. Deep information propagation. arXiv preprint arXiv:1611.01232, 2016. ",
+        "bbox": [
+            171,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "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,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "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, pp. 1–9, 2015. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2818–2826, 2016. ",
+        "bbox": [
+            178,
+            155,
+            820,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, and Alexander A Alemi. Inception-v4, inception-resnet and the impact of residual connections on learning. In AAAI, pp. 4278–4284, 2017. ",
+        "bbox": [
+            176,
+            207,
+            823,
+            248
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramer, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick McDaniel. Ensemble \\` adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017. ",
+        "bbox": [
+            174,
+            257,
+            821,
+            287
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Weilin Xu, David Evans, and Yanjun Qi. Feature squeezing: Detecting adversarial examples in deep neural networks. arXiv preprint arXiv:1704.01155, 2017. ",
+        "bbox": [
+            174,
+            295,
+            821,
+            325
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016. ",
+        "bbox": [
+            174,
+            333,
+            821,
+            363
+        ],
+        "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": [
+            174,
+            371,
+            823,
+            400
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. arXiv preprint arXiv:1707.07012, 2017. ",
+        "bbox": [
+            176,
+            409,
+            825,
+            438
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6 APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            464,
+            294,
+            479
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "6.1 FURTHER EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            496,
+            387,
+            511
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/b670571accf1ec3148d8641417d4a6b43fdf7c353720d8907853cc342b1807d3.jpg",
+        "image_caption": [
+            "Figure 9: Adversarial error for hundreds of models trained on MNIST, including fully-connected and convolutional models. We only show models with clean accuracy larger than $80 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            525,
+            751,
+            799
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/0cda1546173e20803b367c7e26e3db58e2dabb30fc58a20a86e6556b80a83117.jpg",
+        "image_caption": [
+            "Figure 10: Points represent the adversarial error due to FGSM as a function of $\\epsilon$ for a 32-layer ResNet trained on CIFAR10. Straight line is a power law fit with an exponent of 0.99. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            370,
+            98,
+            627,
+            243
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/19c453a2f89cb39d463cccfb8014f80f6dddd6dcf92298ac8ab322959b8de828.jpg",
+        "image_caption": [
+            "Figure 11: Effect of adding an entropy regularization $( \\lambda = 3 . 0 )$ ): step l.l. adversarial accuracy of wide ResNet on CIFAR10, with and without entropy regularization. Both models have a clean accuracy of $9 4 \\%$ . They were both trained for 100 epochs with the same hyperparameters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            369,
+            318,
+            627,
+            460
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6.2 DERIVATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            559,
+            310,
+            573
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Here we derive several of the results found in the main text. ",
+        "bbox": [
+            173,
+            589,
+            563,
+            604
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6.2.1 LINEAR RESPONSE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            631,
+            361,
+            645
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "First, we compute the linear response of the network to the $L _ { 2 }$ FGSM attack. Let, $f : \\mathbb { R } ^ { N } \\to \\mathbb { R } ^ { M }$ be a neural network (or other model) structured such that $f = \\operatorname { s o f t m a x } \\circ h$ where $h : \\mathbb { R } ^ { N } \\to \\mathbb { R } ^ { M }$ maps inputs to logits. Additionally define a loss $L : \\mathbb { R } ^ { M } \\to \\mathbb { R }$ which can be cross-entropy, $L ^ { 2 }$ , etc.. To generate adversarial examples we start with an input $\\boldsymbol { x } \\in \\mathbb { R } ^ { N }$ and a corresponding target $t \\in \\mathbb { R } ^ { M }$ such that $t _ { \\beta } = 1$ if $\\beta = \\gamma$ for some $\\gamma$ and $t _ { \\beta } = 0$ otherwise. We assume our network gets the answer correct so that $h _ { \\gamma } > h _ { \\beta }$ for all $\\beta \\neq \\gamma$ . Then we apply the adversarial perturbation, ",
+        "bbox": [
+            173,
+            659,
+            825,
+            744
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/698cfcfcd533729a8ee35c3411cd4dbc8ebada99beeef2af9f1817eff2228852.jpg",
+        "text": "$$\nx _ { \\alpha } ^ { \\prime } = x _ { \\alpha } + \\epsilon \\frac { \\nabla _ { x } L } { | | \\nabla _ { x } L | | _ { 2 } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            761,
+            578,
+            795
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Note that we can write ",
+        "bbox": [
+            173,
+            810,
+            325,
+            824
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6116bb499f2d7950bc3dc8ae7a9d23c7b006d0b8308eb33f50f8f0e18e2fe300.jpg",
+        "text": "$$\n\\nabla _ { x } L = { \\frac { \\partial L } { \\partial x _ { \\alpha } } } = \\sum _ { \\beta } { \\frac { \\partial h _ { \\beta } } { \\partial x _ { \\alpha } } } { \\frac { \\partial L } { \\partial h _ { \\beta } } } = \\sum _ { \\beta } J _ { \\alpha \\beta } { \\frac { \\partial L } { \\partial h _ { \\beta } } } = J \\delta .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            838,
+            674,
+            878
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Where we associate $J _ { \\alpha \\beta } = \\partial h _ { \\beta } / \\partial x _ { \\alpha }$ with the input-to-logit Jacobian linking the inputs to the logits and $\\delta = \\partial L / \\partial h _ { \\beta }$ the error of the outputs of the network. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/1d995c793653d9be88818c8a1da8189e47e3b0c071c1153919643df49d15ff93.jpg",
+        "image_caption": [
+            "Figure 12: Fully connected network trained on MNIST with hinge loss. (a) Distributions of logit differences. (b) Red dots represent the adversarial error when FGSM attack uses the same hinge loss from training. Blue dots represent the adversarial error when FGSM attack uses a cross-entropy loss to create the adversarial examples.The line is a power-law fit with an exponent of 0.98 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            101,
+            758,
+            300
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/917b69d3b380562fee50ab581eb866d83a8e46674d25a3848452158d9ecbe7a4.jpg",
+        "image_caption": [
+            "Figure 13: Fully connected network trained on MNIST with L2-norm loss. (a) Distributions of logit differences. (b) Black dots represent the adversarial error due to FGSM. The line is a power-law fit with an exponent of 1.02 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            395,
+            759,
+            595
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We can compute the change to the logits of the network due to this perturbation. We find, ",
+        "bbox": [
+            169,
+            689,
+            758,
+            705
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ca3da83053aae2635ef11693f583bd390e3c0fa2c44233fe975727c8dc19194f.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle h ( \\boldsymbol { x } ^ { \\prime } ) = h ( \\boldsymbol { x } + \\epsilon \\nabla _ { \\boldsymbol { x } } L / | | \\nabla _ { \\boldsymbol { x } } L | | _ { 2 } ) } \\\\ { \\displaystyle h _ { \\beta } ^ { \\prime } \\approx h _ { \\beta } + \\frac { \\epsilon } { | | \\nabla _ { \\boldsymbol { x } } L | | _ { 2 } } \\sum _ { \\alpha } \\frac { \\partial h _ { \\beta } } { \\partial x _ { \\alpha } } \\frac { \\partial L } { \\partial x _ { \\alpha } } + \\mathcal { O } ( \\epsilon ^ { 2 } ) } \\\\ { \\displaystyle ~ = h _ { \\beta } + \\frac { \\epsilon } { | | \\nabla _ { \\boldsymbol { x } } L | | _ { 2 } } \\sum _ { \\alpha \\delta } \\frac { \\partial h _ { \\beta } } { \\partial x _ { \\alpha } } \\frac { \\partial h _ { \\delta } } { \\partial x _ { \\alpha } } \\frac { \\partial L } { \\partial h _ { \\delta } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            714,
+            656,
+            813
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where we have plugged in for eq. (11). Expressing the above equation in terms of the Jacobian, it follows that we can write the effect of the adversarial perturbation on the logits by, ",
+        "bbox": [
+            174,
+            821,
+            826,
+            852
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ceee0d33c597ac4b8bde25953cb3945d334ac04357968def4d109df5b98a35ea.jpg",
+        "text": "$$\nh ^ { \\prime } = h + \\epsilon \\frac { J ^ { T } J \\delta } { | | J \\delta | | _ { 2 } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            862,
+            560,
+            898
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "as postulated. ",
+        "bbox": [
+            173,
+            910,
+            264,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/c88352a66455538e3ceb30d420cf36b2a3ba9a8e1ccaa6907bbe9c8b2c3f27af.jpg",
+        "image_caption": [
+            "Figure 14: (a) Distribution of $\\Delta _ { 1 N }$ for other ImageNet models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            101,
+            823,
+            482
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/0969b6740619fa492073f02b297f60c5b900679948f3b95b0f698427fc978a31.jpg",
+        "image_caption": [
+            "Figure 15: (a) FGSM adversarial accuracy of NAS Baseline trained with and without step l.l. adversarial examples in green and red, respectively. Best model from Experiment 1 is shown in blue. (b) FGSM adversarial accuracy of NAS Baseline trained with and without PGD adversarial examples in green and red, respectively. Best model from Experiment 2 is shown in blue. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            536,
+            825,
+            689
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6.2.2 UNIVERSAL PROPERTIES OF THE LOGIT DIFFERENCE DISTRIBUTION",
+        "bbox": [
+            174,
+            795,
+            704,
+            811
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We now show that ",
+        "bbox": [
+            174,
+            823,
+            297,
+            837
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8e6d05ab29463d2fd555ef41f5aee3b98c20c7b72e43fad29aac0bd0ab6d227d.jpg",
+        "text": "$$\nP ( \\Delta _ { 1 j } ) = C \\Delta _ { 1 j } ^ { j - 2 } + \\mathcal { O } ( \\Delta _ { 1 j } ^ { j - 1 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            838,
+            607,
+            861
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To make progress we will again make a mean field approximation and assume that each of the logits are i.i.d. with arbitrary distribution $P ( h )$ . We denote the cumulative distribution $F ( h )$ . While it is not obvious that the factorial approximation is valid here, we will see that the resulting distribution of $P ( \\Delta _ { 1 j } )$ shares many qualitative similarities with the distribution observed in real networks. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We first change variables from the logits to a sorted version of the logits, $r _ { i }$ . The ranked logits are defined such that $r _ { 1 } = \\operatorname* { m a x } ( \\{ h _ { i } \\} )$ , $r _ { 2 } = \\mathrm { m a x } ( \\{ h _ { i } \\} \\backslash \\{ r _ { 1 } \\} ) , \\cdot \\cdot \\cdot$ . Our first result is to compute the resulting joint distribution between $r _ { 1 }$ and $r _ { j }$ , ",
+        "bbox": [
+            173,
+            103,
+            825,
+            147
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7e30fdb7772a040aa882be895ff74d114eb745aa24cec79802ee8918cb71eb27.jpg",
+        "text": "$$\nP _ { j } ( r _ { 1 } , r _ { j } ) = A ( N , j ) F ^ { N - j } ( r _ { j } ) \\left[ F ( r _ { 1 } ) - F ( r _ { j } ) \\right] ^ { j - 2 } P ( r _ { j } ) P ( r _ { 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            154,
+            715,
+            174
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where $A ( N , j ) = N ( N - 1 ) { \\binom { N - 2 } { j - 2 } }$ is a combinatorial factor. Eq. (18) has a simple interpretation. $F ^ { N - j } ( r _ { j } )$ is the probability that there are $N - j$ variables less than $r _ { j }$ ; $[ F ( r _ { 1 } ) - F ( r _ { j } ) ] ^ { j - 2 }$ is the probability that $j - 2$ variables are between $r _ { j }$ and $r _ { 1 }$ ; $P ( r _ { j } ) P ( r _ { 1 } )$ is the probability that there is one variable equal to each of $r _ { 1 }$ and $r _ { j }$ . The combinatorial factor can be understood since there are $N$ ways of selecting $r _ { 1 }$ , $N - 1$ ways of selecting $r _ { j }$ , and $\\binom { N - 2 } { j - 2 }$ ways of choosing $j - 2$ variables out of the remaining $N - 2$ to be between $r _ { j }$ and $r _ { 1 }$ . ",
+        "bbox": [
+            173,
+            179,
+            825,
+            277
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In terms of eq. (18) we can compute the distribution over $\\Delta _ { 1 j }$ to be given by, ",
+        "bbox": [
+            173,
+            282,
+            679,
+            299
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0bd05e3ce70da9c00546c83deaed6336be9eca582945e7436910e23c32af93a3.jpg",
+        "text": "$$\n\\begin{array} { l } { { P ( \\Delta _ { 1 j } ) = \\displaystyle \\int d r P _ { j } ( r + \\Delta _ { 1 j } , r ) } } \\\\ { { \\displaystyle \\qquad = A ( N , j ) \\int d r F ^ { N - j } ( r ) \\left[ F ( r + \\Delta _ { 1 j } ) - F ( r ) \\right] ^ { j - 2 } P ( r ) P ( r + \\Delta _ { 1 j } ) . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            304,
+            759,
+            372
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We can analyze this equation for small $\\Delta _ { 1 j }$ . Expanding to lowest order in $\\Delta _ { 1 j }$ , ",
+        "bbox": [
+            173,
+            376,
+            694,
+            392
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c29d33627f4c5a9e808860029d8c7cc0243d7b15309ec8788ce100c1034c896a.jpg",
+        "text": "$$\n\\begin{array} { l } { P ( \\Delta _ { 1 j } ) \\approx A ( N , j ) \\displaystyle \\int d r { \\cal F } ^ { N - j } ( r ) \\left[ { \\cal F } ( r ) + \\Delta _ { 1 j } P ( r ) - { \\cal F } ( r ) \\right] ^ { j - 2 } P ( r ) \\left[ P ( r ) + \\Delta _ { 1 j } \\frac { d P ( r ) } { d r } \\right] } \\\\ { \\displaystyle ~ ( \\Delta ( N , j ) \\Delta _ { 1 j } ^ { j - 2 } \\int d r { \\cal F } ^ { N - j } ( r ) P ^ { j } ( r ) + \\mathcal { O } ( \\Delta _ { 1 j } ^ { j - 1 } ) . ~ } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            398,
+            803,
+            482
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Since the term in the integral does not depend on $\\Delta _ { 1 j }$ the result follows with, ",
+        "bbox": [
+            176,
+            487,
+            679,
+            502
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6440ba877f82be8ea247cabce64eff5ae88c603741c81ca709806983ccfc6f5d.jpg",
+        "text": "$$\n{ \\cal C } = { \\cal N } ( N - 1 ) { \\binom { N - 2 } { j - 2 } } \\int d r F ^ { N - j } ( r ) P ^ { j } ( r ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            508,
+            658,
+            544
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "6.2.3 ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            556,
+            349,
+            571
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/156b53fcd92de96aae41c52a10d1da280a0afb23260f06022ef070bf60dba302.jpg",
+        "image_caption": [
+            "Figure 16: Left: Best architecture from Experiment 1. Right: Architecture of NAS Baseline. We note that the architecture from Experiment 1 is “longer” and “narrower” than previous architectures found by NAS for higher clean accuracy (Zoph & Le, 2016; Zoph et al., 2017). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            190,
+            821,
+            803
+        ],
+        "page_idx": 15
+    }
+]

parse/train/ryebG04YvB/ryebG04YvB.md

@@ -0,0 +1,268 @@
+# ADVERSARIALLY ROBUST TRANSFER LEARNING
+
+Ali Shafahi∗†, Parsa Saadatpanah∗†, Chen Zhu∗†, Amin Ghiasi†, Cristoph Studer‡,   
+ashafahi,parsa,chenzhu,amin @cs.umd.edu ; studer@cornell.edu   
+David Jacobs†, Tom Goldstein†   
+{djacobs,tomg}@cs.umd.edu
+
+# ABSTRACT
+
+Transfer learning, in which a network is trained on one task and re-purposed on another, is often used to produce neural network classifiers when data is scarce or full-scale training is too costly. When the goal is to produce a model that is not only accurate but also adversarially robust, data scarcity and computational limitations become even more cumbersome. We consider robust transfer learning, in which we transfer not only performance but also robustness from a source model to a target domain. We start by observing that robust networks contain robust feature extractors. By training classifiers on top of these feature extractors, we produce new models that inherit the robustness of their parent networks. We then consider the case of “fine tuning” a network by re-training end-to-end in the target domain. When using lifelong learning strategies, this process preserves the robustness of the source network while achieving high accuracy. By using such strategies, it is possible to produce accurate and robust models with little data, and without the cost of adversarial training. Additionally, we can improve the generalization of adversarially trained models, while maintaining their robustness.
+
+# 1 INTRODUCTION
+
+Deep neural networks achieve human-like accuracy on a range of tasks when sufficient training data and computing power is available. However, when large datasets are unavailable for training, or pracitioners require a low-cost training strategy, transfer learning methods are often used. This process starts with a source network (pre-trained on a task for which large datasets are available), which is then re-purposed to act on the target problem, usually with minimal re-training on a small dataset (Yosinski et al., 2014; Pan & Yang, 2009).
+
+While transfer learning greatly accelerates the training pipeline and reduces data requirements in the target domain, it does not address the important issue of model robustness. It is well-known that naturally trained models often completely fail under adversarial inputs (Biggio et al., 2013; Szegedy et al., 2013). As a result, researchers and practitioners often resort to adversarial training, in which adversarial examples are crafted on-the-fly during network training and injected into the training set. This process greatly exacerbates the problems that transfer learning seeks to avoid. The high cost of creating adversarial examples increases training time (often by an order of magnitude or more). Furthermore, robustness is known to suffer when training on a small dataset (Schmidt et al., 2018). To make things worse, high-capacity models are often needed to achieve good robustness (Madry et al., 2017; Kurakin et al., 2016; Shafahi et al., 2019b), but these models may over-fit badly on small datasets.
+
+# CONTRIBUTIONS
+
+The purpose of this paper is to study the adversarial robustness of models produced by transfer learning. We begin by observing that robust networks contain robust feature extractors, which are resistant to adversarial perturbations in different domains. Such robust features can be used as a basis for semi-supervised transfer learning, which only requires re-training the last layer of a network. To demonstrate the power of robust transfer learning, we transfer a robust ImageNet source model onto the CIFAR domain, achieving both high accuracy and robustness in the new domain without adversarial training. We use visualization methods to explore properties of robust feature extractors. Then, we consider the case of transfer of learning by “fine-tuning.” In this case, the source network is re-trained end-to-end using a small number of epochs on the target domain. Unfortunately, this end-to-end process does not always retain the robustness of the source domain; the network “forgets” the robust feature representations learned on the source task. To address this problem, we use recently proposed lifelong learning methods that prevent the network from forgetting the robustness it once learned. Using our proposed methods, we construct robust models that generalize well. In particular, we improve the generalization of a robust CIFAR-100 model by roughly $2 \%$ while preserving its robustness.
+
+# 2 BACKGROUND
+
+Adversarial examples fall within the category of evasion attacks—test-time attacks in which a perturbation is added to a natural image before inference. Adversarial attacks are most often crafted using a differentiable loss function that measures the performance of a classifier on a chosen image. In the case of norm-constrained attacks (which form the basis of most standard benchmark problems), the adversary solves
+
+$$
+\operatorname* { m a x } _ { \delta } \quad l ( x + \delta , y , \theta ) \qquad \mathrm { s . t . } \quad \| \delta \| _ { p } \leq \epsilon ,
+$$
+
+where $\theta$ are the (already trained and frozen) parameters of classifier $c ( x , \theta ) \to \hat { y }$ that maps an image to a class, $l$ is the proxy loss used for classification (often cross-entropy), $\delta$ is the image perturbation, $( x , y )$ is the natural image and its true class, and $| | . | | _ { p }$ is some $\ell _ { p } { \ - } \mathrm { n o r m } ^ { 1 }$ . The optimization problem in Eq. 1 aims to find a bounded perturbation that maximizes the cross-entropy loss given the correct label. There are many variants of this process, including DeepFool (Moosavi-Dezfooli et al., 2016), L-BFGS (Szegedy et al., 2013), and CW (Carlini & Wagner, 2017).
+
+Many researchers have studied methods for building a robust network which have been later shown to be ineffective when attacked with stronger adversaries (Athalye et al., 2018). Adversarial training (Szegedy et al., 2013) is one of the defenses that was not broken by Athalye et al. (2018). While adversarial training using a weak adversary such as the FGSM attack (Goodfellow et al., 2015) can be broken even by single step attacks which add a simple random step prior to the FGSM step (Tramer\` et al., 2017), adversarial training using a strong attack has successfully improved robustness. Madry et al. (2017) showed that a PGD attack (which is a BIM attack (Kurakin et al., 2016) with an initial random step and projection) is a strong enough attack to achieve promising adversarial training results. We will refer to this training method as PGD adversarial training. PGD adversarial training achieves good robustness on bounded attacks for MNIST (LeCun et al., 1998) and acceptable robustness on CIFAR-10 (Krizhevsky & Hinton, 2009) classifiers.
+
+Tsipras et al. (2018) show that adversarial training with strong PGD adversaries has many benefits in addition to robustness. They also state that while adversarial training may improve generalization in regimes where training data is limited (especially on MNIST), it may be at odds with generalization in regimes where data is available. This trade-off was also recently studied by Zhang et al. (2019), Su et al. (2018), and Shafahi et al. (2019a).
+
+While, to the best of our knowlegde, the transferability of robustness has not been studied in depth, Hendrycks et al. (2019) studied the case of adversarially training models that were pre-trained on different domains. Our work is fundamentally different in that we seek to transfer robustness without resorting to costly and data-hungry adversarial training. We train the target model on natural examples only, which allows us to directly study how well robustness transfers. Additionally, this allows us to have better generalization and achieve higher accuracy on validation examples. While as Hendrycks et al. (2019) state, fine-tuning on adversarial examples built for the target domain can improve robustness of relatively large datasets such as CIFAR-10 and CIFAR-100 compared to adversarial training from scratch on the target domain, we show that in the regimes of limited data (where transfer learning is more common), adversarially robust transfer learning can lead to better results measured in terms of both robustness and clean validation accuracy.
+
+Table 1: Accuracy and robustness of natural and adversarially trained models on CIFAR- $^ { 1 0 + }$ and CIFAR- $1 0 0 +$ . The $" + "$ sign denotes standard data augmentation $( \epsilon = 8$ ).   
+
+<table><tr><td>Dataset</td><td>model</td><td>validation accuracy</td><td>accuracy on PGD-20</td><td> accuracy on CW-20</td></tr><tr><td rowspan="2">CIFAR-10+</td><td rowspan="2">natural robust</td><td>95.01%</td><td>0.00%</td><td>0.00%</td></tr><tr><td>87.25%</td><td>45.84%</td><td>46.96%</td></tr><tr><td rowspan="2">CIFAR-100+</td><td rowspan="2">natural robust</td><td>78.84%</td><td>0.00%</td><td>0.00%</td></tr><tr><td>59.87%</td><td>22.76%</td><td>23.16%</td></tr></table>
+
+# 3 THE ROBUSTNESS OF DEEP FEATURES
+
+In this section, we explore the robustness of different network layers, and demonstrate that robust networks rely on robust deep features. To do so, we start from robust classifiers $( c ( \theta _ { r } ) )$ for the CIFAR-100 and CIFAR-10 datasets (Krizhevsky & Hinton, 2009), and update $\theta$ by training on natural examples. In each experiment, we re-initialize the last $k$ layers/blocks of the network, and re-train just those layers. We start by re-initializing just the last layer, then the last two, and so on until we re-initialize all the layers.
+
+We use the adversarially trained Wide-ResNet 32-10 (Zagoruyko & Komodakis, 2016) for CIFAR10 from Madry et al. (2017) as our robust model for CIFAR-10. We also adversarially train our own robust classifier for CIFAR-100 using the code from Madry et al. (2017). To keep things consistent, we use the same hyper-parameters used by Madry et al. (2017) for adversarially training CIFAR-10 to adversarially train the CIFAR-100 model.2 The performance of the CIFAR-10 and CIFAR-100 models on natural and adversarial examples are summarized in Table 1. To measure robustness, we evaluate the models on adversarial examples built using PGD attacks.
+
+We break the WRN 32-10 model into 17 blocks, which are depicted in Fig. 2. In each experiment, we first re-initialize the $k$ deepest blocks (blocks 1 through $k$ ) and then train the parameters of those blocks on natural images3. We train for 20,000 iterations using Momentum SGD and a learning rate of 0.001. We then incrementally unfreeze and train more blocks. For each experiment, we evaluate the newly trained model’s accuracy on validation adversarial examples built with a 20-step PGD $\ell _ { \infty }$ attack with $\epsilon = 8$ .
+
+Fig. 1 shows that robustness does not drop if only the final layers of the networks are re-trained on natural examples. In fact, there is a slight increase in robustness compared to the baseline PGD7 adversarially trained models when we just retrain the last batch-normalization block and fully connected block. As we unfreeze and train more blocks, the network’s robustness suddenly drops. This leads us to believe that a hardened network’s robustness is mainly due to robust deep feature representations and robustness is preserved if we re-train on top of deep features.
+
+![](images/c33719c1a824606b01236b8b81daf48b068d3513906190353bbe64339d86daf0.jpg)  
+Figure 2: Wide Resnet 32-10 and the blocks used for freezing/retraining
+
+Now that we have identified feature extractors as a source of robustness, it is natural to investigate whether robustness is preserved when transfer learning using robust feature extractors. We will study two different approaches for transferring robustness across datasets: one in which only the last layer is re-trained, and one with end-to-end re-training.
+
+![](images/26389130b72972f6e201592b236dfb033e1ef54168c8a5802e473d5d373c7127.jpg)  
+Figure 1: Robustness is preserved when we retrain only the deepest block(s) of robust CIFAR10 and CIFAR-100 models using natural examples. The vertical axis is the accuracy on PGD-20 generated adversarial examples (i.e. robustness) after re-training deep layers. The robustness of the adversarially trained models if all layers are frozen are shown with dashed lines.
+
+# 4 TRANSFER LEARNING: RECYCLING FEATURE EXTRACTORS
+
+We study how robustness transfers when the feature extractor layers of the source network are frozen, and we retrain only the last fully connected layer (i.e. the classification layer) for the new task. Formally, the transfer learning objective is:
+
+$$
+\operatorname* { m i n } _ { w } \quad l ( z ( x , \theta ^ { * } ) , y , w )
+$$
+
+where $z$ is the deep feature extractor function with pre-trained and now “frozen” parameters $\theta ^ { * }$ , and $w$ represents the trainable parameters of the last fully connected layer. To investigate how well robustness transfers, we use two source models: one that is hardened by adversarial training and another that is naturally trained.
+
+We use models trained on CIFAR-100 as source models and perform transfer learning from CIFAR100 to CIFAR-10. The results are summarized in Table 2. Compared to adversarial/natural training the target model, transferring from a source model seems to result in a drop in natural accuracy (compare first row of Table 1 to the first row of Table 2). This difference is wider when the source and target data distributions are dissimilar (Yosinski et al., 2014).
+
+To evaluate our method on two datasets with more similar attributes, we randomly partition CIFAR100 into two disjoint subsets where each subset contains images corresponding to 50 classes. Table 2 shows the accuracy of transferring from one of the disjoint sets to the other (second row) and to the same set (third row). We can compare results of transfer learning with adversarial training on CIFAR-100 by averaging the results in the second and third rows of Table 2 to get the accuracy across all 100 classes of CIFAR-100.4 By doing so, we see that the accuracy of the transferred classifier matches that of the adversarially trained one, even though no adversarial training took place in the target domain. For completeness, we have also included experiments where we use CIFAR-10 as the source and CIFAR-100 as the target domain.
+
+We make the following observations from the transfer-learning results in Table 2. 1) robustness transfers: when the source model used for transfer learning is robust, the target model is also robust (although less so than the source), 2) robustness transfers between models that are more similar: If the source and target models are trained on datasets which have similar distributions (and number of classes), robustness transfers better, and 3) validation accuracy is worst if we use a robust model as the source compared to using a conventionally trained source model: if the source model is naturally trained, the natural validation accuracy is better, although the target model is then vulnerable to adversarial perturbations.
+
+Table 2: Transfer learning by freezing the feature extractor layers $\epsilon = 8$ ).   
+
+<table><tr><td rowspan=1 colspan=1>Source Dataset</td><td rowspan=1 colspan=1>Target Dataset</td><td rowspan=1 colspan=1>Source Model</td><td rowspan=1 colspan=1>val.</td><td rowspan=1 colspan=1>PGD-20</td><td rowspan=1 colspan=2>CW-20</td></tr><tr><td rowspan=2 colspan=1>CIFAR-100</td><td rowspan=2 colspan=1>CIFAR-10</td><td rowspan=2 colspan=1>naturalrobust</td><td rowspan=1 colspan=1>83.05%</td><td rowspan=1 colspan=1>0.00%</td><td rowspan=1 colspan=2>0.00%</td></tr><tr><td rowspan=1 colspan=1>72.05%</td><td rowspan=1 colspan=1>17.70%</td><td rowspan=1 colspan=2>17.43%</td></tr><tr><td rowspan=2 colspan=1>CIFAR-100(50% of classes)</td><td rowspan=2 colspan=1>CIFAR-100(other 50% of classes)</td><td rowspan=2 colspan=1>naturalrobust</td><td rowspan=1 colspan=1>71.44%</td><td rowspan=2 colspan=1>0.00%15.86%</td><td rowspan=2 colspan=2>0.00%15.30%</td></tr><tr><td rowspan=1 colspan=1>58.48%</td></tr><tr><td rowspan=2 colspan=1>CIFAR-100(50% of classes)</td><td rowspan=2 colspan=1>CIFAR-100(same 50% of classes)</td><td rowspan=2 colspan=1>naturalrobust</td><td rowspan=1 colspan=1>80.20%</td><td rowspan=1 colspan=1>0.00%</td><td rowspan=2 colspan=2>0.00%25.56%</td></tr><tr><td rowspan=1 colspan=1>64.96%</td><td rowspan=1 colspan=1>25.16%</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=2 colspan=1>CIFAR-10</td><td rowspan=2 colspan=1>CIFAR-100</td><td rowspan=2 colspan=1>naturalrobust</td><td rowspan=2 colspan=1>49.66%41.59%</td><td rowspan=1 colspan=1>0.00%</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>0.00%</td></tr><tr><td rowspan=1 colspan=1>11.63%</td><td rowspan=1 colspan=2>9.68%</td></tr></table>
+
+Table 3: Transfer learning from ImageNet $\epsilon = 5$ ).   
+
+<table><tr><td>Architecture and Source Dataset</td><td>Target Dataset</td><td>Source Model</td><td>val.</td><td>PGD-20</td><td>CW-20</td></tr><tr><td>ResNet-50 ImageNet</td><td>CIFAR-10+ CIFAR-100+</td><td>natural robust (ε = 5) natural robust (e = 5)</td><td>90.49% 88.33% 72.84% 68.88% 82.00%</td><td>0.01% 22.66% 0.05% 15.21%</td><td>0.00% 26.01% 0.00% 18.34%</td></tr><tr><td colspan="4">Robust u-ResNet-50 (ε = 5) for CIFAR-10+ Robust u-ResNet-50 (ε = 5) for CIFAR-100+</td><td>53.11% 59.90% 29.54%</td><td></td></tr></table>
+
+# 4.1 TRANSFER LEARNING WITH IMAGENET MODELS
+
+Transfer learning using models trained on ImageNet (Russakovsky et al., 2015) as the source is a common practice in industry because ImageNet feature extractors are powerful and expressive. In this section we evaluate how well robustness transfers from these models.
+
+# 4.1.1 TRANSFER LEARNING USING IMAGENET
+
+Starting from both a natural and robust ImageNet model, we perform the same set of experiments we did in section 4. Robust ImageNet models do not withstand untargeted $\ell _ { \infty }$ attacks using as large an $\epsilon$ as those that can be used for simpler datasets like CIFAR. Following the method Shafahi et al. (2019b), we “free train” a robust ResNet-50 on ImageNet using replay hyper-parameter $m = 4$ . The hardened ImageNet classifier withstands attacks bounded by $\epsilon = 5$ . Our robust ImageNet achieves $5 9 . 0 5 \%$ top-1 accuracy and roughly $27 \%$ accuracy against $\mathrm { P G D } { - } 2 0 \ \ell _ { \infty } \ \epsilon = 5$ attacks on validation examples. We experiment with using this robust ImageNet model and a conventionally trained ResNet-50 ImageNet model as the source models.
+
+Using the ImageNet source models, we train CIFAR classifiers by retraining the last layer on natural CIFAR examples. We up-sample the $3 2 \times 3 2$ -dimensional CIFAR images to $2 2 4 \times 2 2 4$ before feeding them into the ResNet-50 source models that are trained on ImageNet. For evaluation purposes, we also train robust ResNet-50 models from scratch using (Shafahi et al., 2019b) for the CIFAR models. To ensure that the transfer learning models and the end-to-end trained robust models have the same capacity and dimensionality, we first upsample the CIFAR images before feeding them to the ResNet-50 model. To distinguish between the common case of training ResNet models on CIFAR images that are $3 2 \times 3 2$ -dimensional, we call our models that are trained on the upsampled CIFAR datasets the upsample-first ResNets or “ $_ u$ -ResNets”.
+
+Table 3 illustrates that using a robust ImageNet model as a source results in high validation accuracy for the transferred CIFAR target models. Also, given that the ImageNet classifier by itself is $27 \%$ robust, the CIFAR-10 model maintains the majority of that $27 \%$ robustness. When we compare the end-to-end hardened classifiers (robust u-ResNets) with the transferred classifier, we can see that while the robustness is less for the transferred case, transferred models result in considerably better performance on clean validation examples.
+
+![](images/01d1c93d1deb9bf8eb77a92ca8ee8b52dc60c15e403ab86ce0a13a908ea8a7ca.jpg)  
+Figure 3: When the number of training data per-class is very limited (right bars), adversarially robust transfer learning [Transferred] is better in all metrics. However, as the number of training data increases (left bars), fine-tuning with adversarial examples of the target domain [Fine-tuned with AT] results in more robustness. Adversarially robust transfer learning always results in models that work better on natural examples and is $3 \times$ faster than fine-tuning with adversarial examples of the target domain. Using a pre-trained robust ImageNet improves both robustness and generalization.
+
+# 4.2 LOW-DATA REGIME
+
+As touched on before, transfer learning is more common in situations where the number of training points in the target domain is limited. Up until now, as a proof of concept, we have illustrated the majority of our experiments on the CIFAR target domains where we have many training points perclass. Hendrycks et al. (2019) show that starting from a pre-trained robust ImageNet model and fine-tuning on adversarial examples of the CIFAR domain can improve robustness beyond that of simply adversarial training CIFAR. Here, we illustrate the effect of training data size on robustness and natural performance by running various experiments on subsets of CIFAR-100 where we vary the number of training points per-class $( N )$ .
+
+We compare three different hardening methods: (1) Free-training/adversarial training the target domain (Shafahi et al., 2019b); (2) fine-tuning using adversarial examples of the target task starting from the Free-4 robust ImageNet model similar to (Hendrycks et al., 2019); and (3) training a fully connected layer on top of the frozen feature extractors of the Free-4 robust ImageNet model using natural examples from the target task. For comparing the three different approaches, we look at three metrics: (a) clean validation accuracy; (b) robustness against PGD-20 validation adversarial examples; and (c) average of robustness and clean performance $( ( ( { \mathbf { a } } ) \substack { + } ( { \mathbf { b } } ) ) / 2 .$ .) The results are summarized in Fig. 3. In the regimes where transfer learning is more common, adversarially robust transfer learning results in the best overall performance. Adversarially/Free training the target domain results in less robustness and validation accuracy compared to fine-tuning which highlights the importance of pre-training (Hendrycks et al., 2019). Note that in terms of computational resources required, the cost of fine-tuning on adversarial examples of the target domain is about $k \times$ our method since it requires generation of adversarial examples using $k$ -step PGD attacks (we set $k = 3$ ).
+
+# 4.2.1 TRAINING DEEPER NETWORKS ON TOP OF ROBUST FEATURE EXTRACTORS
+
+The basic transfer learning setting of section 4.1.1 only re-trains one layer for the new task. In section 4.1.1, when we transferred from the robust ImageNet to CIFAR-100, the natural training accuracy was $8 8 . 8 4 \%$ . Given the small number of trainable parameters left for the network $( \approx 2 0 4 8 \times 1 0 0 )$ and the fixed feature extractor, the network was not capable of completely fitting the training data. This means that there is potential to improve natural accuracy by learning more complex non-linear features and increasing the number of trainable parameters.
+
+To increase representation capacity and the number of trainable parameters, instead of training a 1- layer network on top of the feature extractor, we train a multi-layer perceptron (MLP) network on top of the robust feature extractor. To keep things simple and prevent bottle-necking, every hidden layer we add has 2048 neurons. We plot the training and validation accuracies on the natural examples and the robustness (i.e. PGD-20 validation accuracy) in Fig. 4 for various numbers of hidden layers. As can be seen, adding one layer is enough to achieve $100 \%$ training accuracy. However, doing so does not result in an increase in validation accuracy. To the contrary, adding more layers can result in a slight drop in validation accuracy due to overfitting. As illustrated, we can improve generalization using simple but effective methods such as dropout (Srivastava et al., 2014) (with probability 0.25) and batch-normalization (Ioffe & Szegedy, 2015).
+
+However, the most interesting behavior we observe in this experiment is that, as we increase the number of hidden layers, the robustness to PGD-20 attacks improves. Note, this seems to happen even when we transfer from a naturally trained ImageNet model. While for the case where we have no hidden layers, robustness is $0 . 0 0 \%$ on CIFAR100 when we use a naturally trained ImageNet model as source, if our MLP has 1, 2, 3, or 5 hidden layers, our robustness against PGD attacks would be $0 . 0 3 \%$ , $0 . 0 9 \%$ , $0 . 3 1 \%$ and $6 . 6 1 \%$ , respectively. This leads us to suspect that this behavior may be an artifact of vanishing gradients for adversary as the softmax loss saturates when the data is fit perfectly (Athalye et al., 2018). Therefore, for this case we change our robustness measure and use the CW attack (Carlini & Wagner, 2017) which will encounter fewer numerical issues because its loss function does not have a softmax component and does not saturate. Attacking the model from the natural source with CW-20 completely breaks the model and achieves $0 . 0 0 \%$ robustness. Most interestingly, attacking the model transferred from a robust source using the CW objective maintains robustness even when the number of hidden layers increases.
+
+![](images/d7dc13914a53060c4642c873547b936577d5c1b0aac10205445054bce8269453.jpg)  
+Figure 4: Training an MLP for CIFAR-100 on top of the robust feature extractors from ImageNet. The xaxis corresponds to the number of hidden layers (0 is a linear classifier and corresponds to experiments in section 4.1.1). Robustness stems from robust feature extractors. Adding more layers on top of this extractor does not hurt robustness. Interestingly, simply adding more layers does not improve the validation accuracy and just results in more overfitting (i.e. training accuracy becomes $100 \%$ ). We can slightly improve generalization using batch norm (BN) and dropout (DO).
+
+# 5 ANALYSIS: ROBUST FEATURE EXTRACTORS ARE FILTERS
+
+Our experiments suggest that the robustness of neural networks arises in large part from the presence of robust feature extractors. We have used this observation to transfer both robustness and accuracy between domains using transfer-learning. However, we have not yet fully delved into what it means to have a robust feature extractor. Through visualizations, Tsipras et al. (2018) studied how adversarial training causes the image gradients of neural networks to exhibit meaningful generative behavior. In other words, adversarial perturbations on hardened networks “look like” the class into which the image is perturbed. Given that optimization-based attacks build adversarial examples using the image gradient, we also visualize the image gradients of our transferred models to see if they exhibit the same generative behavior as adversarially trained nets.
+
+Fig. 5 plots the gradient of the loss w.r.t. the input image for models obtained by re-training only the last layer, and also for the case where we train MLPs on top of a robust feature extractor. The gradients for the transfer-learned models with a robust source are interpretable and “look like” the adversarial object class, while the gradients of models transferred from a natural source do not. This interpretatbility comes despite the fact that the source model was hardened against attacks on one dataset, and the transferred model is being tested on object classes from another. Also, we see that adding more layers on top of the feature extractor, which often leads to over-fitting, does not make gradients less interpretable. This latter observation is consistent with our observation that added layers preserve robustness(Fig. 4).
+
+These observations, together with the success of robust transfer learning, leads us to speculate that a robust model’s feature extractors act as a “filter” that ignores irrelevant parts of the image.
+
+![](images/08230f2415fe9b53e0ed050b0381109d2e05361ef7883e2dc1b013007c587098.jpg)  
+Figure 5: Gradients of the loss w.r.t to input images for the CIFAR-100 transfer learning experiments of sections $4 . 1 . 1 \ \&$ 4.2.1. The top row contains sample CIFAR-100 images. Other rows contain image gradients of the model loss. The second row is for a model transferred from a naturally trained ImageNet source. Rows 3-5 are for models transferred from a robust ImageNet source. These rows correspond to an MLP with 0 (row 3), 1 (row 4), and 2 (row 5) hidden layers on top of the robust feature extractor. The gradients in the last three rows all show interpretable generative behavior.
+
+# 6 END-TO-END TRAINING WITHOUT FORGETTING
+
+As discussed in section 4, transfer learning can preserve robustness of the robust source model. However, it comes at the cost of decreased validation accuracy on natural examples compared to the case where we use a naturally trained source model. Consequently, there seems to be a trade-off between generalization and robustness based on the choice of the source model. For any given classifer, the trade-off between generalization and robustness is the subject of recent research (Tsipras et al., 2018; Zhang et al., 2019; Shafahi et al., 2019a). In this section, we intend to improve the overall performance of classifiers transferred from a robust source model by improving their generalization on natural images. To do so, unlike previous sections where we froze the feature extractor mainly to preserve robustness, we fine tune the feature extractor parameters $\theta$ . Ideally, we should learn to perform well on the target dataset without catastrophically forgetting the robustness of the source model. To achieve this, we utilize lifelong learning methods.
+
+Learning without Forgetting (LwF) (Li & Hoiem, 2018) is a method for overcoming catastrophic forgetting. The method is based on distillation. In this framework, we train the target model with a loss that includes a distillation term from the previous model.
+
+$$
+\operatorname* { m i n } _ { w , \theta } \quad l ( z ( x , \theta ) , y , w ) + \lambda _ { d } \cdot d ( z ( x , \theta ) , z _ { 0 } ( x , \theta _ { r } ^ { * } ) )
+$$
+
+![](images/1b65be02dcb26f582c98135d5bcacb719bebefac5da0577079cd0b265af93269.jpg)  
+Figure 6: Our LwF loss has a term that enforces the similarity of feature representations (i.e. penultimate layer activations) between the source model and the fine-tuned model.
+
+where, in our method, $\lambda _ { d }$ is the feature representation similarity penalty, and $d$ is some distance metric between the robust model’s feature representations $z _ { 0 } ( x , \theta _ { r } ^ { * } )$ and the current model’s feature representations $z ( x , \theta )$ . Unlike the original LwF paper that used a distilled loss from Hinton et al. (2015) and applies distillation to the logits, we simply choose $d$ to be the $\ell _ { 2 }$ -norm and apply distillation to the penultimate layer5. Our loss is designed to make the feature representations of the source and target network similar, thus preserving the robust feature representations (Fig. 6). Ideally, $z ( x , \theta ) \approx \mathbf { \bar { \Phi } } { z } ( x , \theta _ { r } ^ { * } )$ . To speed up training, given robust feature extractor parameters $\theta _ { r } ^ { * }$ , we store $z _ { 0 } ( x , \theta _ { r } ^ { * } )$ for the images of the target task and load this from memory (i.e. offline) instead of performing a forward pass through the robust source network online. Therefore, in the experiments related to LwF, we do not train with data augmentation because we have not pre-computed $z ( x _ { a } , \theta _ { r } ^ { * } )$ , where $x _ { a }$ is the augmented image. Empirically we verified that $d ( z ( x , \theta _ { r } ^ { * } ) , z ( x _ { a } , \theta _ { r } ^ { * } ) )$ was not negligible6.
+
+To improve performance, we follow a warm-start scheme and only train the fully connected parameters $w$ early in training. We then cut the learning rate and continue fine tuning both feature extractors $\mathbf { \eta } ^ { ( \theta ) }$ and $w$ . In our experiments, we use a learning rate of 0.001, and the warm-start makes up half of the total training iterations. Starting from the pre-trained source model, we train for a total of 20,000 iterations with batch-size 128. The results with an adversarially trained CIFAR-100 model as source and CIFAR-10 as target are summarized in Table 4.7
+
+As can be seen, having a LwF-type regularizer helps in maintaining robustness and also results in a considerable increase in validation accuracy. The trade-off between robustness and generalization can be controlled by the choice of $\lambda _ { d }$ . It seems that for some choices of $\lambda _ { d }$ such as 0.1, robustness also increases. However, in hindsight, the increase in accuracy on PGD-20 adversarial examples is not solely due to improvement in robustness. It is due to the fact that the validation accuracy has increased and we have a better classifier overall. For easier comparisons, we have provided the transfer results without LwF at the bottom of Table 4. Note that using LwF, we can keep the robustness of the source model and also achieve clean validation accuracy comparable to a model that uses naturally trained feature extractors. In the supplementary, we show that similar conclusions can be drawn for the split CIFAR-100 task.
+
+Table 4: Distilling robust features using learning without forgetting. The bottom rows show results from transfer learning with a frozen feature extractor. The $\cdot _ { + } ,$ sign refers to using augmentation.   
+
+<table><tr><td>Source →Target Dataset</td><td>Source Model</td><td>入d</td><td>val.</td><td>PGD-20 (ε = 8)</td></tr><tr><td rowspan="5">CIFAR-100+→CIFAR-10</td><td rowspan="5">robust</td><td>1e-7</td><td>89.07%</td><td>0.61%</td></tr><tr><td>0.001</td><td>86.15%</td><td>4.70%</td></tr><tr><td>0.0025</td><td>81.90%</td><td>15.42%</td></tr><tr><td>0.005</td><td>79.35%</td><td>17.61%</td></tr><tr><td>0.01</td><td>77.73%</td><td>17.55%</td></tr><tr><td rowspan="2">CIFAR-10O+→CIFAR-10+</td><td rowspan="2">natural robust</td><td>0.1 NA</td><td>73.39% 83.05%</td><td>18.62% 0.00%</td></tr><tr><td>NA</td><td>72.05%</td><td>17.70%</td></tr></table>
+
+# ECREASING GENERALIZATION GAP OF ADVERSARIALLY TRAINED NETWORK
+
+We demonstrated in our transfer experiments that using our LwF-type loss, can help decrease the generalization gap while preserving robustness. In this section, we assume that the source domain is the adversarial example domain of a dataset and the target domain is the clean example domain of the same dataset. This experiment can be seen as applying transfer learning from the adversarial example domain to the natural example domain while preventing forgetting the adversarial domain.
+
+In the case where the source and target datasets are the same (Transferring from a robust CIFAR-100 model to CIFAR-100), by applying our LwF-type loss, we can improve the generalization of robust models. Our results are summarized in Table 5.
+
+Table 5: Decreasing generalization gap by transferring with LwF. For reference, last row shows results from adversarial training CIFAR-100. The $\cdot _ { + } ,$ sign refers to using augmentation. $\epsilon = 8$ )   
+
+<table><tr><td>Source→Target Dataset</td><td>Source Model</td><td>入d</td><td>val.</td><td>PGD-20</td><td>CW-20</td></tr><tr><td rowspan="3">CIFAR-10O+→ CIFAR-100</td><td rowspan="3">robust</td><td>1e-5</td><td>61.53% 61.71%</td><td>21.83% 23.44%</td><td>21.97% 22.94%</td></tr><tr><td>5e-5 1e-4</td><td>61.38%</td><td>23.95%</td><td>23.40%</td></tr><tr><td>0.001</td><td>60.17%</td><td>24.31%</td><td>23.17%</td></tr><tr><td>CIFAR-100+</td><td>robust</td><td>0.01 NA</td><td>59.87% 59.87%</td><td>24.10% 22.76%</td><td>22.96% 23.16%</td></tr></table>
+
+# 7 CONCLUSION
+
+We identified the feature extractors of adversarially trained models as a source of robustness, and use this observation to transfer robustness to new problems domains without adversarial training. While transferring from a natural model can achieve higher validation accuracy in comparison to transferring from a robust model, we can close the gap and maintain the initial transferred robustness by borrowing ideas from the lifelong learning literature. The success of this methods suggests that a robust feature extractor is effectively a filter that sifts out relevant components of an image that are needed to assign class labels. We hope that the insights from this study enable practitioners to build robust models in situations with limited labeled training data, or when the cost and complexity of adversarial training from scratch is untenable.
+
+Acknowledgements: Goldstein and his students were supported by the DARPA QED for RML program, the DARPA GARD program, and the National Science Foundation.
+
+# REFERENCES
+
+Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. arXiv preprint arXiv:1802.00420, 2018.
+
+Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Srndi ˇ c, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Joint European conference on machine learning and knowledge discovery in databases, pp. 387–402. Springer, 2013.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 IEEE Symposium on Security and Privacy (SP), pp. 39–57. IEEE, 2017.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. International Conference on Learning Representation, 2015.
+
+Dan Hendrycks, Kimin Lee, and Mantas Mazeika. Using pre-training can improve model robustness and uncertainty. arXiv preprint arXiv:1901.09960, 2019.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, Patrick Haffner, et al. Gradient-based learning applied ´ to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE transactions on pattern analysis and machine intelligence, 40(12):2935–2947, 2018.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2574–2582, 2016.
+
+Sinno Jialin Pan and Qiang Yang. A survey on transfer learning. IEEE Transactions on knowledge and data engineering, 22(10):1345–1359, 2009.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International journal of computer vision, 115(3):211–252, 2015.
+
+Ludwig Schmidt, Shibani Santurkar, Dimitris Tsipras, Kunal Talwar, and Aleksander Madry. Adversarially robust generalization requires more data. In Advances in Neural Information Processing Systems, pp. 5014–5026, 2018.
+
+Ali Shafahi, W Ronny Huang, Christoph Studer, Soheil Feizi, and Tom Goldstein. Are adversarial examples inevitable? ICLR, 2019a.
+
+Ali Shafahi, Mahyar Najibi, Amin Ghiasi, Zheng Xu, John Dickerson, Christoph Studer, Larry S Davis, Gavin Taylor, and Tom Goldstein. Adversarial training for free! arXiv preprint arXiv:1904.12843, 2019b.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014.
+
+Dong Su, Huan Zhang, Hongge Chen, Jinfeng Yi, Pin-Yu Chen, and Yupeng Gao. Is robustness the cost of accuracy?–a comprehensive study on the robustness of 18 deep image classification models. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 631–648, 2018.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Florian Tramer, Alexey Kurakin, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick Mc-\` Daniel. Ensemble adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017.
+
+Dimitris Tsipras, Shibani Santurkar, Logan Engstrom, Alexander Turner, and Aleksander Madry. Robustness may be at odds with accuracy. stat, 1050:11, 2018.
+
+Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Advances in neural information processing systems, pp. 3320–3328, 2014.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.
+
+Hongyang Zhang, Yaodong Yu, Jiantao Jiao, Eric P Xing, Laurent El Ghaoui, and Michael I Jordan. Theoretically principled trade-off between robustness and accuracy. arXiv preprint arXiv:1901.08573, 2019.
+
+# A EXPERIMENT DETAILS
+
+# A.1 LWF-BASED EXPERIMENTS
+
+In our LWF-based experiments, we use a batch-size of 128, a fixed learning-rate of $1 \mathrm { e } { - } 2 \mathrm { m }$ , and fine-tune for an additional 20,000 iterations. The first 10,000 iterations are used for warm-start; during which we only update the final fully connected layer’s weights. During the remaining 10,000 iterations, we update all of the weights but do not update the batch-normalization parameters.
+
+# A.2 IMAGENET TO CIFAR EXPERIMENTS
+
+When freezing the feature extractor and fine-tuning on adversarial examples, we train the last fully connected layer’s weights for 50 epochs using batch-size ${ \mathrm { - } } 1 2 8$ . We start with an initial learning rate of 0.01 and drop the learning rate to 0.001 at epoch 30. In the case of fine-tuning on adversarial examples, we generate the adversarial examples using a 3 step PGD attack with step-size 3 and a perturbation bound $\epsilon = 5$ .
+
+# A.3 FREE TRAINING EXPERIMENTS
+
+In all of our free-training experiments where we train the u-ResNet-50, we train for 90 epochs using a batch-size of 128. The initial learning rate used is 0.1 and we drop it by a factor of 10 at epochs 30 and 60. We use a replay parameter $m = 4$ and perturbation bound $\epsilon = 5$ .
+
+# B THE DISTANCE BETWEEN FEATURE REPRESENTATIONS OF NATURAL IMAGES AND AUGMENTED IMAGES
+
+To speed up the LwF experiments, we did not use data augmentation during training. Instead of computing the robust feature representations on the fly, before starting training on the new target task, we passed the entire training data of the target task through the robust network and stored the feature representation vector. If we were doing data augmentation, we would have to pass the entire augmented training data through the network, which would be slow and memory intensive. Alternatively, we could use the robust feature representation of the non-augmented images instead. The latter would have been feasible if the distance between the robust feature representations of the non-augmented and augmented images were very small. However, as shown in fig 7, this quantity is not often negligible.
+
+![](images/90e6d476bbe24227f3b5adc4007f0636a46ea454fc9ede809e5b235b5396cdaa.jpg)
+
+![](images/e696063dae05d81986a48089ef4f43ba116824b44dcb9a050613231a804874a1.jpg)  
+(b) Histogram of $\lVert z ( x , \theta _ { r } ^ { * } ) , z ( x _ { a } , \theta _ { r } ^ { * } ) \rVert _ { 2 }$ for CIFAR100 dataset, given $\theta _ { r } ^ { * }$ for CIFAR-100 dataset. The mean for both training and test examples is $\simeq 5 . 5 7$
+
+(a) Histogram of $\lVert z ( x , \theta _ { r } ^ { * } ) , z ( x _ { a } , \theta _ { r } ^ { * } ) \rVert _ { 2 }$ for CIFAR-10 dataset, given ${ \boldsymbol { \theta } } _ { r } ^ { * }$ for CIFAR-100 dataset. The mean for both training and test examples is $\simeq 5 . 5 3$
+
+Figure 7: Figures $\mathrm { 7 a }$ and $\mathrm { 7 b }$ both show that the values of $\lVert z ( x , \theta _ { r } ^ { * } ) , z ( x _ { a } , \theta _ { r } ^ { * } ) \rVert _ { 2 }$ are high most of the time, consequently, LwF is better done without data augmentation.
+
+![](images/d27b48e4ddfaa40de01d092b3a1ed01194830c72e3afc0578cb181a10c8f0a56.jpg)  
+Figure 8: When the number of training data per-class is very limited (right bars), adversarially robust transfer learning [Transferred] is better overall. However, as the number of training data increases (left bars), fine-tuning with adversarial examples of the target domain [Fine-tuned with AT] results in an overall better performing model. Adversarially robust transfer learning is $3 \times$ faster than finetuning with adversarial examples of the target domain.
+
+# C LOW-DATA REGIME TRANSFER LEARNING FROM IMAGENET TO CIFAR-10
+
+In section 4.2, we illustrated that robust transfer learning is most beneficial where we have limited data (i.e., limited number of training data per class). We used CIFAR-100 as an illustrative target dataset. However, the overall results are not data set dependent. When we have limited number of training data, robust transfer learning results in the highest overall performance (see Fig. 8 for transferring from a robust ImageNet model to smaller instances of CIFAR-10).
+
+# D LWF-BASED ROBUST TRANSFER LEARNING FOR SIMILAR SOURCE AND TARGET DATASETS
+
+In Table 6 we conduct LwF experiments on the split CIFAR-100 task which is more suited for transfer learning due to the similarities between the source and target datasets. In these situations, the LwF regularizer on the feature representations still works and can improve generalization without becoming vulnerable to adversarial examples. If we take the average performance of the robust classifiers on the split tasks (average of robust half CIFAR-100 and the LwF setting model for $\lambda _ { d } = 0 . 0 1$ ) we get $( 6 3 . 3 2 + 6 4 . 9 6 ) / 2 = 6 4 . 1 4 \%$ average validation accuracy and $2 0 . 4 2 \%$ average robustness which is comparable with the case that we had adversarially trained the entire CIFAR-100 dataset (Table 1).
+
+Table 6: Distilling robust features using LwF for the split CIFAR-100 task. For reference, we have included the results from transfer learning by freezing the features at the bottom of the table.   
+
+<table><tr><td rowspan=1 colspan=1>Source -→ Target Dataset</td><td rowspan=1 colspan=1>Source Model</td><td rowspan=1 colspan=1>入d</td><td rowspan=1 colspan=1>val.</td><td rowspan=1 colspan=1>PGD-20</td></tr><tr><td rowspan=1 colspan=1>CIFAR-100+ (1/2) → CIFAR-100 (other 1/2)</td><td rowspan=1 colspan=1>robust</td><td rowspan=1 colspan=1>0.0010.0050.010.1</td><td rowspan=1 colspan=1>73.30%66.96%63.32%55.14%</td><td rowspan=1 colspan=1>1.92%10.52%15.68%17.26%</td></tr><tr><td rowspan=1 colspan=1>CIFAR-100+ (1/2) →&gt; CIFAR-100+ (other 1/2)</td><td rowspan=1 colspan=1>naturalrobust</td><td rowspan=1 colspan=1>NANA</td><td rowspan=1 colspan=1>71.44%58.48%</td><td rowspan=1 colspan=1>0.00%15.86%</td></tr></table>
+
+# E IMPROVING GENERALIZATION OF THE CIFAR-10 ADVERSARIALLY TRAINED MODEL
+
+Similar to the case of improving the generalization for CIFAR-100, we use our LwF-based loss function to transfer from the robust CIFAR-10 domain to the natural CIFAR-10 domain. We summarize the results in Table 7.
+
+Table 7: Decreasing generalization gap by transferring with LwF. For reference, last row shows results from adversarial training CIFAR-10. The $\cdot _ { + } ,$ sign refers to using augmentation. $\epsilon = 8$ )   
+
+<table><tr><td rowspan=1 colspan=1>Source → Target Dataset</td><td rowspan=1 colspan=1>Source Model</td><td rowspan=1 colspan=1>入d</td><td rowspan=1 colspan=1>val.</td><td rowspan=1 colspan=1>PGD-20</td><td rowspan=1 colspan=1>CW-20</td></tr><tr><td rowspan=3 colspan=1>CIFAR-10+ →CIFAR-10</td><td rowspan=3 colspan=1>robust</td><td rowspan=1 colspan=1>1e-5</td><td rowspan=1 colspan=1>88.16%</td><td rowspan=1 colspan=1>45.31%</td><td rowspan=1 colspan=1>46.15%</td></tr><tr><td rowspan=1 colspan=1>5e-5</td><td rowspan=1 colspan=1>88.08%</td><td rowspan=2 colspan=1>46.24%46.54%46.36%46.27%46.09%46.11%</td><td rowspan=2 colspan=1>47.06%47.29%47.16%47.06%46.92%46.84%</td></tr><tr><td rowspan=1 colspan=1>1e-45e-40.0010.010.1</td><td rowspan=1 colspan=1>87.81%87.44%87.31%87.27%87.49%</td></tr><tr><td rowspan=1 colspan=1>CIFAR-10+</td><td rowspan=1 colspan=1>robust</td><td rowspan=1 colspan=1>NA</td><td rowspan=1 colspan=1>87.25%</td><td rowspan=1 colspan=1>45.84%</td><td rowspan=1 colspan=1>46.96%</td></tr></table>

parse/train/ryebG04YvB/ryebG04YvB_content_list.json

@@ -0,0 +1,1476 @@
+[
+    {
+        "type": "text",
+        "text": "ADVERSARIALLY ROBUST TRANSFER LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            101,
+            753,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ali Shafahi∗†, Parsa Saadatpanah∗†, Chen Zhu∗†, Amin Ghiasi†, Cristoph Studer‡,   \nashafahi,parsa,chenzhu,amin @cs.umd.edu ; studer@cornell.edu   \nDavid Jacobs†, Tom Goldstein†   \n{djacobs,tomg}@cs.umd.edu ",
+        "bbox": [
+            184,
+            143,
+            766,
+            205
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            242,
+            544,
+            257
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Transfer learning, in which a network is trained on one task and re-purposed on another, is often used to produce neural network classifiers when data is scarce or full-scale training is too costly. When the goal is to produce a model that is not only accurate but also adversarially robust, data scarcity and computational limitations become even more cumbersome. We consider robust transfer learning, in which we transfer not only performance but also robustness from a source model to a target domain. We start by observing that robust networks contain robust feature extractors. By training classifiers on top of these feature extractors, we produce new models that inherit the robustness of their parent networks. We then consider the case of “fine tuning” a network by re-training end-to-end in the target domain. When using lifelong learning strategies, this process preserves the robustness of the source network while achieving high accuracy. By using such strategies, it is possible to produce accurate and robust models with little data, and without the cost of adversarial training. Additionally, we can improve the generalization of adversarially trained models, while maintaining their robustness. ",
+        "bbox": [
+            233,
+            273,
+            764,
+            481
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            510,
+            336,
+            526
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks achieve human-like accuracy on a range of tasks when sufficient training data and computing power is available. However, when large datasets are unavailable for training, or pracitioners require a low-cost training strategy, transfer learning methods are often used. This process starts with a source network (pre-trained on a task for which large datasets are available), which is then re-purposed to act on the target problem, usually with minimal re-training on a small dataset (Yosinski et al., 2014; Pan & Yang, 2009). ",
+        "bbox": [
+            174,
+            542,
+            825,
+            626
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While transfer learning greatly accelerates the training pipeline and reduces data requirements in the target domain, it does not address the important issue of model robustness. It is well-known that naturally trained models often completely fail under adversarial inputs (Biggio et al., 2013; Szegedy et al., 2013). As a result, researchers and practitioners often resort to adversarial training, in which adversarial examples are crafted on-the-fly during network training and injected into the training set. This process greatly exacerbates the problems that transfer learning seeks to avoid. The high cost of creating adversarial examples increases training time (often by an order of magnitude or more). Furthermore, robustness is known to suffer when training on a small dataset (Schmidt et al., 2018). To make things worse, high-capacity models are often needed to achieve good robustness (Madry et al., 2017; Kurakin et al., 2016; Shafahi et al., 2019b), but these models may over-fit badly on small datasets. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            785
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "CONTRIBUTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            804,
+            294,
+            818
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The purpose of this paper is to study the adversarial robustness of models produced by transfer learning. We begin by observing that robust networks contain robust feature extractors, which are resistant to adversarial perturbations in different domains. Such robust features can be used as a basis for semi-supervised transfer learning, which only requires re-training the last layer of a network. To demonstrate the power of robust transfer learning, we transfer a robust ImageNet source model onto the CIFAR domain, achieving both high accuracy and robustness in the new domain without adversarial training. We use visualization methods to explore properties of robust feature extractors. Then, we consider the case of transfer of learning by “fine-tuning.” In this case, the source network is re-trained end-to-end using a small number of epochs on the target domain. Unfortunately, this end-to-end process does not always retain the robustness of the source domain; the network “forgets” the robust feature representations learned on the source task. To address this problem, we use recently proposed lifelong learning methods that prevent the network from forgetting the robustness it once learned. Using our proposed methods, we construct robust models that generalize well. In particular, we improve the generalization of a robust CIFAR-100 model by roughly $2 \\%$ while preserving its robustness. ",
+        "bbox": [
+            176,
+            830,
+            821,
+            872
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            290,
+            326,
+            306
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial examples fall within the category of evasion attacks—test-time attacks in which a perturbation is added to a natural image before inference. Adversarial attacks are most often crafted using a differentiable loss function that measures the performance of a classifier on a chosen image. In the case of norm-constrained attacks (which form the basis of most standard benchmark problems), the adversary solves ",
+        "bbox": [
+            174,
+            320,
+            823,
+            391
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ab16b69ed680fbc0f1a095035f310f63e4a50da7c87e866dab113e7872249357.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\delta } \\quad l ( x + \\delta , y , \\theta ) \\qquad \\mathrm { s . t . } \\quad \\| \\delta \\| _ { p } \\leq \\epsilon ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            393,
+            632,
+            416
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\theta$ are the (already trained and frozen) parameters of classifier $c ( x , \\theta ) \\to \\hat { y }$ that maps an image to a class, $l$ is the proxy loss used for classification (often cross-entropy), $\\delta$ is the image perturbation, $( x , y )$ is the natural image and its true class, and $| | . | | _ { p }$ is some $\\ell _ { p } { \\ - } \\mathrm { n o r m } ^ { 1 }$ . The optimization problem in Eq. 1 aims to find a bounded perturbation that maximizes the cross-entropy loss given the correct label. There are many variants of this process, including DeepFool (Moosavi-Dezfooli et al., 2016), L-BFGS (Szegedy et al., 2013), and CW (Carlini & Wagner, 2017). ",
+        "bbox": [
+            173,
+            421,
+            825,
+            506
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Many researchers have studied methods for building a robust network which have been later shown to be ineffective when attacked with stronger adversaries (Athalye et al., 2018). Adversarial training (Szegedy et al., 2013) is one of the defenses that was not broken by Athalye et al. (2018). While adversarial training using a weak adversary such as the FGSM attack (Goodfellow et al., 2015) can be broken even by single step attacks which add a simple random step prior to the FGSM step (Tramer\\` et al., 2017), adversarial training using a strong attack has successfully improved robustness. Madry et al. (2017) showed that a PGD attack (which is a BIM attack (Kurakin et al., 2016) with an initial random step and projection) is a strong enough attack to achieve promising adversarial training results. We will refer to this training method as PGD adversarial training. PGD adversarial training achieves good robustness on bounded attacks for MNIST (LeCun et al., 1998) and acceptable robustness on CIFAR-10 (Krizhevsky & Hinton, 2009) classifiers. ",
+        "bbox": [
+            173,
+            511,
+            825,
+            664
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Tsipras et al. (2018) show that adversarial training with strong PGD adversaries has many benefits in addition to robustness. They also state that while adversarial training may improve generalization in regimes where training data is limited (especially on MNIST), it may be at odds with generalization in regimes where data is available. This trade-off was also recently studied by Zhang et al. (2019), Su et al. (2018), and Shafahi et al. (2019a). ",
+        "bbox": [
+            174,
+            671,
+            825,
+            741
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While, to the best of our knowlegde, the transferability of robustness has not been studied in depth, Hendrycks et al. (2019) studied the case of adversarially training models that were pre-trained on different domains. Our work is fundamentally different in that we seek to transfer robustness without resorting to costly and data-hungry adversarial training. We train the target model on natural examples only, which allows us to directly study how well robustness transfers. Additionally, this allows us to have better generalization and achieve higher accuracy on validation examples. While as Hendrycks et al. (2019) state, fine-tuning on adversarial examples built for the target domain can improve robustness of relatively large datasets such as CIFAR-10 and CIFAR-100 compared to adversarial training from scratch on the target domain, we show that in the regimes of limited data (where transfer learning is more common), adversarially robust transfer learning can lead to better results measured in terms of both robustness and clean validation accuracy. ",
+        "bbox": [
+            174,
+            747,
+            825,
+            901
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/9b14ba3d25cecd2037daf163a5d3c965de495c7a733d6064bd2fb2d1f43c6278.jpg",
+        "table_caption": [
+            "Table 1: Accuracy and robustness of natural and adversarially trained models on CIFAR- $^ { 1 0 + }$ and CIFAR- $1 0 0 +$ . The $\" + \"$ sign denotes standard data augmentation $( \\epsilon = 8$ ). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>model</td><td>validation accuracy</td><td>accuracy on PGD-20</td><td> accuracy on CW-20</td></tr><tr><td rowspan=\"2\">CIFAR-10+</td><td rowspan=\"2\">natural robust</td><td>95.01%</td><td>0.00%</td><td>0.00%</td></tr><tr><td>87.25%</td><td>45.84%</td><td>46.96%</td></tr><tr><td rowspan=\"2\">CIFAR-100+</td><td rowspan=\"2\">natural robust</td><td>78.84%</td><td>0.00%</td><td>0.00%</td></tr><tr><td>59.87%</td><td>22.76%</td><td>23.16%</td></tr></table>",
+        "bbox": [
+            184,
+            140,
+            810,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 THE ROBUSTNESS OF DEEP FEATURES ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            241,
+            517,
+            256
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we explore the robustness of different network layers, and demonstrate that robust networks rely on robust deep features. To do so, we start from robust classifiers $( c ( \\theta _ { r } ) )$ for the CIFAR-100 and CIFAR-10 datasets (Krizhevsky & Hinton, 2009), and update $\\theta$ by training on natural examples. In each experiment, we re-initialize the last $k$ layers/blocks of the network, and re-train just those layers. We start by re-initializing just the last layer, then the last two, and so on until we re-initialize all the layers. ",
+        "bbox": [
+            173,
+            273,
+            825,
+            357
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use the adversarially trained Wide-ResNet 32-10 (Zagoruyko & Komodakis, 2016) for CIFAR10 from Madry et al. (2017) as our robust model for CIFAR-10. We also adversarially train our own robust classifier for CIFAR-100 using the code from Madry et al. (2017). To keep things consistent, we use the same hyper-parameters used by Madry et al. (2017) for adversarially training CIFAR-10 to adversarially train the CIFAR-100 model.2 The performance of the CIFAR-10 and CIFAR-100 models on natural and adversarial examples are summarized in Table 1. To measure robustness, we evaluate the models on adversarial examples built using PGD attacks. ",
+        "bbox": [
+            174,
+            363,
+            825,
+            462
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We break the WRN 32-10 model into 17 blocks, which are depicted in Fig. 2. In each experiment, we first re-initialize the $k$ deepest blocks (blocks 1 through $k$ ) and then train the parameters of those blocks on natural images3. We train for 20,000 iterations using Momentum SGD and a learning rate of 0.001. We then incrementally unfreeze and train more blocks. For each experiment, we evaluate the newly trained model’s accuracy on validation adversarial examples built with a 20-step PGD $\\ell _ { \\infty }$ attack with $\\epsilon = 8$ . ",
+        "bbox": [
+            173,
+            468,
+            825,
+            551
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Fig. 1 shows that robustness does not drop if only the final layers of the networks are re-trained on natural examples. In fact, there is a slight increase in robustness compared to the baseline PGD7 adversarially trained models when we just retrain the last batch-normalization block and fully connected block. As we unfreeze and train more blocks, the network’s robustness suddenly drops. This leads us to believe that a hardened network’s robustness is mainly due to robust deep feature representations and robustness is preserved if we re-train on top of deep features. ",
+        "bbox": [
+            173,
+            559,
+            825,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/c33719c1a824606b01236b8b81daf48b068d3513906190353bbe64339d86daf0.jpg",
+        "image_caption": [
+            "Figure 2: Wide Resnet 32-10 and the blocks used for freezing/retraining "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            661,
+            826,
+            789
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Now that we have identified feature extractors as a source of robustness, it is natural to investigate whether robustness is preserved when transfer learning using robust feature extractors. We will study two different approaches for transferring robustness across datasets: one in which only the last layer is re-trained, and one with end-to-end re-training. ",
+        "bbox": [
+            176,
+            840,
+            823,
+            868
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/26389130b72972f6e201592b236dfb033e1ef54168c8a5802e473d5d373c7127.jpg",
+        "image_caption": [
+            "Figure 1: Robustness is preserved when we retrain only the deepest block(s) of robust CIFAR10 and CIFAR-100 models using natural examples. The vertical axis is the accuracy on PGD-20 generated adversarial examples (i.e. robustness) after re-training deep layers. The robustness of the adversarially trained models if all layers are frozen are shown with dashed lines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            102,
+            820,
+            304
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            400,
+            825,
+            428
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 TRANSFER LEARNING: RECYCLING FEATURE EXTRACTORS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            449,
+            699,
+            465
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We study how robustness transfers when the feature extractor layers of the source network are frozen, and we retrain only the last fully connected layer (i.e. the classification layer) for the new task. Formally, the transfer learning objective is: ",
+        "bbox": [
+            174,
+            479,
+            825,
+            522
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1de209be30a02680292f667d82c86ce30985f88656d1ed63370584a64a6a08e4.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { w } \\quad l ( z ( x , \\theta ^ { * } ) , y , w )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            529,
+            575,
+            553
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $z$ is the deep feature extractor function with pre-trained and now “frozen” parameters $\\theta ^ { * }$ , and $w$ represents the trainable parameters of the last fully connected layer. To investigate how well robustness transfers, we use two source models: one that is hardened by adversarial training and another that is naturally trained. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            614
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use models trained on CIFAR-100 as source models and perform transfer learning from CIFAR100 to CIFAR-10. The results are summarized in Table 2. Compared to adversarial/natural training the target model, transferring from a source model seems to result in a drop in natural accuracy (compare first row of Table 1 to the first row of Table 2). This difference is wider when the source and target data distributions are dissimilar (Yosinski et al., 2014). ",
+        "bbox": [
+            174,
+            621,
+            825,
+            691
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To evaluate our method on two datasets with more similar attributes, we randomly partition CIFAR100 into two disjoint subsets where each subset contains images corresponding to 50 classes. Table 2 shows the accuracy of transferring from one of the disjoint sets to the other (second row) and to the same set (third row). We can compare results of transfer learning with adversarial training on CIFAR-100 by averaging the results in the second and third rows of Table 2 to get the accuracy across all 100 classes of CIFAR-100.4 By doing so, we see that the accuracy of the transferred classifier matches that of the adversarially trained one, even though no adversarial training took place in the target domain. For completeness, we have also included experiments where we use CIFAR-10 as the source and CIFAR-100 as the target domain. ",
+        "bbox": [
+            173,
+            698,
+            825,
+            824
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We make the following observations from the transfer-learning results in Table 2. 1) robustness transfers: when the source model used for transfer learning is robust, the target model is also robust (although less so than the source), 2) robustness transfers between models that are more similar: If the source and target models are trained on datasets which have similar distributions (and number of classes), robustness transfers better, and 3) validation accuracy is worst if we use a robust model as the source compared to using a conventionally trained source model: if the source model is naturally trained, the natural validation accuracy is better, although the target model is then vulnerable to adversarial perturbations. ",
+        "bbox": [
+            176,
+            830,
+            821,
+            872
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/7878215c2f4d87b05323b6fecb2183b39c6538b37194fbe34beba5ede3047f86.jpg",
+        "table_caption": [
+            "Table 2: Transfer learning by freezing the feature extractor layers $\\epsilon = 8$ ). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Source Dataset</td><td rowspan=1 colspan=1>Target Dataset</td><td rowspan=1 colspan=1>Source Model</td><td rowspan=1 colspan=1>val.</td><td rowspan=1 colspan=1>PGD-20</td><td rowspan=1 colspan=2>CW-20</td></tr><tr><td rowspan=2 colspan=1>CIFAR-100</td><td rowspan=2 colspan=1>CIFAR-10</td><td rowspan=2 colspan=1>naturalrobust</td><td rowspan=1 colspan=1>83.05%</td><td rowspan=1 colspan=1>0.00%</td><td rowspan=1 colspan=2>0.00%</td></tr><tr><td rowspan=1 colspan=1>72.05%</td><td rowspan=1 colspan=1>17.70%</td><td rowspan=1 colspan=2>17.43%</td></tr><tr><td rowspan=2 colspan=1>CIFAR-100(50% of classes)</td><td rowspan=2 colspan=1>CIFAR-100(other 50% of classes)</td><td rowspan=2 colspan=1>naturalrobust</td><td rowspan=1 colspan=1>71.44%</td><td rowspan=2 colspan=1>0.00%15.86%</td><td rowspan=2 colspan=2>0.00%15.30%</td></tr><tr><td rowspan=1 colspan=1>58.48%</td></tr><tr><td rowspan=2 colspan=1>CIFAR-100(50% of classes)</td><td rowspan=2 colspan=1>CIFAR-100(same 50% of classes)</td><td rowspan=2 colspan=1>naturalrobust</td><td rowspan=1 colspan=1>80.20%</td><td rowspan=1 colspan=1>0.00%</td><td rowspan=2 colspan=2>0.00%25.56%</td></tr><tr><td rowspan=1 colspan=1>64.96%</td><td rowspan=1 colspan=1>25.16%</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=2 colspan=1>CIFAR-10</td><td rowspan=2 colspan=1>CIFAR-100</td><td rowspan=2 colspan=1>naturalrobust</td><td rowspan=2 colspan=1>49.66%41.59%</td><td rowspan=1 colspan=1>0.00%</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>0.00%</td></tr><tr><td rowspan=1 colspan=1>11.63%</td><td rowspan=1 colspan=2>9.68%</td></tr></table>",
+        "bbox": [
+            186,
+            126,
+            807,
+            257
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/81d5e5a0ee4d147986d146270676ef3b9bddf07fbf6c6d574c63f31ac5359726.jpg",
+        "table_caption": [
+            "Table 3: Transfer learning from ImageNet $\\epsilon = 5$ ). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Architecture and Source Dataset</td><td>Target Dataset</td><td>Source Model</td><td>val.</td><td>PGD-20</td><td>CW-20</td></tr><tr><td>ResNet-50 ImageNet</td><td>CIFAR-10+ CIFAR-100+</td><td>natural robust (ε = 5) natural robust (e = 5)</td><td>90.49% 88.33% 72.84% 68.88% 82.00%</td><td>0.01% 22.66% 0.05% 15.21%</td><td>0.00% 26.01% 0.00% 18.34%</td></tr><tr><td colspan=\"4\">Robust u-ResNet-50 (ε = 5) for CIFAR-10+ Robust u-ResNet-50 (ε = 5) for CIFAR-100+</td><td>53.11% 59.90% 29.54%</td><td></td></tr></table>",
+        "bbox": [
+            173,
+            292,
+            846,
+            397
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            422,
+            826,
+            492
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 TRANSFER LEARNING WITH IMAGENET MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            510,
+            555,
+            525
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Transfer learning using models trained on ImageNet (Russakovsky et al., 2015) as the source is a common practice in industry because ImageNet feature extractors are powerful and expressive. In this section we evaluate how well robustness transfers from these models. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            577
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 TRANSFER LEARNING USING IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            593,
+            511,
+            607
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Starting from both a natural and robust ImageNet model, we perform the same set of experiments we did in section 4. Robust ImageNet models do not withstand untargeted $\\ell _ { \\infty }$ attacks using as large an $\\epsilon$ as those that can be used for simpler datasets like CIFAR. Following the method Shafahi et al. (2019b), we “free train” a robust ResNet-50 on ImageNet using replay hyper-parameter $m = 4$ . The hardened ImageNet classifier withstands attacks bounded by $\\epsilon = 5$ . Our robust ImageNet achieves $5 9 . 0 5 \\%$ top-1 accuracy and roughly $27 \\%$ accuracy against $\\mathrm { P G D } { - } 2 0 \\ \\ell _ { \\infty } \\ \\epsilon = 5$ attacks on validation examples. We experiment with using this robust ImageNet model and a conventionally trained ResNet-50 ImageNet model as the source models. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            728
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using the ImageNet source models, we train CIFAR classifiers by retraining the last layer on natural CIFAR examples. We up-sample the $3 2 \\times 3 2$ -dimensional CIFAR images to $2 2 4 \\times 2 2 4$ before feeding them into the ResNet-50 source models that are trained on ImageNet. For evaluation purposes, we also train robust ResNet-50 models from scratch using (Shafahi et al., 2019b) for the CIFAR models. To ensure that the transfer learning models and the end-to-end trained robust models have the same capacity and dimensionality, we first upsample the CIFAR images before feeding them to the ResNet-50 model. To distinguish between the common case of training ResNet models on CIFAR images that are $3 2 \\times 3 2$ -dimensional, we call our models that are trained on the upsampled CIFAR datasets the upsample-first ResNets or “ $_ u$ -ResNets”. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 3 illustrates that using a robust ImageNet model as a source results in high validation accuracy for the transferred CIFAR target models. Also, given that the ImageNet classifier by itself is $27 \\%$ robust, the CIFAR-10 model maintains the majority of that $27 \\%$ robustness. When we compare the end-to-end hardened classifiers (robust u-ResNets) with the transferred classifier, we can see that while the robustness is less for the transferred case, transferred models result in considerably better performance on clean validation examples. ",
+        "bbox": [
+            174,
+            868,
+            823,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/01d1c93d1deb9bf8eb77a92ca8ee8b52dc60c15e403ab86ce0a13a908ea8a7ca.jpg",
+        "image_caption": [
+            "Figure 3: When the number of training data per-class is very limited (right bars), adversarially robust transfer learning [Transferred] is better in all metrics. However, as the number of training data increases (left bars), fine-tuning with adversarial examples of the target domain [Fine-tuned with AT] results in more robustness. Adversarially robust transfer learning always results in models that work better on natural examples and is $3 \\times$ faster than fine-tuning with adversarial examples of the target domain. Using a pre-trained robust ImageNet improves both robustness and generalization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            99,
+            810,
+            243
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            364,
+            823,
+            393
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 LOW-DATA REGIME ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            411,
+            348,
+            425
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As touched on before, transfer learning is more common in situations where the number of training points in the target domain is limited. Up until now, as a proof of concept, we have illustrated the majority of our experiments on the CIFAR target domains where we have many training points perclass. Hendrycks et al. (2019) show that starting from a pre-trained robust ImageNet model and fine-tuning on adversarial examples of the CIFAR domain can improve robustness beyond that of simply adversarial training CIFAR. Here, we illustrate the effect of training data size on robustness and natural performance by running various experiments on subsets of CIFAR-100 where we vary the number of training points per-class $( N )$ . ",
+        "bbox": [
+            174,
+            438,
+            825,
+            549
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare three different hardening methods: (1) Free-training/adversarial training the target domain (Shafahi et al., 2019b); (2) fine-tuning using adversarial examples of the target task starting from the Free-4 robust ImageNet model similar to (Hendrycks et al., 2019); and (3) training a fully connected layer on top of the frozen feature extractors of the Free-4 robust ImageNet model using natural examples from the target task. For comparing the three different approaches, we look at three metrics: (a) clean validation accuracy; (b) robustness against PGD-20 validation adversarial examples; and (c) average of robustness and clean performance $( ( ( { \\mathbf { a } } ) \\substack { + } ( { \\mathbf { b } } ) ) / 2 .$ .) The results are summarized in Fig. 3. In the regimes where transfer learning is more common, adversarially robust transfer learning results in the best overall performance. Adversarially/Free training the target domain results in less robustness and validation accuracy compared to fine-tuning which highlights the importance of pre-training (Hendrycks et al., 2019). Note that in terms of computational resources required, the cost of fine-tuning on adversarial examples of the target domain is about $k \\times$ our method since it requires generation of adversarial examples using $k$ -step PGD attacks (we set $k = 3$ ). ",
+        "bbox": [
+            174,
+            556,
+            825,
+            736
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2.1 TRAINING DEEPER NETWORKS ON TOP OF ROBUST FEATURE EXTRACTORS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            753,
+            740,
+            767
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The basic transfer learning setting of section 4.1.1 only re-trains one layer for the new task. In section 4.1.1, when we transferred from the robust ImageNet to CIFAR-100, the natural training accuracy was $8 8 . 8 4 \\%$ . Given the small number of trainable parameters left for the network $( \\approx 2 0 4 8 \\times 1 0 0 )$ and the fixed feature extractor, the network was not capable of completely fitting the training data. This means that there is potential to improve natural accuracy by learning more complex non-linear features and increasing the number of trainable parameters. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To increase representation capacity and the number of trainable parameters, instead of training a 1- layer network on top of the feature extractor, we train a multi-layer perceptron (MLP) network on top of the robust feature extractor. To keep things simple and prevent bottle-necking, every hidden layer we add has 2048 neurons. We plot the training and validation accuracies on the natural examples and the robustness (i.e. PGD-20 validation accuracy) in Fig. 4 for various numbers of hidden layers. As can be seen, adding one layer is enough to achieve $100 \\%$ training accuracy. However, doing so does not result in an increase in validation accuracy. To the contrary, adding more layers can result in a slight drop in validation accuracy due to overfitting. As illustrated, we can improve generalization using simple but effective methods such as dropout (Srivastava et al., 2014) (with probability 0.25) and batch-normalization (Ioffe & Szegedy, 2015). ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "However, the most interesting behavior we observe in this experiment is that, as we increase the number of hidden layers, the robustness to PGD-20 attacks improves. Note, this seems to happen even when we transfer from a naturally trained ImageNet model. While for the case where we have no hidden layers, robustness is $0 . 0 0 \\%$ on CIFAR100 when we use a naturally trained ImageNet model as source, if our MLP has 1, 2, 3, or 5 hidden layers, our robustness against PGD attacks would be $0 . 0 3 \\%$ , $0 . 0 9 \\%$ , $0 . 3 1 \\%$ and $6 . 6 1 \\%$ , respectively. This leads us to suspect that this behavior may be an artifact of vanishing gradients for adversary as the softmax loss saturates when the data is fit perfectly (Athalye et al., 2018). Therefore, for this case we change our robustness measure and use the CW attack (Carlini & Wagner, 2017) which will encounter fewer numerical issues because its loss function does not have a softmax component and does not saturate. Attacking the model from the natural source with CW-20 completely breaks the model and achieves $0 . 0 0 \\%$ robustness. Most interestingly, attacking the model transferred from a robust source using the CW objective maintains robustness even when the number of hidden layers increases. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            375
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/d7dc13914a53060c4642c873547b936577d5c1b0aac10205445054bce8269453.jpg",
+        "image_caption": [
+            "Figure 4: Training an MLP for CIFAR-100 on top of the robust feature extractors from ImageNet. The xaxis corresponds to the number of hidden layers (0 is a linear classifier and corresponds to experiments in section 4.1.1). Robustness stems from robust feature extractors. Adding more layers on top of this extractor does not hurt robustness. Interestingly, simply adding more layers does not improve the validation accuracy and just results in more overfitting (i.e. training accuracy becomes $100 \\%$ ). We can slightly improve generalization using batch norm (BN) and dropout (DO). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            552,
+            412,
+            818,
+            539
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 ANALYSIS: ROBUST FEATURE EXTRACTORS ARE FILTERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            598,
+            679,
+            613
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our experiments suggest that the robustness of neural networks arises in large part from the presence of robust feature extractors. We have used this observation to transfer both robustness and accuracy between domains using transfer-learning. However, we have not yet fully delved into what it means to have a robust feature extractor. Through visualizations, Tsipras et al. (2018) studied how adversarial training causes the image gradients of neural networks to exhibit meaningful generative behavior. In other words, adversarial perturbations on hardened networks “look like” the class into which the image is perturbed. Given that optimization-based attacks build adversarial examples using the image gradient, we also visualize the image gradients of our transferred models to see if they exhibit the same generative behavior as adversarially trained nets. ",
+        "bbox": [
+            173,
+            631,
+            825,
+            756
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fig. 5 plots the gradient of the loss w.r.t. the input image for models obtained by re-training only the last layer, and also for the case where we train MLPs on top of a robust feature extractor. The gradients for the transfer-learned models with a robust source are interpretable and “look like” the adversarial object class, while the gradients of models transferred from a natural source do not. This interpretatbility comes despite the fact that the source model was hardened against attacks on one dataset, and the transferred model is being tested on object classes from another. Also, we see that adding more layers on top of the feature extractor, which often leads to over-fitting, does not make gradients less interpretable. This latter observation is consistent with our observation that added layers preserve robustness(Fig. 4). ",
+        "bbox": [
+            174,
+            762,
+            825,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "These observations, together with the success of robust transfer learning, leads us to speculate that a robust model’s feature extractors act as a “filter” that ignores irrelevant parts of the image. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/08230f2415fe9b53e0ed050b0381109d2e05361ef7883e2dc1b013007c587098.jpg",
+        "image_caption": [
+            "Figure 5: Gradients of the loss w.r.t to input images for the CIFAR-100 transfer learning experiments of sections $4 . 1 . 1 \\ \\&$ 4.2.1. The top row contains sample CIFAR-100 images. Other rows contain image gradients of the model loss. The second row is for a model transferred from a naturally trained ImageNet source. Rows 3-5 are for models transferred from a robust ImageNet source. These rows correspond to an MLP with 0 (row 3), 1 (row 4), and 2 (row 5) hidden layers on top of the robust feature extractor. The gradients in the last three rows all show interpretable generative behavior. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            109,
+            375,
+            244
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 END-TO-END TRAINING WITHOUT FORGETTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            282,
+            602,
+            297
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As discussed in section 4, transfer learning can preserve robustness of the robust source model. However, it comes at the cost of decreased validation accuracy on natural examples compared to the case where we use a naturally trained source model. Consequently, there seems to be a trade-off between generalization and robustness based on the choice of the source model. For any given classifer, the trade-off between generalization and robustness is the subject of recent research (Tsipras et al., 2018; Zhang et al., 2019; Shafahi et al., 2019a). In this section, we intend to improve the overall performance of classifiers transferred from a robust source model by improving their generalization on natural images. To do so, unlike previous sections where we froze the feature extractor mainly to preserve robustness, we fine tune the feature extractor parameters $\\theta$ . Ideally, we should learn to perform well on the target dataset without catastrophically forgetting the robustness of the source model. To achieve this, we utilize lifelong learning methods. ",
+        "bbox": [
+            173,
+            314,
+            825,
+            468
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Learning without Forgetting (LwF) (Li & Hoiem, 2018) is a method for overcoming catastrophic forgetting. The method is based on distillation. In this framework, we train the target model with a loss that includes a distillation term from the previous model. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            517
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/87a8993cf8f9b192795f6674221af6cf1d8cab5c300802d13cd3dd94472614ef.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { w , \\theta } \\quad l ( z ( x , \\theta ) , y , w ) + \\lambda _ { d } \\cdot d ( z ( x , \\theta ) , z _ { 0 } ( x , \\theta _ { r } ^ { * } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            526,
+            663,
+            551
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/1b65be02dcb26f582c98135d5bcacb719bebefac5da0577079cd0b265af93269.jpg",
+        "image_caption": [
+            "Figure 6: Our LwF loss has a term that enforces the similarity of feature representations (i.e. penultimate layer activations) between the source model and the fine-tuned model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            574,
+            761,
+            811
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where, in our method, $\\lambda _ { d }$ is the feature representation similarity penalty, and $d$ is some distance metric between the robust model’s feature representations $z _ { 0 } ( x , \\theta _ { r } ^ { * } )$ and the current model’s feature representations $z ( x , \\theta )$ . Unlike the original LwF paper that used a distilled loss from Hinton et al. (2015) and applies distillation to the logits, we simply choose $d$ to be the $\\ell _ { 2 }$ -norm and apply distillation to the penultimate layer5. Our loss is designed to make the feature representations of the source and target network similar, thus preserving the robust feature representations (Fig. 6). Ideally, $z ( x , \\theta ) \\approx \\mathbf { \\bar { \\Phi } } { z } ( x , \\theta _ { r } ^ { * } )$ . To speed up training, given robust feature extractor parameters $\\theta _ { r } ^ { * }$ , we store $z _ { 0 } ( x , \\theta _ { r } ^ { * } )$ for the images of the target task and load this from memory (i.e. offline) instead of performing a forward pass through the robust source network online. Therefore, in the experiments related to LwF, we do not train with data augmentation because we have not pre-computed $z ( x _ { a } , \\theta _ { r } ^ { * } )$ , where $x _ { a }$ is the augmented image. Empirically we verified that $d ( z ( x , \\theta _ { r } ^ { * } ) , z ( x _ { a } , \\theta _ { r } ^ { * } ) )$ was not negligible6. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To improve performance, we follow a warm-start scheme and only train the fully connected parameters $w$ early in training. We then cut the learning rate and continue fine tuning both feature extractors $\\mathbf { \\eta } ^ { ( \\theta ) }$ and $w$ . In our experiments, we use a learning rate of 0.001, and the warm-start makes up half of the total training iterations. Starting from the pre-trained source model, we train for a total of 20,000 iterations with batch-size 128. The results with an adversarially trained CIFAR-100 model as source and CIFAR-10 as target are summarized in Table 4.7 ",
+        "bbox": [
+            174,
+            222,
+            825,
+            305
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As can be seen, having a LwF-type regularizer helps in maintaining robustness and also results in a considerable increase in validation accuracy. The trade-off between robustness and generalization can be controlled by the choice of $\\lambda _ { d }$ . It seems that for some choices of $\\lambda _ { d }$ such as 0.1, robustness also increases. However, in hindsight, the increase in accuracy on PGD-20 adversarial examples is not solely due to improvement in robustness. It is due to the fact that the validation accuracy has increased and we have a better classifier overall. For easier comparisons, we have provided the transfer results without LwF at the bottom of Table 4. Note that using LwF, we can keep the robustness of the source model and also achieve clean validation accuracy comparable to a model that uses naturally trained feature extractors. In the supplementary, we show that similar conclusions can be drawn for the split CIFAR-100 task. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            450
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/69645c7f29fcc5815fd8d59332da47ba0fa1d16138763e257cd66e3c90858c27.jpg",
+        "table_caption": [
+            "Table 4: Distilling robust features using learning without forgetting. The bottom rows show results from transfer learning with a frozen feature extractor. The $\\cdot _ { + } ,$ sign refers to using augmentation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Source →Target Dataset</td><td>Source Model</td><td>入d</td><td>val.</td><td>PGD-20 (ε = 8)</td></tr><tr><td rowspan=\"5\">CIFAR-100+→CIFAR-10</td><td rowspan=\"5\">robust</td><td>1e-7</td><td>89.07%</td><td>0.61%</td></tr><tr><td>0.001</td><td>86.15%</td><td>4.70%</td></tr><tr><td>0.0025</td><td>81.90%</td><td>15.42%</td></tr><tr><td>0.005</td><td>79.35%</td><td>17.61%</td></tr><tr><td>0.01</td><td>77.73%</td><td>17.55%</td></tr><tr><td rowspan=\"2\">CIFAR-10O+→CIFAR-10+</td><td rowspan=\"2\">natural robust</td><td>0.1 NA</td><td>73.39% 83.05%</td><td>18.62% 0.00%</td></tr><tr><td>NA</td><td>72.05%</td><td>17.70%</td></tr></table>",
+        "bbox": [
+            202,
+            513,
+            789,
+            645
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ECREASING GENERALIZATION GAP OF ADVERSARIALLY TRAINED NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            186,
+            693,
+            709,
+            705
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We demonstrated in our transfer experiments that using our LwF-type loss, can help decrease the generalization gap while preserving robustness. In this section, we assume that the source domain is the adversarial example domain of a dataset and the target domain is the clean example domain of the same dataset. This experiment can be seen as applying transfer learning from the adversarial example domain to the natural example domain while preventing forgetting the adversarial domain. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            791
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the case where the source and target datasets are the same (Transferring from a robust CIFAR-100 model to CIFAR-100), by applying our LwF-type loss, we can improve the generalization of robust models. Our results are summarized in Table 5. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            840
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/2f76a013db77e5f5c5f1c6718cd5b5602bc82a01a461ffae90fd9daf289cafc5.jpg",
+        "table_caption": [
+            "Table 5: Decreasing generalization gap by transferring with LwF. For reference, last row shows results from adversarial training CIFAR-100. The $\\cdot _ { + } ,$ sign refers to using augmentation. $\\epsilon = 8$ ) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Source→Target Dataset</td><td>Source Model</td><td>入d</td><td>val.</td><td>PGD-20</td><td>CW-20</td></tr><tr><td rowspan=\"3\">CIFAR-10O+→ CIFAR-100</td><td rowspan=\"3\">robust</td><td>1e-5</td><td>61.53% 61.71%</td><td>21.83% 23.44%</td><td>21.97% 22.94%</td></tr><tr><td>5e-5 1e-4</td><td>61.38%</td><td>23.95%</td><td>23.40%</td></tr><tr><td>0.001</td><td>60.17%</td><td>24.31%</td><td>23.17%</td></tr><tr><td>CIFAR-100+</td><td>robust</td><td>0.01 NA</td><td>59.87% 59.87%</td><td>24.10% 22.76%</td><td>22.96% 23.16%</td></tr></table>",
+        "bbox": [
+            197,
+            140,
+            795,
+            242
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            265,
+            320,
+            282
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We identified the feature extractors of adversarially trained models as a source of robustness, and use this observation to transfer robustness to new problems domains without adversarial training. While transferring from a natural model can achieve higher validation accuracy in comparison to transferring from a robust model, we can close the gap and maintain the initial transferred robustness by borrowing ideas from the lifelong learning literature. The success of this methods suggests that a robust feature extractor is effectively a filter that sifts out relevant components of an image that are needed to assign class labels. We hope that the insights from this study enable practitioners to build robust models in situations with limited labeled training data, or when the cost and complexity of adversarial training from scratch is untenable. ",
+        "bbox": [
+            173,
+            297,
+            825,
+            422
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements: Goldstein and his students were supported by the DARPA QED for RML program, the DARPA GARD program, and the National Science Foundation. ",
+        "bbox": [
+            176,
+            438,
+            821,
+            467
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            487,
+            285,
+            502
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. arXiv preprint arXiv:1802.00420, 2018. ",
+        "bbox": [
+            176,
+            511,
+            825,
+            553
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Srndi ˇ c, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Joint European conference on machine learning and knowledge discovery in databases, pp. 387–402. Springer, 2013. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            618
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 IEEE Symposium on Security and Privacy (SP), pp. 39–57. IEEE, 2017. ",
+        "bbox": [
+            169,
+            628,
+            823,
+            657
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. International Conference on Learning Representation, 2015. ",
+        "bbox": [
+            173,
+            666,
+            823,
+            695
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks, Kimin Lee, and Mantas Mazeika. Using pre-training can improve model robustness and uncertainty. arXiv preprint arXiv:1901.09960, 2019. ",
+        "bbox": [
+            171,
+            704,
+            823,
+            733
+        ],
+        "page_idx": 9
+    },
+    {
+        "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,
+            742,
+            823,
+            771
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015. ",
+        "bbox": [
+            173,
+            781,
+            823,
+            810
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009. ",
+        "bbox": [
+            169,
+            819,
+            823,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016. ",
+        "bbox": [
+            174,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, Patrick Haffner, et al. Gradient-based learning applied ´ to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE transactions on pattern analysis and machine intelligence, 40(12):2935–2947, 2018. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017. ",
+        "bbox": [
+            173,
+            146,
+            825,
+            188
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2574–2582, 2016. ",
+        "bbox": [
+            176,
+            203,
+            825,
+            247
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sinno Jialin Pan and Qiang Yang. A survey on transfer learning. IEEE Transactions on knowledge and data engineering, 22(10):1345–1359, 2009. ",
+        "bbox": [
+            173,
+            260,
+            823,
+            289
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International journal of computer vision, 115(3):211–252, 2015. ",
+        "bbox": [
+            176,
+            303,
+            823,
+            347
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ludwig Schmidt, Shibani Santurkar, Dimitris Tsipras, Kunal Talwar, and Aleksander Madry. Adversarially robust generalization requires more data. In Advances in Neural Information Processing Systems, pp. 5014–5026, 2018. ",
+        "bbox": [
+            173,
+            359,
+            825,
+            402
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ali Shafahi, W Ronny Huang, Christoph Studer, Soheil Feizi, and Tom Goldstein. Are adversarial examples inevitable? ICLR, 2019a. ",
+        "bbox": [
+            169,
+            416,
+            823,
+            445
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ali Shafahi, Mahyar Najibi, Amin Ghiasi, Zheng Xu, John Dickerson, Christoph Studer, Larry S Davis, Gavin Taylor, and Tom Goldstein. Adversarial training for free! arXiv preprint arXiv:1904.12843, 2019b. ",
+        "bbox": [
+            173,
+            459,
+            825,
+            502
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014. ",
+        "bbox": [
+            176,
+            516,
+            823,
+            559
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dong Su, Huan Zhang, Hongge Chen, Jinfeng Yi, Pin-Yu Chen, and Yupeng Gao. Is robustness the cost of accuracy?–a comprehensive study on the robustness of 18 deep image classification models. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 631–648, 2018. ",
+        "bbox": [
+            173,
+            573,
+            825,
+            630
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013. ",
+        "bbox": [
+            171,
+            643,
+            825,
+            672
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramer, Alexey Kurakin, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick Mc-\\` Daniel. Ensemble adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017. ",
+        "bbox": [
+            173,
+            686,
+            825,
+            729
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dimitris Tsipras, Shibani Santurkar, Logan Engstrom, Alexander Turner, and Aleksander Madry. Robustness may be at odds with accuracy. stat, 1050:11, 2018. ",
+        "bbox": [
+            173,
+            743,
+            823,
+            773
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Advances in neural information processing systems, pp. 3320–3328, 2014. ",
+        "bbox": [
+            171,
+            786,
+            825,
+            816
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016. ",
+        "bbox": [
+            171,
+            830,
+            823,
+            859
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hongyang Zhang, Yaodong Yu, Jiantao Jiao, Eric P Xing, Laurent El Ghaoui, and Michael I Jordan. Theoretically principled trade-off between robustness and accuracy. arXiv preprint arXiv:1901.08573, 2019. ",
+        "bbox": [
+            173,
+            872,
+            825,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A EXPERIMENT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            397,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 LWF-BASED EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            138,
+            408,
+            154
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In our LWF-based experiments, we use a batch-size of 128, a fixed learning-rate of $1 \\mathrm { e } { - } 2 \\mathrm { m }$ , and fine-tune for an additional 20,000 iterations. The first 10,000 iterations are used for warm-start; during which we only update the final fully connected layer’s weights. During the remaining 10,000 iterations, we update all of the weights but do not update the batch-normalization parameters. ",
+        "bbox": [
+            174,
+            170,
+            825,
+            226
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 IMAGENET TO CIFAR EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            252,
+            475,
+            266
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "When freezing the feature extractor and fine-tuning on adversarial examples, we train the last fully connected layer’s weights for 50 epochs using batch-size ${ \\mathrm { - } } 1 2 8$ . We start with an initial learning rate of 0.01 and drop the learning rate to 0.001 at epoch 30. In the case of fine-tuning on adversarial examples, we generate the adversarial examples using a 3 step PGD attack with step-size 3 and a perturbation bound $\\epsilon = 5$ . ",
+        "bbox": [
+            174,
+            282,
+            825,
+            352
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.3 FREE TRAINING EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            380,
+            431,
+            393
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In all of our free-training experiments where we train the u-ResNet-50, we train for 90 epochs using a batch-size of 128. The initial learning rate used is 0.1 and we drop it by a factor of 10 at epochs 30 and 60. We use a replay parameter $m = 4$ and perturbation bound $\\epsilon = 5$ . ",
+        "bbox": [
+            174,
+            410,
+            825,
+            452
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B THE DISTANCE BETWEEN FEATURE REPRESENTATIONS OF NATURAL IMAGES AND AUGMENTED IMAGES ",
+        "text_level": 1,
+        "bbox": [
+            179,
+            483,
+            769,
+            516
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To speed up the LwF experiments, we did not use data augmentation during training. Instead of computing the robust feature representations on the fly, before starting training on the new target task, we passed the entire training data of the target task through the robust network and stored the feature representation vector. If we were doing data augmentation, we would have to pass the entire augmented training data through the network, which would be slow and memory intensive. Alternatively, we could use the robust feature representation of the non-augmented images instead. The latter would have been feasible if the distance between the robust feature representations of the non-augmented and augmented images were very small. However, as shown in fig 7, this quantity is not often negligible. ",
+        "bbox": [
+            173,
+            537,
+            826,
+            664
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/90e6d476bbe24227f3b5adc4007f0636a46ea454fc9ede809e5b235b5396cdaa.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            693,
+            439,
+            835
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/e696063dae05d81986a48089ef4f43ba116824b44dcb9a050613231a804874a1.jpg",
+        "image_caption": [
+            "(b) Histogram of $\\lVert z ( x , \\theta _ { r } ^ { * } ) , z ( x _ { a } , \\theta _ { r } ^ { * } ) \\rVert _ { 2 }$ for CIFAR100 dataset, given $\\theta _ { r } ^ { * }$ for CIFAR-100 dataset. The mean for both training and test examples is $\\simeq 5 . 5 7$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            534,
+            693,
+            767,
+            835
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Histogram of $\\lVert z ( x , \\theta _ { r } ^ { * } ) , z ( x _ { a } , \\theta _ { r } ^ { * } ) \\rVert _ { 2 }$ for CIFAR-10 dataset, given ${ \\boldsymbol { \\theta } } _ { r } ^ { * }$ for CIFAR-100 dataset. The mean for both training and test examples is $\\simeq 5 . 5 3$ ",
+        "bbox": [
+            173,
+            840,
+            493,
+            880
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Figure 7: Figures $\\mathrm { 7 a }$ and $\\mathrm { 7 b }$ both show that the values of $\\lVert z ( x , \\theta _ { r } ^ { * } ) , z ( x _ { a } , \\theta _ { r } ^ { * } ) \\rVert _ { 2 }$ are high most of the time, consequently, LwF is better done without data augmentation. ",
+        "bbox": [
+            169,
+            891,
+            823,
+            920
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/d27b48e4ddfaa40de01d092b3a1ed01194830c72e3afc0578cb181a10c8f0a56.jpg",
+        "image_caption": [
+            "Figure 8: When the number of training data per-class is very limited (right bars), adversarially robust transfer learning [Transferred] is better overall. However, as the number of training data increases (left bars), fine-tuning with adversarial examples of the target domain [Fine-tuned with AT] results in an overall better performing model. Adversarially robust transfer learning is $3 \\times$ faster than finetuning with adversarial examples of the target domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            99,
+            812,
+            243
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C LOW-DATA REGIME TRANSFER LEARNING FROM IMAGENET TO CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            349,
+            733,
+            381
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In section 4.2, we illustrated that robust transfer learning is most beneficial where we have limited data (i.e., limited number of training data per class). We used CIFAR-100 as an illustrative target dataset. However, the overall results are not data set dependent. When we have limited number of training data, robust transfer learning results in the highest overall performance (see Fig. 8 for transferring from a robust ImageNet model to smaller instances of CIFAR-10). ",
+        "bbox": [
+            173,
+            397,
+            826,
+            468
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D LWF-BASED ROBUST TRANSFER LEARNING FOR SIMILAR SOURCE AND TARGET DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            489,
+            797,
+            521
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Table 6 we conduct LwF experiments on the split CIFAR-100 task which is more suited for transfer learning due to the similarities between the source and target datasets. In these situations, the LwF regularizer on the feature representations still works and can improve generalization without becoming vulnerable to adversarial examples. If we take the average performance of the robust classifiers on the split tasks (average of robust half CIFAR-100 and the LwF setting model for $\\lambda _ { d } = 0 . 0 1$ ) we get $( 6 3 . 3 2 + 6 4 . 9 6 ) / 2 = 6 4 . 1 4 \\%$ average validation accuracy and $2 0 . 4 2 \\%$ average robustness which is comparable with the case that we had adversarially trained the entire CIFAR-100 dataset (Table 1). ",
+        "bbox": [
+            173,
+            536,
+            825,
+            648
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/2449c8fc6d8c7930634974aaa6a04778f067d4d6a60e9b904a3ff6c106b408b5.jpg",
+        "table_caption": [
+            "Table 6: Distilling robust features using LwF for the split CIFAR-100 task. For reference, we have included the results from transfer learning by freezing the features at the bottom of the table. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Source -→ Target Dataset</td><td rowspan=1 colspan=1>Source Model</td><td rowspan=1 colspan=1>入d</td><td rowspan=1 colspan=1>val.</td><td rowspan=1 colspan=1>PGD-20</td></tr><tr><td rowspan=1 colspan=1>CIFAR-100+ (1/2) → CIFAR-100 (other 1/2)</td><td rowspan=1 colspan=1>robust</td><td rowspan=1 colspan=1>0.0010.0050.010.1</td><td rowspan=1 colspan=1>73.30%66.96%63.32%55.14%</td><td rowspan=1 colspan=1>1.92%10.52%15.68%17.26%</td></tr><tr><td rowspan=1 colspan=1>CIFAR-100+ (1/2) →&gt; CIFAR-100+ (other 1/2)</td><td rowspan=1 colspan=1>naturalrobust</td><td rowspan=1 colspan=1>NANA</td><td rowspan=1 colspan=1>71.44%58.48%</td><td rowspan=1 colspan=1>0.00%15.86%</td></tr></table>",
+        "bbox": [
+            174,
+            700,
+            818,
+            804
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "E IMPROVING GENERALIZATION OF THE CIFAR-10 ADVERSARIALLY TRAINED MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            829,
+            763,
+            864
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Similar to the case of improving the generalization for CIFAR-100, we use our LwF-based loss function to transfer from the robust CIFAR-10 domain to the natural CIFAR-10 domain. We summarize the results in Table 7. ",
+        "bbox": [
+            176,
+            878,
+            825,
+            921
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/7e32e0e6b76a94e0454d17e3c9991b2344b0369ef85022f75aaa631739f44393.jpg",
+        "table_caption": [
+            "Table 7: Decreasing generalization gap by transferring with LwF. For reference, last row shows results from adversarial training CIFAR-10. The $\\cdot _ { + } ,$ sign refers to using augmentation. $\\epsilon = 8$ ) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Source → Target Dataset</td><td rowspan=1 colspan=1>Source Model</td><td rowspan=1 colspan=1>入d</td><td rowspan=1 colspan=1>val.</td><td rowspan=1 colspan=1>PGD-20</td><td rowspan=1 colspan=1>CW-20</td></tr><tr><td rowspan=3 colspan=1>CIFAR-10+ →CIFAR-10</td><td rowspan=3 colspan=1>robust</td><td rowspan=1 colspan=1>1e-5</td><td rowspan=1 colspan=1>88.16%</td><td rowspan=1 colspan=1>45.31%</td><td rowspan=1 colspan=1>46.15%</td></tr><tr><td rowspan=1 colspan=1>5e-5</td><td rowspan=1 colspan=1>88.08%</td><td rowspan=2 colspan=1>46.24%46.54%46.36%46.27%46.09%46.11%</td><td rowspan=2 colspan=1>47.06%47.29%47.16%47.06%46.92%46.84%</td></tr><tr><td rowspan=1 colspan=1>1e-45e-40.0010.010.1</td><td rowspan=1 colspan=1>87.81%87.44%87.31%87.27%87.49%</td></tr><tr><td rowspan=1 colspan=1>CIFAR-10+</td><td rowspan=1 colspan=1>robust</td><td rowspan=1 colspan=1>NA</td><td rowspan=1 colspan=1>87.25%</td><td rowspan=1 colspan=1>45.84%</td><td rowspan=1 colspan=1>46.96%</td></tr></table>",
+        "bbox": [
+            205,
+            465,
+            787,
+            595
+        ],
+        "page_idx": 13
+    }
+]

parse/train/ryxf9CEKDr/ryxf9CEKDr.md

@@ -0,0 +1,343 @@
+# EFFICIENT SALIENCY MAPS FOR EXPLAINABLE AI
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We describe an explainable AI saliency map method for use with deep convolutional neural networks (CNN) that is much more efficient than popular gradient methods. It is also quantitatively similar and better in accuracy. Our technique works by measuring information at the end of each network scale which is then combined into a single saliency map. We describe how saliency measures can be made more efficient by exploiting Saliency Map Order Equivalence. Finally, we visualize individual scale/layer contributions by using a Layer Ordered Visualization of Information. This provides an interesting comparison of scale information contributions within the network not provided by other saliency map methods. Since our method only requires a single forward pass through a few of the layers in a network, it is at least $9 7 \mathbf { x }$ faster than Guided Backprop and much more accurate. Using our method instead of Guided Backprop, class activation methods such as Grad-CAM, Grad- $\mathrm { C A M + + }$ and Smooth Grad- $\mathrm { C A M + + }$ will run several orders of magnitude faster, have a significantly smaller memory footprint and be more accurate. This will make such methods feasible on resource limited platforms such as robots, cell phones and low cost industrial devices. This will also significantly help them work in extremely data intensive applications such as satellite image processing. All without sacrificing accuracy. Our method is generally straight forward and should be applicable to the most commonly used CNNs 1.
+
+# 1 INTRODUCTION
+
+Deep neural networks (DNN) have provided a new burst of research in the machine learning community. However, their complexity obfuscates the underlying processes that drive their inferences. This has lead to a new field of explainable AI (XAI). A variety of tools are being developed to enable researchers to peer into the inner workings of DNNs. One such tool is the XAI saliency map. It is generally used with image or video processing applications and is supposed to show what parts of an image or video frame are most important to a network’s decisions. The seemingly most popular methods derive a gradient saliency map by back-propagating a gradient from the end of the network and project it onto an image plane (Simonyan et al., 2014; Zeiler & Fergus, 2014; Springenberg et al., 2015; Sundararajan et al., 2017; Patro et al., 2019). The gradient can typically be from a loss function, layer activation or class activation. Thus, it requires storage of the data necessary to compute a full backward pass on the input image.
+
+Several newer methods attempt to iteratively augment the image or a mask in ways that affect the precision of the results (Fong & Vedaldi, 2017; Chang et al., 2018). Additionally, saliency map encoders can be trained within the network itself (Dabkowski & Gal, 2017). Both of these methods have a distinct advantage of being more self-evidently empirical when compared with gradient techniques. Class Activation Map (CAM) methods (Selvaraju et al., 2017; Chattopadhyay et al., 2018; Omeiza et al., 2019) efficiently map a specified class to a region in an image, but the saliency map is very coarse. They generally use a method like Guided Backprop (Springenberg et al., 2015) to add finer pixel level details. This requires a full backwards pass through the network, and it adds significant memory and computational overhead to CAM solutions relative to just computing the CAM alone. Several of the CAM methods compute gradients aside from the use of Guided Backprop, but we will differentiate them by referring to them as CAM methods.
+
+# 1.1 EFFICIENCY AND WHY IT MATTERS HERE
+
+Most saliency map methods require many passes through the network in order to generate results or train. The gradient methods hypothetically would require just one backwards pass, but often require as many as 15 in order to give an accurate rendering (Hooker et al., 2018). This is not always a problem in the lab when a person has a powerful GPU development box. However, what if one would like to see the workings of the network at training time or even run time? This can be a serious hurdle when running a network on mobile or embedded platforms. It is not uncommon for hardware to be barely fast enough to process each image from a video source. Running a full backward pass can lead to dropped frames. Additionally, viewing or saving the saliency map for each frame is infeasible. Another problem is that some platforms may not have the memory capacity to save all the information required for a backward pass. Gradient based methods cannot work in these instances. Sometimes this can even be the case with powerful hardware. Satellite images can be vary large and potentially exhaust generous resources. An efficient method would enable developers in these areas to get feedback in the field and aid in debugging or understanding the behavior of a network.
+
+Here we show a method of computing an XAI saliency map which is highly efficient. The memory and processing overhead is several orders of magnitude lower than the commonly used gradient methods. This makes it feasible in any resource limited environment. Also, since we demonstrate empirically that our method is either similar or more accurate than the most commonly used gradient methods, it can be used it to speed up run-time in any situation. It is fast enough that we already use it automatically when training networks. We notice very little degradation of training speed.
+
+# 2 METHODS
+
+# 2.1 SALIENCY MAP DERIVATION
+
+We were looking for a method to compute saliency maps based on certain conditions and assumptions.
+
+1. The method used needs to be relatively efficient to support rapid analysis at both test time and during DNN training.   
+2. The method should have a reasonable information representation. As a DNN processes data, the flow of information should become localized to areas which are truly important.   
+3. The method should capture the intuition that the informativeness of a location is proportional to the overall activation level of all the filters as well their variance. That is, informative activations should have a sparse pattern with strong peaks.
+
+Our approach works by creating saliency maps for the output layer of each scale in a neural network and then combines them. We can understand scale by noting that the most commonly used image processing DNNs work on images with filter groups at the same scale which down-sample the image and pass it to the group of filters at the next scale, and so on. Given a network like ResNet-50 (He et al., 2015) with in input image size of $2 2 4 x 2 2 4$ , we would have five scale groups of size $1 1 2 x 1 1 2$ , $5 6 x 5 6$ , $2 8 x 2 8$ , $1 4 x 1 4$ and $7 x 7$ . It is at the end of these scale groups where we are interested in computing saliency. In this way, our approach is efficient and is computed during the standard forward pass through the network. No extra pass is needed.
+
+To achieve localization of information, we measure statistics of activation values arising at different input locations. Given an output activation tensor $\pmb { \mathsf { T } } \in \mathbb { R } ^ { + , p \times q \times r }$ with spatial indices $i , j \in p , q$ and depth index $k \in \textit { r }$ from some layer ${ \boldsymbol { \mathsf { T } } } = l \left( { \boldsymbol { \mathsf { X } } } \right)$ . In our case $l \left( . \right)$ is a $R e L U$ (Nair & Hinton, 2010). We apply a function to each column at $i , j$ over all depths $k$ . This yields a 2D saliency map $\pmb { S } \in \mathbb { R } ^ { + , p \times \hat { q } }$ where $S = \varphi \left( \boldsymbol { \mathsf { T } } \right)$ . We process the tensor after it has been batch-normalized (Ioffe & Szegedy, 2015) and processed by the activation function. When we compute Truncated Normal statistics as an alternative in later section, we take the tensor prior to the activation function.
+
+Finally, to capture our intuition about the informativeness of an output activation tensor, we derived $\varphi \left( . \right)$ by creating a special simplification of the maximum likelihood estimation Gamma Scale parameter (Choi & Wette, 1969). One way we can express it is:
+
+![](images/2286f7ccdeec7b998cb675e9d8ace2b46e53aa64a679d3edf69afdcc72404e03.jpg)  
+Figure 1: The left most image is the input to the network. Five saliency maps are shown for each spatial scale in the network. They are combined per $\operatorname { E q } 3$ . The right most image is the combined saliency map created from these. To aid in visualizing context, it has been alpha blended with a gray scale version of the original image here at $2 5 \%$ . Many more combined saliency map examples can be seen in Appendix Figures 9 and 10
+
+$$
+\varphi \left( . \right) = \frac { 1 } { r } \cdot \sum _ { k = 1 } ^ { r } x _ { k } \cdot \left[ l o g _ { 2 } \left( \frac { 1 } { r } \cdot \sum _ { k = 1 } ^ { r } x _ { k } \right) - \frac { 1 } { r } \cdot \sum _ { k = 1 } ^ { r } l o g _ { 2 } \left( x _ { k } \right) \right]
+$$
+
+To avoid log zero, we add $1 e - 0 6$ to each $x _ { k }$ . How mean and variance relate seems readily apparent with the square bracketed part being the computational formula for the standard deviation with values taken to $l o g _ { 2 } \left( . \right)$ rather than squared. This is preceded by a typical mean estimate. This meets the third requirement we mentioned. This simplification is Saliency Map Order Equivalent (SMOE) to the full iterative (and expensive) scale parameter estimation. We define SMOE as follows. Given saliency map $S _ { a } \in \mathbb { R } ^ { + , p \times q }$ and $S _ { b } \in \mathbb { R } ^ { + , p \times q }$ where we may have $S _ { a } \neq S _ { b }$ , if we sort the pixels by value, then $S _ { a }$ will be sorted in exactly the same order as $S _ { b }$ . That means that the most salient location $i , j$ is exactly the same in both $S _ { a }$ and $S _ { b }$ . This also means that if we create a binary mask of the $n \%$ most salient pixels, the mask for both $S _ { a }$ and $S _ { b }$ will also be exactly the same. SMOE is preserved if for instance, we apply independent monotonic functions to a saliency map. As such, we may as well strip these away to save on computation. Tie values may create an imperfect equivalence, but we assert that these should be very rare and not affect results by a measurable amount.
+
+Using $\mu$ as the mean of each column $r$ in $\boldsymbol { \mathsf { T } }$ , we can see the information relation more clearly if we simplify Eq 1 further which gives us our SMOE Scale method:
+
+$$
+\varphi \left( . \right) = \frac { 1 } { r } \cdot \sum _ { k = 1 } ^ { r } \mu \cdot \log _ { 2 } \left( \frac { \mu } { x _ { k } } \right)
+$$
+
+The resemblance to conditional entropy is apparent. However, since the values in $\operatorname { E q } 2$ are not probabilities, this does not fit the precise definition of it. On the other hand, the interpretation is fairly similar. It is the mean activation multiplied by the information we would gain if we knew the individual values which formed the mean. Put in traditional terms, it is the information in the mean conditioned on the individual values. Numerical examples of this method at work can be seen in Appendix Table 3 along with more information on the derivation. To create a 2D saliency map $\pmb { S } \in \mathbb { R } ^ { + , p \times q }$ , we simply apply Eq 2 at each spatial location $i , j \in p , q$ with column elements $k \in r$ in the 3D activation tensor $\boldsymbol { \mathsf { T } }$ for a given input image.
+
+# 2.2 COMBINED SALIENCY MAP GENERATION
+
+For each input image, we derive five saliency maps. For different networks, this number may vary. Given a network such as a ResNet (He et al., 2015), AlexNet (Krizhevsky et al., 2013), VGG Net (Simonyan & Zisserman, 2015) or DenseNet (Huang et al., 2017) we compute saliency on the final tensor computed at each spatial scale. Recall that most image classification networks process images in a pipeline that processes an image in consecutive groups of convolution layers where each group downsamples the image by $1 / 2 \mathbf { x }$ before passing it onto the next. It is just prior to the downsampling that we compute each saliency map. Computing saliency across image scales is a classical technique (Itti et al., 1998). This is also similar to the method used in the XAI saliency technique described in (Dabkowski & Gal, 2017).
+
+![](images/81b44ec40e147e2162caa9b8c053146acaebf72f2489dae4f356e61e1c164371.jpg)  
+Figure 2: Images are shown with their combined saliency map using our LOVI scheme. The hue in each saliency map corresponds to layer activation. Earlier layers start at violet and trend red in the last layers following the order of the rainbow. Areas which are blue or violet are only activated early in network processing. They tend to activate early filters, but are later disregarded by the network. Yellow and red areas are only activated later in the network. They appear to be places where the objects components are combined together. White areas are activated throughout all network layers. They possibly correspond to the most important features in the image. Many more examples can be seen in Appendix Figures 11 and 12
+
+To make our maps easier to visualize or combine together, we normalize them from 0 to 1 by squashing them with the normal cumulative distribution function $\gamma \left( s ; \mu , \sigma \right)$ . Here mean and standard deviation are computed independently over each saliency map. We then create a combined saliency map by taking the weighted average of the maps. Since they are at different scales, they are upsampled via bilinear interpolation to match the dimensions of the input image. Given $r$ saliency maps that have been bilinear interpolated (upsampled) to the original input image size $p , q$ , they are then combined as:
+
+$$
+c _ { i , j } = \frac { \sum _ { k = 1 } ^ { r } \gamma \left( s _ { i , j , k } ; \mu _ { k } , \sigma _ { k } \right) \cdot w _ { k } } { \sum _ { k = 1 } ^ { r } w _ { k } }
+$$
+
+Note that technically, we compute $\gamma \left( s ; \mu , \sigma \right)$ before we upsample. Weighting is very useful since we expect that saliency maps computed later in the network should be more accurate than saliency maps computed earlier as the network has reduced more irrelevant information in deeper layers, distilling relevant pixels from noise (Tishby et al., 2000). Network activity should be more focused on relevant locations as information becomes more related to the message. We observe this behavior which can be seen later in Figure 4. A saliency map generation example can be seen in Figure 1 with many more examples in Appendix Figures 9 and 10.
+
+The advantages of creating saliency maps this way when compared with most gradient methods are:
+
+• Pro: This is relatively efficient, requiring processing of just five low cost layers during a standard forward pass.   
+• Pro: We can easily visualize the network at different stages (layers).   
+• Con: The current method does not have a class specific activation map (CAM) (Selvaraju et al., 2017; Chattopadhyay et al., 2018; Omeiza et al., 2019), but we discuss how this can be done later.
+
+# 2.3 VISUALIZING MULTIPLE SALIENCY MAPS
+
+One advantage to computing multiple saliency maps at each scale is that we can get an idea of what is happening in the middle of the network. However, with so many saliency maps, we are starting to be overloaded with information. This could get even worse if we decided to insert saliency maps after each layer rather than just at the end of each scale. One way to deal with this is to come up with a method of combining saliency maps into a single image that preserves useful information about each map. Such a composite saliency map should communicate where the network is most active as well as which layers specifically are active. We call our method Layer Ordered Visualization of Information (LOVI). We do this by combining saliency maps using an HSV color scheme (Joblove & Greenberg, 1978) where hue corresponds to which layer is most active at a given location. That is, it shows the mean layer around which a pixels activity is centered. Saturation tells us the uniqueness of the activation. This is the difference between the maximum value at a location and the others. Value (intensity) corresponds to the maximal activation at that location. Basically, this is a pixel’s importance.
+
+If only one layer is active at a location, the color will be very saturated (vivid colors). On the other hand, if all layers are equally active at a given location, the pixel value will be unsaturated (white or gray). If most of the activation is towards the start of a network, a pixel will be violet or blue. If the activation mostly happens at the end, a pixel will be yellow or red. Green indicates a middle layer. Thus, the color ordering by layer follows the standard order of the rainbow. Examples can be seen in Figure 2. Given $k \in r$ saliency maps $\pmb { S }$ (in this instance, we have $r = 5$ maps), we stack them into a tensor $\pmb { \mathsf { S } } \in \mathbb { R } ^ { + , p \times q \times r }$ . Note that all $s \in [ 0 , 1 ]$ because of $\operatorname { E q } 3$ and they have been upsampled via bilinear interpolation to match the original input image size. Given:
+
+$$
+\begin{array} { r } { \phi \left( k \right) = 1 - \frac { k - 1 } { r } \cdot \left( \frac { r - 1 } { r } \right) ^ { - 1 } , \nu = \frac { 1 } { r } } \end{array}
+$$
+
+$\mathbf { H u e } \in [ 0 , 3 6 0 ]$ is basically the center of mass of activation for column vector $\pmb { s }$ at each location $i , j \in p , q$ in S:
+
+$$
+H u e = \frac { \sum _ { k = 1 } ^ { r } s _ { k } \cdot \phi \left( k \right) } { \sum _ { k = 1 } ^ { r } s _ { k } } \cdot 3 0 0 
+$$
+
+Saturation $\in [ 0 , 1 ]$ is the inverse of the ratio of the values in $\pmb { s }$ compared to if they are all equal to the maximum value. So for instance, if one value is large and all the other values are small, saturation is high. On the other hand, if all values are about the same (equal to the maximum value), saturation is very small:
+
+$$
+S a t = 1 - \frac { \sum _ { k = 1 } ^ { r } \left( s _ { k } \right) - \nu } { r \cdot m a x \left( s \right) \cdot \left( 1 - \nu \right) }
+$$
+
+Value $\in [ 0 , 1 ]$ is basically just the maximum value in vector $\pmb { s }$ :
+
+$$
+V a l = m a x \left( s \right)
+$$
+
+Once we have the HSV values for each location, we then convert the image to RGB color space in the usual manner.
+
+# 2.4 QUANTIFICATION VIA ROAR AND KAR
+
+(Hooker et al., 2018) proposed a standardized method for comparing XAI saliency maps. This extends on ideas proposed by (Dabkowski & Gal, 2017; Samek et al., 2017) and in general hearkens back to methods used to compare computational saliency maps to psychophysical observations (Itti & Koch, 2001). The general idea is that if a saliency map is an accurate representation of what is important in an image, then if we block out salient regions, network performance should degrade. Conversely, if we block out non-salient regions, we should see little degradation in performance. The ROAR/KAR metrics measure these degradations explicitly. The KAR metric (Keep And Retrain) works by blanking out the least salient information/pixels in an input image, and the ROAR (Remove And Retrain) metric uses the contrary strategy and removes the most salient pixels. Figure 3 shows an example of ROAR and KAR masked image. A key component to the ROAR/KAR method is that the network needs to be retrained with saliency masking in place. This is because when we mask out regions in an input image, we unavoidably create artifacts. By retraining the network on masked images, the network learns to ignore the new artifacts and focus on image information.
+
+We will give a few examples to show why we need both metrics. If a saliency map is good at deciding which parts of an image are least informative but gets the ranking of the most salient objects wrong, ROAR scores will suggest the method is very good. This is because it masks out the most salient locations in one large grouping. However, ROAR will be unable to diagnose that the saliency map has erroneously ranked the most informative locations until we have removed $50 \%$ or more of the salient pixels. As such, we get no differentiation between the top $1 \%$ and the top $10 \%$ most salient pixels. On the other hand, KAR directly measures how well the saliency map has ranked the most informative locations. By using both metrics, we can quantify the goodness of both the most and least salient locations in a map.
+
+![](images/c2fc969838a856383df2845b4ea618604d90723ced01925b453e6893c80ad514.jpg)  
+Figure 3: These are the KAR (kept) and ROAR (removed) mask images created by masking out the original images with the combined saliency map. The percentage is how much of the image has been kept or removed based on the combined saliency map. Thus, the $10 \%$ kept example shows the top $10 \%$ most salient pixels in the image. It is these example images that are fed into the network when we compute the KAR and ROAR scores. Many more examples can be seen in Appendix Figure 8
+
+# 3 QUANTITATIVE EXPERIMENTS
+
+# 3.1 COMPARING DIFFERENT EFFICIENT STATISTICS
+
+We tested our SMOE Scale saliency map method against several other statistical measures using three different datasets that have fairly different tasks and can be effectively trained from scratch. The sets used are ImageNet (Deng et al., 2009), CSAIL Places (Zhou et al., 2014) and COWC (Mundhenk et al., 2016). ImageNet as a task focuses on foreground identification of objects in standard photographic images. Places has more emphasis on background objects, so we would expect more spatial distribution of useful information. COWC, Cars Overhead With Context is an overhead dataset for counting as many as 64 cars per image. We might expect information to be spatially and discretely localized, but distributed over many locations. In summary, these three datasets are expected to have fairly different distributions of important information within each image. This should give us more insight into performance than if we used several task-similar datasets (e.g. Three photographic foreground object sets such as; ImageNet $^ +$ CUB (birds) (Welinder et al., 2010) $^ +$ CompCars (Yang et al., 2015)).
+
+For compatibility with (Hooker et al., 2018), we used a ResNet-50 network (He et al., 2015). We also show performance on a per layer basis in order to understand the accuracy at different levels of the network. For comparison with our SMOE Scale method, we included any statistical measure which had at least a modicum of justification and was within the realm of the efficiency we were aiming for. These included parameter and entropy estimations from Normal, Truncated-normal, Log-normal and Gamma Distribution models. We also tested Shanon Entropy and Renyi Entropy. To save compute time, we did a preliminary test on each method and did not continue using it if the results qualitatively appeared very poor and highly unlikely to yield good quantitative results. Normal entropy was excluded because it is SMOE with the Normal standard deviation. This left us with nine possible statistical models which we will discuss in further detail.
+
+Saliency maps for each method are computed over each tensor column in the same way as we did with our SMOE Scale metric. The only difference is with the truncated-normal statistic which computes parameters prior to the ReLU layer. We should note that (Jeong & Shin, 2019) uses a truncated normal distribution to measure network information for network design. Recall that we have five saliency map layers. They are at the end of each of the five network spatial scales. We test each one at a time. This is done by setting the network with pre-trained weights for the specific dataset. Then, all weights in the network which come after the saliency mask to be tested are allowed to fine-tune over 25 epochs. Otherwise, we used the same methodology as (He et al., 2015) for data augmentation etc. This is necessary in order to adapt the network to mask related artifacts as specified in the ROAR/KAR protocol. At the level where the saliency map is generated, we mask out pixels in the activation tensor by setting them to zero. For this experiment, we computed the ROAR statistic for the $10 \%$ least salient pixels. For KAR, we computed a map to only let through the top $2 . 5 \%$ most salient pixels. This creates a more similar magnitude between ROAR and KAR measures. Layer scores for the top five methods can be seen in Figure 4. We combine layer scores two different ways since ROAR and KAR scores are not quite proportional. These methods both yield very similar results. The first method takes the improvement difference between
+
+![](images/9ac15155188471db3e61f929f42764903195f545c7e274f14786d4d55f3323c5.jpg)  
+Figure 4: SMOE Scale is compared with several other efficient statistical methods. The Y-axis is the combined score per scale layer over all three image sets. The $\mathbf { X }$ -axis is the network layer with L1 being the earliest layer in the network and L5 near the end. A difference score of zero means the result was about the same as for a randomly generated saliency map. Less than zero means it is worse. SMOE Scale differentiates itself the most early on in the network where most statistical methods score at the level of a random saliency map. About mid way through, the difference between methods becomes relatively small. This may be because information contains more message and less noise by this point in processing. Finer grain details can be seen in Appendix Table 4
+
+Table 1: KAR and ROAR results per dataset. The Difference Score shows the results using Eq 8. The Information Score uses Eq 9. They are sorted by the average difference score (AVG). The SMOE Scale from Eq 2 performs best overall using both scoring methods. The vanilla standard deviation is second best. Recall it is SMOE with normal entropy. Truncated normal entropy is best on the COWC set and ranks third overall. It is interesting to note that the difference in scores over COWC are not as large as the other two datasets. The top four methods all are information related and mean activation style methods are towards the bottom. Finer grain details can be seen in Appendix Table 4
+
+<table><tr><td></td><td colspan="4">Difference Score</td><td colspan="4">Information Score</td></tr><tr><td>Method</td><td>ImNet</td><td>Places</td><td>COWC</td><td>AVG</td><td>ImNet</td><td>Places</td><td>COWC</td><td>AVG</td></tr><tr><td>SMOE Scale</td><td>1.70</td><td>0.90</td><td>1.61</td><td>1.40</td><td>1.13</td><td>0.68</td><td>1.31</td><td>1.04</td></tr><tr><td>Standard Dev</td><td>1.64</td><td>0.83</td><td>1.61</td><td>1.36</td><td>1.07</td><td>0.61</td><td>1.30</td><td>0.99</td></tr><tr><td>Trunc Normal Ent</td><td>1.56</td><td>0.77</td><td>1.64</td><td>1.32</td><td>1.00</td><td>0.56</td><td>1.32</td><td>0.96</td></tr><tr><td>Shanon Ent</td><td>1.61</td><td>0.80</td><td>1.51</td><td>1.31</td><td>0.98</td><td>0.59</td><td>1.23</td><td>0.93</td></tr><tr><td>Trunc Normal Std</td><td>1.51</td><td>0.71</td><td>1.64</td><td>1.28</td><td>1.00</td><td>0.52</td><td>1.32</td><td>0.94</td></tr><tr><td>Trunc Normal Mean</td><td>1.38</td><td>0.67</td><td>1.64</td><td>1.23</td><td>0.96</td><td>0.49</td><td>1.32</td><td>0.92</td></tr><tr><td>Normal Mean</td><td>1.29</td><td>0.63</td><td>1.42</td><td>1.11</td><td>0.75</td><td>0.44</td><td>1.18</td><td>0.79</td></tr><tr><td>Log Normal Ent</td><td>1.16</td><td>0.66</td><td>1.44</td><td>1.09</td><td>0.82</td><td>0.47</td><td>1.20</td><td>0.83</td></tr><tr><td>Log Normal Mean</td><td>1.46</td><td>0.55</td><td>1.09</td><td>1.03</td><td>0.54</td><td>0.35</td><td>0.88</td><td>0.59</td></tr></table>
+
+tested method’s score and a randomized mask score. We have five $\kappa \in [ 0 , 1 ]$ KAR scores for a method. We have five $\rho \in [ 0 , 1 ]$ ROAR scores for a method and five $z \in \ [ 0 , 1 ]$ scores from a random mask condition. This corresponds to each saliency map spatial scale which we tested. We compute a simple difference score as:
+
+$$
+D \left( \rho , \kappa \right) = \sum _ { p = 1 } ^ { 5 } { \left( z _ { p } - \rho _ { p } \right) } + \sum _ { q = 1 } ^ { 5 } { \left( \kappa _ { q } - z _ { q } \right) }
+$$
+
+The second method is an information gain score given by:
+
+$$
+I \left( \rho , \kappa \right) = - \sum _ { p = 1 } ^ { 5 } { { { \rho } _ { p } } \cdot l o { { g } _ { 2 } } \left( \frac { { { \rho } _ { p } } } { { { z } _ { p } } } \right) } - \sum _ { q = 1 } ^ { 5 } { { { z } _ { q } } \cdot l o { { g } _ { 2 } } \left( \frac { { { z } _ { q } } } { { { \kappa } _ { q } } } \right) }
+$$
+
+Table 1 shows the results.
+
+![](images/a3dbc6264ebf770673200175de8e3c00a557c5a9ba66b15780fbc10ec00f51ee.jpg)  
+Figure 5: SMOE Scale with prior layer weights is compared with three popular baseline methods that all use Squared SmoothGrad. Scores for these three are taken from (Hooker et al., 2018). The Yaxis is the model accuracy on ImageNet only. The $\mathbf { X }$ -axis is how much of the input image salient pixels are kept or removed. KAR keeps the most salient locations. Higher accuracy values are better. ROAR removes the most salient regions. Lower values are better. Our method does not seem to suffer as much when the $10 \%$ least salient parts are removed in KAR and in general maintains a better score. Our ROAR scores are very similar to Guided Backprop. Finer grain details can be seen in Appendix Table 5. Note that these results are not per layer. For a closer numerical comparison with the mask layer method, see Appendix Table 4.
+
+# 3.2 COMPARISON WITH POPULAR METHODS
+
+We compare our method with three popular saliency map methods using the standard ROAR/KAR methodology. These are Gradient Heatmaps (Simonyan et al., 2014), Guided Backprop (Springenberg et al., 2015) and Integrated Gradients (Sundararajan et al., 2017). All methods use SmoothGrad-Squared (Smilkov et al., 2017) which gives generally the best results. We should note that without SmoothGrad or another augmentation, all three do not yield very good ROAR/KAR scores.
+
+We compare three different weighting strategies when combining the saliency maps from all five scales. In the first strategy, we weight all five maps equal [1,1,1,1,1]. In the second, we use a ruleof-thumb like approach where we weight the first layer the least since it should be less accurate. Then each successive layer is weighted more. For this we choose the weights to be [1,2,3,4,5]. The third method weights the maps based on the expected accuracy given our results when we computed Table 1. These prior weights are [0.18, 0.15, 0.37, 0.4, 0.72]. The reason for showing the rule-ofthumb results is to give an idea of performance given imperfect weights since one may not want to spend time computing optimal prior weights.
+
+To fairly compare the three popular saliency map methods with our own, we adopt a methodology as close as possible to (Hooker et al., 2018). We train a ResNet-50 from scratch on ImageNet with either ROAR or KAR masking (computed by each of the different saliency mapping approaches in turn) at the start of the network. Otherwise, our training method is the same as (He et al., 2015). The comparison results are shown in Figure 5. We can try and refine these results into fewer scores by subtracting the sum of the ROAR scores from the sum of the KAR scores. The results can be seen in Table 2. The KAR score for our method is superior to all three comparison methods. The ROAR score is better than Guided Backpropagation and Integrated Gradients. This suggests our method is superior at correctly determining which locations are most salient, but is not as good as Gradient Heatmaps for determining which parts of the image are least informative.
+
+# 4 DISCUSSION
+
+# 4.1 METHOD EFFICIENCY
+
+The method as proposed is much faster than the three baseline comparison methods. Given a ResNet-50 network, we only process five layers. The other methods require a special back propagation step over all layers. We can compute the cost in time by looking at operations that come from three sources. The first is the computation of statistics on tensors in five layers. The second is
+
+Table 2: Combined KAR and ROAR scores for several methods on ImageNet Only. The top three rows show several popular methods with Squared SmoothGrad (Smilkov et al., 2017). These scores are created by simply summing the individual scores together. ROAR is negative since we want it to be as small as possible. Prior Layer Weights means we applied layer weights based on the prior determined accuracy of the layer saliency map. We include our top three scoring methods. The SMOE Scale method outperforms the three baseline methods on KAR. It outperforms Guided Backprop and Integrated Gradients on ROAR as well as overall. The Gradient method is best overall, but as we discuss later, it is at least 1456 times more computationally expensive to compute. Truncated normal entropy scores about the same as SMOE Scale. Since SMOE Scale gains its largest performance boost in the earlier layers, when we apply prior weighting, we reduce that advantage. Finer grain details can be seen in Appendix Table 5.
+
+<table><tr><td>Method</td><td>KAR</td><td>ROAR</td><td>SUM</td></tr><tr><td>Gradient (Simonyan et al., 2014) Guided Backprop (Springenberg et al., 2015)</td><td>3.57 3.60</td><td>-3.54 -3.57</td><td>0.04 0.04</td></tr><tr><td>Integrated Grad (Sundararajan et al., 2017) Gradient -w- SmoothGrad Sq.</td><td>3.62</td><td>-3.58</td><td>0.03</td></tr><tr><td>Guided Backprop -w- SmoothGrad Sq.</td><td>3.52 3.49</td><td>-2.12</td><td>1.41</td></tr><tr><td></td><td></td><td>-2.33</td><td>1.16</td></tr><tr><td>Integrated Grad -w- SmoothGrad Sq.</td><td>3.56</td><td>-2.68</td><td>0.88</td></tr><tr><td>SMOE Scale + Prior Layer Weights</td><td>3.61</td><td>-2.31</td><td>1.30</td></tr><tr><td>SMOE Scale + Layer Weights [1,2,3,4,5]</td><td>3.62</td><td>-2.34</td><td></td></tr><tr><td>SMOE Scale + Layer Weights [1,1,1,1,1]</td><td>3.62</td><td></td><td>1.28</td></tr><tr><td></td><td>3.61</td><td>-2.46</td><td>1.15</td></tr><tr><td>Normal Std + Prior Layer Weights</td><td></td><td>-2.32</td><td>1.29</td></tr><tr><td>Trunc Normal Ent + Prior Layer Weights</td><td>3.61</td><td>-2.31</td><td> 1.30</td></tr></table>
+
+the normalization of each 2D saliency map. Third we account for the cost of combing the saliency maps.
+
+Ops for our solution ranges from $1 . 1 x 1 0 ^ { 7 }$ to $3 . 9 x 1 0 ^ { 7 }$ FLOPs (using terminology from (He et al., 2015)) for a ResNet-50. The network itself has $3 . 8 x 1 0 ^ { 9 }$ FLOPs in total. The range in our count comes from how we measure Log and Error Function operations that are computationally expensive compared to more standard ops and whose implementations vary. We estimate the worst case from available software instantiations. Most of the work comes from the initial computation of statistics over activation tensors. This ranges from $9 . 2 x 1 0 ^ { 6 }$ to $3 . 7 \mathrm { ~ x ~ } 1 0 ^ { 7 }$ FLOPs. In total, this gives us an overhead of $0 . 3 \%$ to $1 . 0 \%$ relative to a ResNet-50 forward pass. All gradient methods have a nominal overhead of at least $100 \%$ . A breakdown of the FLOPs per layer and component can be seen in Table 6 in the appendix.
+
+Compared to any method which requires a full backward pass, such as gradient methods, our solution is nominally between $9 7 x$ and $3 4 4 x$ faster for non-SmoothGrad techniques, which according to (Hooker et al., 2018) performs poorly on ROAR/KAR scores. We are between $1 4 5 6 x$ and $5 1 8 1 x$ faster than a 15-iteration SmoothGrad implementation that yields the competitive results in Table 2. 15 iterations as well as other parameters was chosen by (Hooker et al., 2018) who describe this selection in more detail.
+
+The memory footprint of our method is minuscule. Computation over tensors can be done inline which leaves the largest storage demand being the retention of 2D saliency maps. This is increased slightly by needing to store one extra $1 1 2 x 1 \bar { 1 } 2$ image during bilinear up-sampling. Peak memory overhead related to data is about 117 kilobytes per $2 2 4 x 2 2 4$ input image.
+
+# 4.2 USAGE WITH A CLASS ACTIVATION MAP
+
+Our method does not have a class activation map (Selvaraju et al., 2017; Chattopadhyay et al., 2018; Omeiza et al., 2019) in the current implementation. This is because what we have is more akin to Guided Backprop which Grad-CAM etc. combine with their class activation map to improve their pixel level accuracy. The overhead for the class activation map itself is not large since in practice, it involves computing gradients over the last few network layers only. This makes Guided Backprop the most expensive computational part. By replacing it with our method, accuracy should increase as per Table 2 while dramatically reducing both computational and memory overhead.
+
+![](images/7062e83599c46341a621b7cafdec1fb537ed354e7961d57954b254fa2fa716cc.jpg)  
+Figure 6: These are examples of the first level saliency maps from SMOE Scale and Standard Deviation. It is common for both std and truncated normal entropy to flood in areas with modest texture. This may explain why difference scores for these two methods are at or below the performance of a random saliency map.
+
+# 4.3 SMOE SCALE IS THE MOST ROBUST MEASURE
+
+SMOE Scale is the only metric without a failure case among all the statistics we tested. It is the only static that reliably scores in the top half of all the ones we tested. For Image Net and Places, it is the only one always in the top three. All statistics except for SMOE Scale and Shannon Entropy have at least one layer where they have a difference score at or below zero. This means they are as accurate as a random saliency map for at least one condition. SMOE Scale is the most robust statistic to use in terms of expected accuracy. The next highest scoring statistics, standard deviation and truncated normal entropy, are no better than a random on layer 1. Figure 6 shows why this may be. It is important to note that layer 1 contains the finest pixel details and should be expected to be important in rendering visual detail in the final combined saliency map.
+
+# 5 CONCLUSION
+
+We have created a method of XAI saliency which is extremely efficent and is quantitatively comparable or better than several popular methods. It can also be used to create a saliency map with interpretability of individual scale layers. Future work includes creating a class specific activation map and expanding it to non-DNN architectures. We are currently testing our class activation map integration Fast-CAM and will introduce it in a future work.
+
+# REFERENCES
+
+Chun-Hao Chang, Elliot Creager, Anna Goldenberg, and David Duvenaud. Explaining image classifiers by adaptive dropout and generative in-filling. In ICLR, 2018.
+
+Aditya Chattopadhyay, Anirban Sarkar, Prantik Howlader, and Vineeth N Balasubramanian. Grad$\mathrm { c a m + + }$ : Improved visual explanations for deep convolutional networks. In WACV, 2018.
+
+S. C. Choi and R. Wette. Maximum likelihood estimation of the parameters of the gamma distribution and their bias. Technometrics, 11:683690, 1969.
+
+Piotr Dabkowski and Yarin Gal. Real time image saliency for black box classifiers. In NIPS, 2017.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, 2009.
+
+Ruth Fong and Andrea Vedaldi. Interpretable explanation of black boxes by meaningful perturbation. In ICCV, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In arXiv:1512.03385, 2015.
+
+Sara Hooker, Dumitru Erhan, Pieter-Jan Kindermans, and Been Kim. Evaluating feature importance estimates. In ICML workshop on Human Interpretability in Machine Learning, 2018.
+
+Gao Huang, Zhuang Liu, Kilian Q. Weinberger, and Laurens van der Maaten. Densely connected convolutional networks. In CVPR, 2017.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.
+
+Laurent Itti and Christof Koch. Computational modelling of visual attention. Nature Neuroscience, 2:194203, 2001.
+
+Laurent Itti, Ernst Niebur, and Christof Koch. A model of saliency-based visual attention for rapid scene analysis. IEEE Transactions on Pattern Analysis & Machine Intelligence, 20:1254–1259, 1998.
+
+Jongheon Jeong and Jinwoo Shin. Training cnns with selective allocation of channels. In ICML, 2019.
+
+George H. Joblove and Donald Greenberg. Color spaces for computer graphics. Computer Graphics, 12:20–25, 1978.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. ImageNet classification with deep convolutional neural networks. In NIPS, 2013.
+
+T Nathan Mundhenk, Goran Konjevod, Wesam A Sakla, and Kofi Boakye. A large contextual dataset for classification, detection and counting of cars with deep learning. In ECCV, 2016.
+
+Vinod Nair and Geoffrey E. Hinton. Rectified linear units improve restricted boltzmann machines. In ICML, 2010.
+
+Daniel Omeiza, Skyler Speakman, Celia Cintas, and Komminist Weldemariam. Smooth gradcam++: An enhanced inference level visualization technique for deep convolutional neural network models. In arXiv:1908.01224, 2019.
+
+Badri N Patro, Mayank Lunayach, Shivansh Patel, and Vinay P. Namboodiri. U-cam: Visual explanation using uncertanty based class activation maps. In ICCV, 2019.
+
+Wojciech Samek, Alexander Binder, Gregoire Montavon, Sebastian Lapuschkin, and Klaus-Robert ´ Muller. Evaluating the visualization of what a deep neural network has learned. ¨ IEEE Transactions on Neural Networks and Learning Systems, 28:2660–2673, 2017.
+
+Ramprasaath R. Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruv Batra. Grad-cam: Visual explanations from deep networks via gradient-based localization. In ICCV, 2017.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.
+
+Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. In arXiv:1312.6034, 2014.
+
+Daniel Smilkov, Nikhil Thorat, Been Kim, Fernanda Vigas, and Martin Wattenberg. Smoothgrad: removing noise by adding noise. In arXiv:1706.03825, 2017.
+
+Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmille. Striving for simplicity: The all convolutional net. In ICLR Workshop, 2015.
+
+Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. In ICML, 2017.
+
+Naftali Tishby, Fernando C. Pereira, and William Bialek. The information bottleneck method, 2000.
+
+Peter Welinder, Steve Branson, Takeshi Mita, Catherine Wah, Florian Schroff, Serge Belongie, and Pietro Perona. Caltech-UCSD Birds 200. Technical Report CNS-TR-2010-001, California Institute of Technology, 2010.
+
+Linjie Yang, Ping Luo, Chen Change Loy, and Xiaoou Tang. A large-scale car dataset for finegrained categorization and verification. In CVPR, 2015.
+
+Matthew D. Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In ECCV, 2014.
+
+Bolei Zhou, Agata Lapedriza Garcia, Jianxiong Xiao, Antonio Torralba, and Aude Oliva. Learning deep features for scene recognition using places database. In NIPS, 2014.
+
+# A APPENDIX
+
+# A.1 DERIVATION OF SMOE SCALE
+
+The maximum likelihood estimator of scale in the Gamma probability distribution is given as:
+
+$$
+{ \hat { \theta } } = { \frac { 1 } { k n } } \sum _ { i = 1 } ^ { n } x _ { i }
+$$
+
+This requires the additional iterative estimation of the shape parameter $k$ starting with an estimate $s$
+
+$$
+s = \ln \left( { \frac { 1 } { n } } \sum _ { i = 1 } ^ { n } x _ { i } \right) - { \frac { 1 } { n } } \sum _ { i = 1 } ^ { n } \ln ( x _ { i } )
+$$
+
+Then we get to within $1 . 5 \%$ of the correct answer via:
+
+$$
+k \approx \frac { 3 - s + \sqrt { ( s - 3 ) ^ { 2 } + 2 4 s } } { 1 2 s }
+$$
+
+Then we use the Newton-Ralphson update to finish:
+
+$$
+k  k - \frac { \ln ( k ) - \psi ( k ) - s } { \frac { 1 } { k } - \psi ^ { \prime } ( k ) }
+$$
+
+But we can see application of Eqs 12 and 13 is monotonic. This is also apparent from the example which we can see in Figure 7.
+
+![](images/20a109aa6c4b2c46a71c8484b1cd42dc4b33941c173d40a41105519f9b24960e.jpg)  
+Figure 7: A plot of the resulting $k$ values from input $s$ values in the gamma probability distribution maximum likelihood estimation. It is monotonic and reciprocal.
+
+$k$ is SMOE to $\frac { 1 } { s }$ , so we rewrite Eq 10 with the reciprocal of $k$ and optionally use the more efficient $l o g _ { 2 }$ as:
+
+$$
+{ \hat { \theta } } _ { S M O E } = { \frac { 1 } { n } } \cdot \sum _ { i = 1 } ^ { n } x _ { i } \cdot \left[ l o g _ { 2 } \left( { \frac { 1 } { n } } \cdot \sum _ { i = 1 } ^ { n } x _ { i } \right) - { \frac { 1 } { n } } \cdot \sum _ { i = 1 } ^ { n } l o g _ { 2 } \left( x _ { i } \right) \right]
+$$
+
+This then simplifies to:
+
+$$
+{ \hat { \theta } } _ { S M O E } = { \frac { 1 } { n } } \cdot \sum _ { i = 1 } ^ { n } \mu \cdot \log _ { 2 } \left( { \frac { \mu } { x _ { n } } } \right)
+$$
+
+We can see the results this gives with different kinds of data in Table 3
+
+Table 3: Examples of SMOE Scale results given different data. This shows in particular when log variance and standard deviation give similar or diverging results. It is easier to see how SMOE Scale as a measure or variance is proportional to the mean. So, if we have lots of large values in an output, we also need them to exhibit more variance relative to the mean activation.   
+
+<table><tr><td></td><td colspan="7">Input Values</td><td></td><td>Mean</td><td>STD</td><td>SMOE Scale</td></tr><tr><td>0.5</td><td>1</td><td></td><td>0.5</td><td>1</td><td>0.5</td><td>1</td><td>0.5</td><td>1</td><td>0.75</td><td>0.25</td><td>0.064</td></tr><tr><td>1</td><td>2</td><td></td><td>1</td><td>2</td><td>1</td><td>2</td><td>1</td><td>2</td><td>1.5</td><td>0.5</td><td>0.127</td></tr><tr><td>2</td><td>4</td><td>.</td><td>2</td><td>4</td><td>2</td><td>4</td><td>2</td><td>4</td><td>3</td><td>1</td><td>0.255</td></tr><tr><td>1</td><td>2</td><td>…</td><td>1</td><td>2</td><td>1</td><td>2</td><td>1</td><td>2</td><td>1.5</td><td>0.5</td><td>0.127</td></tr><tr><td>2</td><td>3</td><td>.</td><td>2</td><td>3</td><td>2</td><td>3</td><td>2</td><td>3</td><td>2.5</td><td>0.5</td><td>0.074</td></tr><tr><td>2</td><td>4</td><td>.</td><td>2</td><td>4</td><td>2</td><td>4</td><td>2</td><td>4</td><td>3</td><td>1</td><td>0.255</td></tr><tr><td>0.6125</td><td>1.8375</td><td>…</td><td>0.6125</td><td>1.8375</td><td>0.6125</td><td>1.8375</td><td>0.6125</td><td>1.8375</td><td>1.225</td><td>0.6125</td><td>0.254</td></tr></table>
+
+# A.2 MORE EXAMPLES OF KAR SALIENCY MASKS
+
+![](images/689b48f8ed5920e3d7b883963071abe025d9036d6200602046170013b35a1d58.jpg)  
+Figure 8: These are the last mini-batch images in our GPU:0 buffer when running the ImageNet validation set. The top images are the original input images and the ones on the bottom are $10 \%$ KAR images of the most salient pixels. These are images used when computing KAR scores.
+
+![](images/4fb6f38a1d785a042afaa1ae11357e80d8c1eaf69c8648d5051ec9340b417156.jpg)  
+Figure 9: These are more examples of combined saliency maps using the same images that appear in Figure 8. These images are not alpha blending with the original. Above each image is the ground truth label, while the label the network gave it is below. This was auto-generated by our training scripts.
+
+![](images/e20d8b495f81143fecc49a5a79078af88846ae7447d0026a048a2a2dc5927b87.jpg)  
+Figure 10: These are the same as Figure 9 except with the original image gray scaled and alpha blended at $2 5 \%$ .
+
+# A.4 MORE EXAMPLES OF LOVI SALIENCY MAPS
+
+![](images/35239414fc28cea60719589da148b885a04daf51f64c15cfec181f4651c6e9df.jpg)  
+Figure 11: These are more examples of visualizing multiple saliency maps using the same images that are in Figure 8. These images are not alpha blending with the original.
+
+![](images/b379c8b0f3b814b5e14edf9d54cef0694aab2d470c9744e98aa1d13a326928a3.jpg)  
+Figure 12: These are the same as Figure 11 with the original image gray scaled and alpha blended at $2 5 \%$ .
+
+A.5 COMPARING DIFFERENT EFFICIENT STATISTICS IN MORE DETAIL
+
+This subsection shows the raw scores for each statistic over each dataset.
+
+Table 4: KAR and ROAR results per dataset. This is a more detailed version of Table 1 and Figure 4. The differing effects of the distribution of data in the three sets seems to manifest itself in the L5 scores whereby the more concentrated the information is spatially, the better the ROAR/L5 score seems to be.   
+
+<table><tr><td></td><td colspan="5">KAR Kept Percent</td><td colspan="5">ROAR Removed Percent</td></tr><tr><td>Method</td><td>L1</td><td>L2</td><td>L3</td><td>L4</td><td>L5</td><td>L1</td><td>L2</td><td>L3</td><td>L4</td><td>L5</td></tr><tr><td colspan="9">ImageNet</td><td></td></tr><tr><td>Random</td><td>66.42</td><td>61.28</td><td>50.67</td><td>40.81</td><td>42.98</td><td>73.48</td><td>72.41</td><td>68.90</td><td>64.63</td><td>66.04</td></tr><tr><td>SMOE Scale</td><td>56.61</td><td>50.69</td><td>51.25</td><td>46.40</td><td>63.00</td><td>44.48</td><td>44.81</td><td>36.35</td><td>33.88</td><td>21.15</td></tr><tr><td>STD</td><td>51.84</td><td>50.73</td><td>50.72</td><td>46.16</td><td>62.82</td><td>45.78</td><td>42.74</td><td>36.17</td><td>34.41</td><td>22.88</td></tr><tr><td>Mean</td><td>53.21</td><td>40.34</td><td>50.88</td><td>46.85</td><td>62.56</td><td>52.66</td><td>64.10</td><td>37.85</td><td>34.15</td><td>19.19</td></tr><tr><td>Shannon Ent</td><td>55.43</td><td>45.69</td><td>50.89</td><td>47.17</td><td>61.18</td><td>44.74</td><td>51.38</td><td>38.73</td><td>35.78</td><td>18.07</td></tr><tr><td>Log Normal Mean</td><td>55.98</td><td>32.28</td><td>51.08</td><td>47.21</td><td>62.02</td><td>57.20</td><td>68.22</td><td>44.42</td><td>34.98</td><td>18.50</td></tr><tr><td>Log Normal ENT</td><td>53.01</td><td>42.52</td><td>51.13</td><td>46.85</td><td>62.26</td><td>47.92</td><td>62.64</td><td>38.73</td><td>34.50</td><td>18.91</td></tr><tr><td>Trunc Normal Mean</td><td>50.67</td><td>49.69</td><td>50.69</td><td>43.52</td><td>62.87</td><td>46.88</td><td>49.76</td><td>35.44</td><td>37.58</td><td>20.92</td></tr><tr><td>Trunc Normal Std</td><td>50.66</td><td>51.02</td><td>50.60</td><td>42.54</td><td>62.97</td><td>46.78</td><td>43.70</td><td>35.68</td><td>38.18</td><td>21.57</td></tr><tr><td>Trunc Normal Ent</td><td>50.84</td><td>50.62</td><td>50.57</td><td>43.63</td><td>62.97</td><td>46.92</td><td>45.48</td><td>35.56</td><td>37.64</td><td>21.25</td></tr><tr><td>Best</td><td>56.61</td><td>51.02</td><td>51.25</td><td>47.21</td><td>63.00</td><td>44.48</td><td>42.74</td><td>35.44</td><td>33.88</td><td>18.07</td></tr><tr><td>Worst</td><td>50.66</td><td>32.28</td><td>50.57</td><td>42.54</td><td>61.18</td><td>57.20</td><td>68.22</td><td>44.42</td><td>38.18</td><td>22.88</td></tr><tr><td colspan="9">Places</td><td></td></tr><tr><td>Random</td><td>57.20</td><td>53.59</td><td>47.83</td><td>41.26</td><td>39.45</td><td>60.77</td><td>60.25</td><td>58.14</td><td>56.41</td><td>55.26</td></tr><tr><td>SMOE Scale</td><td>49.76</td><td>45.67</td><td>46.39</td><td>40.57</td><td>53.50</td><td>44.35</td><td>44.61</td><td>39.80</td><td>40.26</td><td>27.94</td></tr><tr><td>STD</td><td>47.15</td><td>44.75</td><td>46.28</td><td>39.41</td><td>53.53</td><td>46.41</td><td>43.69</td><td>39.28</td><td>41.38</td><td>29.12</td></tr><tr><td>Mean</td><td>47.93</td><td>40.38</td><td>45.94</td><td>41.10</td><td>52.33</td><td>50.66</td><td>56.58</td><td>41.26</td><td>39.90</td><td>27.38</td></tr><tr><td>Shannon Ent</td><td>48.80</td><td>43.20</td><td>45.92</td><td>41.31</td><td>50.62</td><td>41.97</td><td>49.28</td><td>42.93</td><td>39.98</td><td>27.06</td></tr><tr><td>Log Normal Mean</td><td>50.05</td><td>35.87</td><td>46.23</td><td>41.45</td><td>51.67</td><td>52.21</td><td>57.91</td><td>45.17</td><td>39.73</td><td>26.88</td></tr><tr><td>Log Normal ENT</td><td>47.77</td><td>41.41</td><td>46.02</td><td>41.39</td><td>52.25</td><td>48.96</td><td>56.34</td><td>41.91</td><td>39.68</td><td>27.00</td></tr><tr><td>Trunc Normal Mean</td><td>46.25</td><td>44.76</td><td>46.12</td><td>38.08</td><td>53.18</td><td>46.92</td><td>46.92</td><td>48.83</td><td>42.09</td><td>28.06</td></tr><tr><td>Trunc Normal Std</td><td>45.96</td><td>45.35</td><td>46.38</td><td>37.61</td><td>53.38</td><td>46.41</td><td>46.76</td><td>44.86</td><td>42.43</td><td>28.68</td></tr><tr><td>Trunc Normal Ent</td><td>46.06</td><td>45.01</td><td>46.38</td><td>37.57</td><td>53.15</td><td>46.67</td><td>46.67</td><td>38.85</td><td>42.09</td><td>28.11</td></tr><tr><td>Best</td><td>50.05</td><td>45.67</td><td>46.39</td><td>41.45</td><td>53.53</td><td>41.97</td><td>43.69</td><td>38.85</td><td>39.68</td><td>26.88</td></tr><tr><td>Worst</td><td>45.96</td><td>35.87</td><td>45.92</td><td>37.57</td><td>50.62</td><td>52.21</td><td>57.91</td><td>48.83</td><td>42.43</td><td>29.12</td></tr><tr><td colspan="9">CowC</td><td></td><td></td></tr><tr><td>Random</td><td>65.05</td><td>57.43</td><td>52.30</td><td>64.31</td><td>65.55</td><td>77.38</td><td>75.44</td><td>71.11</td><td>78.25</td><td>77.32</td></tr><tr><td>SMOE Scale</td><td>64.19</td><td>63.02</td><td>71.05</td><td>62.87</td><td>80.65</td><td>45.16</td><td>44.09</td><td>43.97</td><td>62.78</td><td>59.49</td></tr><tr><td>STD</td><td>60.36</td><td>61.95</td><td>70.89</td><td>64.57</td><td>80.55</td><td>44.12</td><td>43.52</td><td>44.10</td><td>60.69</td><td>59.73</td></tr><tr><td>Mean</td><td>63.82</td><td>59.90</td><td>73.20</td><td>61.83</td><td>80.54</td><td>45.79</td><td>59.24</td><td>44.61</td><td>64.02</td><td>58.86</td></tr><tr><td>Shannon Ent</td><td>62.64</td><td>63.78</td><td>73.29</td><td>60.99</td><td>78.77</td><td>46.50</td><td>44.23</td><td>46.42</td><td>68.31</td><td>57.98</td></tr><tr><td>Log Normal Mean</td><td>66.37</td><td>46.05</td><td>72.89</td><td>60.21</td><td>80.38</td><td>48.98</td><td>71.02</td><td>46.69</td><td>67.19</td><td>58.16</td></tr><tr><td>Log Normal ENT</td><td>63.23</td><td>62.78</td><td>73.26</td><td>60.99</td><td>80.44</td><td>45.10</td><td>57.12</td><td>44.92</td><td>65.61</td><td>58.56</td></tr><tr><td>Trunc Normal Mean</td><td>60.00</td><td>63.35</td><td>72.08</td><td>65.62</td><td>80.54</td><td>42.98</td><td>44.44</td><td>44.15</td><td>61.60</td><td>59.45</td></tr><tr><td>Trunc Normal Std</td><td>59.52</td><td>63.74</td><td>71.58</td><td>65.58</td><td>80.54</td><td>42.76</td><td>43.45</td><td>43.98</td><td>62.07</td><td>59.81</td></tr><tr><td>Trunc Normal Ent</td><td>59.79</td><td>63.48</td><td>71.77</td><td>65.68</td><td>80.59</td><td>43.04</td><td>43.80</td><td>43.89</td><td>61.79 60.69</td><td>59.89 57.98</td></tr><tr><td>Best Worst</td><td>66.37 59.52</td><td>63.78 46.05</td><td>73.29 70.89</td><td>65.68 60.21</td><td>80.65 78.77</td><td>42.76 48.98</td><td>43.45 71.02</td><td>43.89 46.69</td></table>
+
+A.6 COMBINED KAR AND ROAR SCORES WITH MORE DETAIL
+
+This subsection shows the raw scores for each ROAR and KAR mask. We also added the nonSmoothGrad methods so we can see how much of an improvement it makes.
+
+Table 5: Combined KAR and ROAR scores for several methods. This is a more detailed version of Table 2 and Figure 5. The top six rows show several popular methods with and without Squared SmoothGrad applied to give optimal results. These are taken from (Hooker et al., 2018). Prior Layer Weights means we applied layer weights based on the prior determined accuracy of the layer saliency map. We include our top three scoring methods. The SMOE Scale method outperforms the three baseline methods on KAR. It outperforms Guided Backprop and Integrated Gradients on ROAR as well as overall. The Gradient method is best overall, but as we discussed, it is much more expensive to compute.   
+
+<table><tr><td></td><td colspan="5">KAR Kept Percent</td><td colspan="5">ROAR Removed Percent</td></tr><tr><td>Method</td><td>10%</td><td>30%</td><td>50%</td><td>70%</td><td>90%</td><td>10%</td><td>30%</td><td>50%</td><td>70%</td><td>90%</td></tr><tr><td>Rand</td><td>63.53</td><td>67.06</td><td>69.13</td><td>71.02</td><td>72.65</td><td>72.65</td><td>71.02</td><td>69.13</td><td>67.06</td><td>63.53</td></tr><tr><td>Gradient</td><td>67.63</td><td>71.45</td><td>72.02</td><td>72.85</td><td>73.46</td><td>72.94</td><td>72.22</td><td>70.97</td><td>70.72</td><td>66.75</td></tr><tr><td>Guided Backprop</td><td>71.03</td><td>72.45</td><td>72.28</td><td>72.69</td><td>71.56</td><td>72.29</td><td>71.91</td><td>71.18</td><td>71.48</td><td>70.38</td></tr><tr><td>Integrated Grad.</td><td>70.38</td><td>72.51</td><td>72.66</td><td>72.88</td><td>73.32</td><td>73.17</td><td>72.72</td><td>72.03</td><td>71.68</td><td>68.20</td></tr><tr><td>Gradient -w- SmoothGrad Sq.</td><td>63.25</td><td>69.79</td><td>72.20</td><td>73.18</td><td>73.96</td><td>69.35</td><td>60.28</td><td>41.55</td><td>29.45</td><td>11.09</td></tr><tr><td>Guided Backprop -w- SmoothGrad Sq.</td><td>62.42</td><td>68.96</td><td>71.17</td><td>72.72</td><td>73.77</td><td>69.74</td><td>60.56</td><td>52.21</td><td>34.98</td><td>15.53</td></tr><tr><td>Integrated Grad.-w- SmoothGrad Sq.</td><td>67.55</td><td>68.96</td><td>72.24</td><td>73.09</td><td>73.80</td><td>70.76</td><td>65.71</td><td>58.34</td><td>43.71</td><td>29.41</td></tr><tr><td>SMOE Scale+ Prior Layer Weights</td><td>65.44</td><td>72.14</td><td>74.28</td><td>74.51</td><td>75.01</td><td>70.40</td><td>60.33</td><td>48.48</td><td>34.23</td><td>17.72</td></tr><tr><td>SMOE Scale+ Layer Weights [1...,5]</td><td>65.76</td><td>72.60</td><td>73.97</td><td>74.53</td><td>74.94</td><td>70.28</td><td>60.93</td><td>48.73</td><td>35.66</td><td>18.01</td></tr><tr><td>SMOE Scale + Layer Weights [1...,1]</td><td>66.13</td><td>72.28</td><td>73.72</td><td>74.52</td><td>74.97</td><td>71.28</td><td>63.58</td><td>52.85</td><td>38.74</td><td>19.72</td></tr><tr><td>Normal Std + Prior L.Weights</td><td>65.48</td><td>72.17</td><td>73.93</td><td>74.62</td><td>74.67</td><td>69.98</td><td>60.39</td><td>48.75</td><td>34.63</td><td>18.13</td></tr><tr><td>Trunc Normal Ent + Prior L.Weights</td><td>65.45</td><td>72.38</td><td>74.10</td><td>74.40</td><td>74.75</td><td>69.85</td><td>60.08</td><td>48.05</td><td>34.32</td><td>18.37</td></tr></table>
+
+# A.7 OPERATIONS COMPUTATION
+
+Table 6: FLOPs for each layer. This is the breakdown of FLOPs for each layer. Log and Error Function are counted as one operation in this example. SMOE Ops is how many operations it takes to compute the initial saliency map using the SMOE Scale statistic. Norm Ops is the number of operations needed to normalize the saliency map. Combine Ops is the number of ops needed to upsample and combine each saliency map.   
+
+<table><tr><td colspan="4">Layer Dimensions</td><td colspan="3">FLOPS</td></tr><tr><td>Layer</td><td>Channels</td><td>Size H</td><td>Size W</td><td> SMOE Ops</td><td>Norm Ops</td><td>Combine Ops</td></tr><tr><td>Layer 1</td><td>64</td><td>112</td><td>112</td><td>3223808</td><td>150528</td><td>225792</td></tr><tr><td>Layer 2</td><td>256</td><td>56</td><td>56</td><td>3214400</td><td>37632</td><td>338688</td></tr><tr><td>Layer 3</td><td>512</td><td>28</td><td>28</td><td>1606416</td><td>9408</td><td>338688</td></tr><tr><td>Layer 4</td><td>1024</td><td>14</td><td>14</td><td>803012</td><td>2352</td><td>338688</td></tr><tr><td>Layer 5</td><td>2048</td><td>7</td><td>7</td><td>401457</td><td>588</td><td>338688</td></tr><tr><td>Total</td><td></td><td></td><td></td><td>9249093</td><td>200508</td><td>1580544</td></tr></table>

parse/train/ryxf9CEKDr/ryxf9CEKDr_content_list.json

@@ -0,0 +1,1746 @@
+[
+    {
+        "type": "text",
+        "text": "EFFICIENT SALIENCY MAPS FOR EXPLAINABLE AI ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            787,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            400,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            209,
+            544,
+            224
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We describe an explainable AI saliency map method for use with deep convolutional neural networks (CNN) that is much more efficient than popular gradient methods. It is also quantitatively similar and better in accuracy. Our technique works by measuring information at the end of each network scale which is then combined into a single saliency map. We describe how saliency measures can be made more efficient by exploiting Saliency Map Order Equivalence. Finally, we visualize individual scale/layer contributions by using a Layer Ordered Visualization of Information. This provides an interesting comparison of scale information contributions within the network not provided by other saliency map methods. Since our method only requires a single forward pass through a few of the layers in a network, it is at least $9 7 \\mathbf { x }$ faster than Guided Backprop and much more accurate. Using our method instead of Guided Backprop, class activation methods such as Grad-CAM, Grad- $\\mathrm { C A M + + }$ and Smooth Grad- $\\mathrm { C A M + + }$ will run several orders of magnitude faster, have a significantly smaller memory footprint and be more accurate. This will make such methods feasible on resource limited platforms such as robots, cell phones and low cost industrial devices. This will also significantly help them work in extremely data intensive applications such as satellite image processing. All without sacrificing accuracy. Our method is generally straight forward and should be applicable to the most commonly used CNNs 1. ",
+        "bbox": [
+            233,
+            246,
+            764,
+            502
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            542,
+            334,
+            559
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks (DNN) have provided a new burst of research in the machine learning community. However, their complexity obfuscates the underlying processes that drive their inferences. This has lead to a new field of explainable AI (XAI). A variety of tools are being developed to enable researchers to peer into the inner workings of DNNs. One such tool is the XAI saliency map. It is generally used with image or video processing applications and is supposed to show what parts of an image or video frame are most important to a network’s decisions. The seemingly most popular methods derive a gradient saliency map by back-propagating a gradient from the end of the network and project it onto an image plane (Simonyan et al., 2014; Zeiler & Fergus, 2014; Springenberg et al., 2015; Sundararajan et al., 2017; Patro et al., 2019). The gradient can typically be from a loss function, layer activation or class activation. Thus, it requires storage of the data necessary to compute a full backward pass on the input image. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Several newer methods attempt to iteratively augment the image or a mask in ways that affect the precision of the results (Fong & Vedaldi, 2017; Chang et al., 2018). Additionally, saliency map encoders can be trained within the network itself (Dabkowski & Gal, 2017). Both of these methods have a distinct advantage of being more self-evidently empirical when compared with gradient techniques. Class Activation Map (CAM) methods (Selvaraju et al., 2017; Chattopadhyay et al., 2018; Omeiza et al., 2019) efficiently map a specified class to a region in an image, but the saliency map is very coarse. They generally use a method like Guided Backprop (Springenberg et al., 2015) to add finer pixel level details. This requires a full backwards pass through the network, and it adds significant memory and computational overhead to CAM solutions relative to just computing the CAM alone. Several of the CAM methods compute gradients aside from the use of Guided Backprop, but we will differentiate them by referring to them as CAM methods. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            883
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1.1 EFFICIENCY AND WHY IT MATTERS HERE ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            103,
+            508,
+            117
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Most saliency map methods require many passes through the network in order to generate results or train. The gradient methods hypothetically would require just one backwards pass, but often require as many as 15 in order to give an accurate rendering (Hooker et al., 2018). This is not always a problem in the lab when a person has a powerful GPU development box. However, what if one would like to see the workings of the network at training time or even run time? This can be a serious hurdle when running a network on mobile or embedded platforms. It is not uncommon for hardware to be barely fast enough to process each image from a video source. Running a full backward pass can lead to dropped frames. Additionally, viewing or saving the saliency map for each frame is infeasible. Another problem is that some platforms may not have the memory capacity to save all the information required for a backward pass. Gradient based methods cannot work in these instances. Sometimes this can even be the case with powerful hardware. Satellite images can be vary large and potentially exhaust generous resources. An efficient method would enable developers in these areas to get feedback in the field and aid in debugging or understanding the behavior of a network. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            308
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here we show a method of computing an XAI saliency map which is highly efficient. The memory and processing overhead is several orders of magnitude lower than the commonly used gradient methods. This makes it feasible in any resource limited environment. Also, since we demonstrate empirically that our method is either similar or more accurate than the most commonly used gradient methods, it can be used it to speed up run-time in any situation. It is fast enough that we already use it automatically when training networks. We notice very little degradation of training speed. ",
+        "bbox": [
+            174,
+            314,
+            823,
+            396
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            422,
+            290,
+            439
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 SALIENCY MAP DERIVATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            459,
+            416,
+            474
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We were looking for a method to compute saliency maps based on certain conditions and assumptions. ",
+        "bbox": [
+            176,
+            488,
+            823,
+            517
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. The method used needs to be relatively efficient to support rapid analysis at both test time and during DNN training.   \n2. The method should have a reasonable information representation. As a DNN processes data, the flow of information should become localized to areas which are truly important.   \n3. The method should capture the intuition that the informativeness of a location is proportional to the overall activation level of all the filters as well their variance. That is, informative activations should have a sparse pattern with strong peaks. ",
+        "bbox": [
+            212,
+            531,
+            825,
+            651
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our approach works by creating saliency maps for the output layer of each scale in a neural network and then combines them. We can understand scale by noting that the most commonly used image processing DNNs work on images with filter groups at the same scale which down-sample the image and pass it to the group of filters at the next scale, and so on. Given a network like ResNet-50 (He et al., 2015) with in input image size of $2 2 4 x 2 2 4$ , we would have five scale groups of size $1 1 2 x 1 1 2$ , $5 6 x 5 6$ , $2 8 x 2 8$ , $1 4 x 1 4$ and $7 x 7$ . It is at the end of these scale groups where we are interested in computing saliency. In this way, our approach is efficient and is computed during the standard forward pass through the network. No extra pass is needed. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            775
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To achieve localization of information, we measure statistics of activation values arising at different input locations. Given an output activation tensor $\\pmb { \\mathsf { T } } \\in \\mathbb { R } ^ { + , p \\times q \\times r }$ with spatial indices $i , j \\in p , q$ and depth index $k \\in \\textit { r }$ from some layer ${ \\boldsymbol { \\mathsf { T } } } = l \\left( { \\boldsymbol { \\mathsf { X } } } \\right)$ . In our case $l \\left( . \\right)$ is a $R e L U$ (Nair & Hinton, 2010). We apply a function to each column at $i , j$ over all depths $k$ . This yields a 2D saliency map $\\pmb { S } \\in \\mathbb { R } ^ { + , p \\times \\hat { q } }$ where $S = \\varphi \\left( \\boldsymbol { \\mathsf { T } } \\right)$ . We process the tensor after it has been batch-normalized (Ioffe & Szegedy, 2015) and processed by the activation function. When we compute Truncated Normal statistics as an alternative in later section, we take the tensor prior to the activation function. ",
+        "bbox": [
+            174,
+            781,
+            825,
+            876
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, to capture our intuition about the informativeness of an output activation tensor, we derived $\\varphi \\left( . \\right)$ by creating a special simplification of the maximum likelihood estimation Gamma Scale parameter (Choi & Wette, 1969). One way we can express it is: ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/2286f7ccdeec7b998cb675e9d8ace2b46e53aa64a679d3edf69afdcc72404e03.jpg",
+        "image_caption": [
+            "Figure 1: The left most image is the input to the network. Five saliency maps are shown for each spatial scale in the network. They are combined per $\\operatorname { E q } 3$ . The right most image is the combined saliency map created from these. To aid in visualizing context, it has been alpha blended with a gray scale version of the original image here at $2 5 \\%$ . Many more combined saliency map examples can be seen in Appendix Figures 9 and 10 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            99,
+            820,
+            186
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f6ba485e6d76582b932faf7b13f711cd64f0039025adeefc1742937923276fb0.jpg",
+        "text": "$$\n\\varphi \\left( . \\right) = \\frac { 1 } { r } \\cdot \\sum _ { k = 1 } ^ { r } x _ { k } \\cdot \\left[ l o g _ { 2 } \\left( \\frac { 1 } { r } \\cdot \\sum _ { k = 1 } ^ { r } x _ { k } \\right) - \\frac { 1 } { r } \\cdot \\sum _ { k = 1 } ^ { r } l o g _ { 2 } \\left( x _ { k } \\right) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            320,
+            702,
+            364
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To avoid log zero, we add $1 e - 0 6$ to each $x _ { k }$ . How mean and variance relate seems readily apparent with the square bracketed part being the computational formula for the standard deviation with values taken to $l o g _ { 2 } \\left( . \\right)$ rather than squared. This is preceded by a typical mean estimate. This meets the third requirement we mentioned. This simplification is Saliency Map Order Equivalent (SMOE) to the full iterative (and expensive) scale parameter estimation. We define SMOE as follows. Given saliency map $S _ { a } \\in \\mathbb { R } ^ { + , p \\times q }$ and $S _ { b } \\in \\mathbb { R } ^ { + , p \\times q }$ where we may have $S _ { a } \\neq S _ { b }$ , if we sort the pixels by value, then $S _ { a }$ will be sorted in exactly the same order as $S _ { b }$ . That means that the most salient location $i , j$ is exactly the same in both $S _ { a }$ and $S _ { b }$ . This also means that if we create a binary mask of the $n \\%$ most salient pixels, the mask for both $S _ { a }$ and $S _ { b }$ will also be exactly the same. SMOE is preserved if for instance, we apply independent monotonic functions to a saliency map. As such, we may as well strip these away to save on computation. Tie values may create an imperfect equivalence, but we assert that these should be very rare and not affect results by a measurable amount. ",
+        "bbox": [
+            173,
+            369,
+            825,
+            545
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Using $\\mu$ as the mean of each column $r$ in $\\boldsymbol { \\mathsf { T } }$ , we can see the information relation more clearly if we simplify Eq 1 further which gives us our SMOE Scale method: ",
+        "bbox": [
+            173,
+            551,
+            823,
+            580
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/12de0645e27efec0553c714f06dc3db3f15c47c7d79f30d679e4d8c11940f874.jpg",
+        "text": "$$\n\\varphi \\left( . \\right) = \\frac { 1 } { r } \\cdot \\sum _ { k = 1 } ^ { r } \\mu \\cdot \\log _ { 2 } \\left( \\frac { \\mu } { x _ { k } } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            599,
+            601,
+            641
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The resemblance to conditional entropy is apparent. However, since the values in $\\operatorname { E q } 2$ are not probabilities, this does not fit the precise definition of it. On the other hand, the interpretation is fairly similar. It is the mean activation multiplied by the information we would gain if we knew the individual values which formed the mean. Put in traditional terms, it is the information in the mean conditioned on the individual values. Numerical examples of this method at work can be seen in Appendix Table 3 along with more information on the derivation. To create a 2D saliency map $\\pmb { S } \\in \\mathbb { R } ^ { + , p \\times q }$ , we simply apply Eq 2 at each spatial location $i , j \\in p , q$ with column elements $k \\in r$ in the 3D activation tensor $\\boldsymbol { \\mathsf { T } }$ for a given input image. ",
+        "bbox": [
+            173,
+            646,
+            825,
+            757
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 COMBINED SALIENCY MAP GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            775,
+            504,
+            790
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For each input image, we derive five saliency maps. For different networks, this number may vary. Given a network such as a ResNet (He et al., 2015), AlexNet (Krizhevsky et al., 2013), VGG Net (Simonyan & Zisserman, 2015) or DenseNet (Huang et al., 2017) we compute saliency on the final tensor computed at each spatial scale. Recall that most image classification networks process images in a pipeline that processes an image in consecutive groups of convolution layers where each group downsamples the image by $1 / 2 \\mathbf { x }$ before passing it onto the next. It is just prior to the downsampling that we compute each saliency map. Computing saliency across image scales is a classical technique (Itti et al., 1998). This is also similar to the method used in the XAI saliency technique described in (Dabkowski & Gal, 2017). ",
+        "bbox": [
+            173,
+            801,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/81b44ec40e147e2162caa9b8c053146acaebf72f2489dae4f356e61e1c164371.jpg",
+        "image_caption": [
+            "Figure 2: Images are shown with their combined saliency map using our LOVI scheme. The hue in each saliency map corresponds to layer activation. Earlier layers start at violet and trend red in the last layers following the order of the rainbow. Areas which are blue or violet are only activated early in network processing. They tend to activate early filters, but are later disregarded by the network. Yellow and red areas are only activated later in the network. They appear to be places where the objects components are combined together. White areas are activated throughout all network layers. They possibly correspond to the most important features in the image. Many more examples can be seen in Appendix Figures 11 and 12 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            217,
+            101,
+            781,
+            316
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To make our maps easier to visualize or combine together, we normalize them from 0 to 1 by squashing them with the normal cumulative distribution function $\\gamma \\left( s ; \\mu , \\sigma \\right)$ . Here mean and standard deviation are computed independently over each saliency map. We then create a combined saliency map by taking the weighted average of the maps. Since they are at different scales, they are upsampled via bilinear interpolation to match the dimensions of the input image. Given $r$ saliency maps that have been bilinear interpolated (upsampled) to the original input image size $p , q$ , they are then combined as: ",
+        "bbox": [
+            173,
+            477,
+            825,
+            570
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9cbbd73f225f1fb08d48d53610f095ac6a6c7cfbac81df0c029b539cf685b0a0.jpg",
+        "text": "$$\nc _ { i , j } = \\frac { \\sum _ { k = 1 } ^ { r } \\gamma \\left( s _ { i , j , k } ; \\mu _ { k } , \\sigma _ { k } \\right) \\cdot w _ { k } } { \\sum _ { k = 1 } ^ { r } w _ { k } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            568,
+            617,
+            604
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that technically, we compute $\\gamma \\left( s ; \\mu , \\sigma \\right)$ before we upsample. Weighting is very useful since we expect that saliency maps computed later in the network should be more accurate than saliency maps computed earlier as the network has reduced more irrelevant information in deeper layers, distilling relevant pixels from noise (Tishby et al., 2000). Network activity should be more focused on relevant locations as information becomes more related to the message. We observe this behavior which can be seen later in Figure 4. A saliency map generation example can be seen in Figure 1 with many more examples in Appendix Figures 9 and 10. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            702
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The advantages of creating saliency maps this way when compared with most gradient methods are: ",
+        "bbox": [
+            176,
+            708,
+            821,
+            723
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Pro: This is relatively efficient, requiring processing of just five low cost layers during a standard forward pass.   \n• Pro: We can easily visualize the network at different stages (layers).   \n• Con: The current method does not have a class specific activation map (CAM) (Selvaraju et al., 2017; Chattopadhyay et al., 2018; Omeiza et al., 2019), but we discuss how this can be done later. ",
+        "bbox": [
+            215,
+            734,
+            825,
+            827
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 VISUALIZING MULTIPLE SALIENCY MAPS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            843,
+            509,
+            858
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One advantage to computing multiple saliency maps at each scale is that we can get an idea of what is happening in the middle of the network. However, with so many saliency maps, we are starting to be overloaded with information. This could get even worse if we decided to insert saliency maps after each layer rather than just at the end of each scale. One way to deal with this is to come up with a method of combining saliency maps into a single image that preserves useful information about each map. Such a composite saliency map should communicate where the network is most active as well as which layers specifically are active. We call our method Layer Ordered Visualization of Information (LOVI). We do this by combining saliency maps using an HSV color scheme (Joblove & Greenberg, 1978) where hue corresponds to which layer is most active at a given location. That is, it shows the mean layer around which a pixels activity is centered. Saturation tells us the uniqueness of the activation. This is the difference between the maximum value at a location and the others. Value (intensity) corresponds to the maximal activation at that location. Basically, this is a pixel’s importance. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            226
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "If only one layer is active at a location, the color will be very saturated (vivid colors). On the other hand, if all layers are equally active at a given location, the pixel value will be unsaturated (white or gray). If most of the activation is towards the start of a network, a pixel will be violet or blue. If the activation mostly happens at the end, a pixel will be yellow or red. Green indicates a middle layer. Thus, the color ordering by layer follows the standard order of the rainbow. Examples can be seen in Figure 2. Given $k \\in r$ saliency maps $\\pmb { S }$ (in this instance, we have $r = 5$ maps), we stack them into a tensor $\\pmb { \\mathsf { S } } \\in \\mathbb { R } ^ { + , p \\times q \\times r }$ . Note that all $s \\in [ 0 , 1 ]$ because of $\\operatorname { E q } 3$ and they have been upsampled via bilinear interpolation to match the original input image size. Given: ",
+        "bbox": [
+            173,
+            231,
+            825,
+            340
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/333e83cc25441ad5e5100f3c6d5f1f2c30049f4a249a922d02e9415a248e9527.jpg",
+        "text": "$$\n\\begin{array} { r } { \\phi \\left( k \\right) = 1 - \\frac { k - 1 } { r } \\cdot \\left( \\frac { r - 1 } { r } \\right) ^ { - 1 } , \\nu = \\frac { 1 } { r } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            342,
+            617,
+            364
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { H u e } \\in [ 0 , 3 6 0 ]$ is basically the center of mass of activation for column vector $\\pmb { s }$ at each location $i , j \\in p , q$ in S: ",
+        "bbox": [
+            176,
+            366,
+            823,
+            393
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c16e4c303c84a202a351fc5adbecf2ecf4646d383cd51fc666a2e6f8cd9fea3a.jpg",
+        "text": "$$\nH u e = \\frac { \\sum _ { k = 1 } ^ { r } s _ { k } \\cdot \\phi \\left( k \\right) } { \\sum _ { k = 1 } ^ { r } s _ { k } } \\cdot 3 0 0 \n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            391,
+            602,
+            428
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Saturation $\\in [ 0 , 1 ]$ is the inverse of the ratio of the values in $\\pmb { s }$ compared to if they are all equal to the maximum value. So for instance, if one value is large and all the other values are small, saturation is high. On the other hand, if all values are about the same (equal to the maximum value), saturation is very small: ",
+        "bbox": [
+            173,
+            428,
+            825,
+            481
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ac66de97d6ddedbb91b001cdb6c4b9edfafb272bb88b0ff93dc086570060b2a7.jpg",
+        "text": "$$\nS a t = 1 - \\frac { \\sum _ { k = 1 } ^ { r } \\left( s _ { k } \\right) - \\nu } { r \\cdot m a x \\left( s \\right) \\cdot \\left( 1 - \\nu \\right) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            479,
+            609,
+            515
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Value $\\in [ 0 , 1 ]$ is basically just the maximum value in vector $\\pmb { s }$ : ",
+        "bbox": [
+            173,
+            515,
+            588,
+            530
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8232983aca7200d6351b7ef435ec3e80931997ffc6202a5be854e88363c0f431.jpg",
+        "text": "$$\nV a l = m a x \\left( s \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            444,
+            532,
+            553,
+            549
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Once we have the HSV values for each location, we then convert the image to RGB color space in the usual manner. ",
+        "bbox": [
+            173,
+            551,
+            823,
+            578
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.4 QUANTIFICATION VIA ROAR AND KAR ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            594,
+            495,
+            608
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(Hooker et al., 2018) proposed a standardized method for comparing XAI saliency maps. This extends on ideas proposed by (Dabkowski & Gal, 2017; Samek et al., 2017) and in general hearkens back to methods used to compare computational saliency maps to psychophysical observations (Itti & Koch, 2001). The general idea is that if a saliency map is an accurate representation of what is important in an image, then if we block out salient regions, network performance should degrade. Conversely, if we block out non-salient regions, we should see little degradation in performance. The ROAR/KAR metrics measure these degradations explicitly. The KAR metric (Keep And Retrain) works by blanking out the least salient information/pixels in an input image, and the ROAR (Remove And Retrain) metric uses the contrary strategy and removes the most salient pixels. Figure 3 shows an example of ROAR and KAR masked image. A key component to the ROAR/KAR method is that the network needs to be retrained with saliency masking in place. This is because when we mask out regions in an input image, we unavoidably create artifacts. By retraining the network on masked images, the network learns to ignore the new artifacts and focus on image information. ",
+        "bbox": [
+            173,
+            619,
+            825,
+            795
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We will give a few examples to show why we need both metrics. If a saliency map is good at deciding which parts of an image are least informative but gets the ranking of the most salient objects wrong, ROAR scores will suggest the method is very good. This is because it masks out the most salient locations in one large grouping. However, ROAR will be unable to diagnose that the saliency map has erroneously ranked the most informative locations until we have removed $50 \\%$ or more of the salient pixels. As such, we get no differentiation between the top $1 \\%$ and the top $10 \\%$ most salient pixels. On the other hand, KAR directly measures how well the saliency map has ranked the most informative locations. By using both metrics, we can quantify the goodness of both the most and least salient locations in a map. ",
+        "bbox": [
+            174,
+            801,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/c2fc969838a856383df2845b4ea618604d90723ced01925b453e6893c80ad514.jpg",
+        "image_caption": [
+            "Figure 3: These are the KAR (kept) and ROAR (removed) mask images created by masking out the original images with the combined saliency map. The percentage is how much of the image has been kept or removed based on the combined saliency map. Thus, the $10 \\%$ kept example shows the top $10 \\%$ most salient pixels in the image. It is these example images that are fed into the network when we compute the KAR and ROAR scores. Many more examples can be seen in Appendix Figure 8 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            99,
+            818,
+            215
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 QUANTITATIVE EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            337,
+            457,
+            353
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 COMPARING DIFFERENT EFFICIENT STATISTICS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            371,
+            545,
+            385
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We tested our SMOE Scale saliency map method against several other statistical measures using three different datasets that have fairly different tasks and can be effectively trained from scratch. The sets used are ImageNet (Deng et al., 2009), CSAIL Places (Zhou et al., 2014) and COWC (Mundhenk et al., 2016). ImageNet as a task focuses on foreground identification of objects in standard photographic images. Places has more emphasis on background objects, so we would expect more spatial distribution of useful information. COWC, Cars Overhead With Context is an overhead dataset for counting as many as 64 cars per image. We might expect information to be spatially and discretely localized, but distributed over many locations. In summary, these three datasets are expected to have fairly different distributions of important information within each image. This should give us more insight into performance than if we used several task-similar datasets (e.g. Three photographic foreground object sets such as; ImageNet $^ +$ CUB (birds) (Welinder et al., 2010) $^ +$ CompCars (Yang et al., 2015)). ",
+        "bbox": [
+            174,
+            397,
+            825,
+            559
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For compatibility with (Hooker et al., 2018), we used a ResNet-50 network (He et al., 2015). We also show performance on a per layer basis in order to understand the accuracy at different levels of the network. For comparison with our SMOE Scale method, we included any statistical measure which had at least a modicum of justification and was within the realm of the efficiency we were aiming for. These included parameter and entropy estimations from Normal, Truncated-normal, Log-normal and Gamma Distribution models. We also tested Shanon Entropy and Renyi Entropy. To save compute time, we did a preliminary test on each method and did not continue using it if the results qualitatively appeared very poor and highly unlikely to yield good quantitative results. Normal entropy was excluded because it is SMOE with the Normal standard deviation. This left us with nine possible statistical models which we will discuss in further detail. ",
+        "bbox": [
+            174,
+            566,
+            825,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Saliency maps for each method are computed over each tensor column in the same way as we did with our SMOE Scale metric. The only difference is with the truncated-normal statistic which computes parameters prior to the ReLU layer. We should note that (Jeong & Shin, 2019) uses a truncated normal distribution to measure network information for network design. Recall that we have five saliency map layers. They are at the end of each of the five network spatial scales. We test each one at a time. This is done by setting the network with pre-trained weights for the specific dataset. Then, all weights in the network which come after the saliency mask to be tested are allowed to fine-tune over 25 epochs. Otherwise, we used the same methodology as (He et al., 2015) for data augmentation etc. This is necessary in order to adapt the network to mask related artifacts as specified in the ROAR/KAR protocol. At the level where the saliency map is generated, we mask out pixels in the activation tensor by setting them to zero. For this experiment, we computed the ROAR statistic for the $10 \\%$ least salient pixels. For KAR, we computed a map to only let through the top $2 . 5 \\%$ most salient pixels. This creates a more similar magnitude between ROAR and KAR measures. Layer scores for the top five methods can be seen in Figure 4. We combine layer scores two different ways since ROAR and KAR scores are not quite proportional. These methods both yield very similar results. The first method takes the improvement difference between ",
+        "bbox": [
+            174,
+            708,
+            825,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/9ac15155188471db3e61f929f42764903195f545c7e274f14786d4d55f3323c5.jpg",
+        "image_caption": [
+            "Figure 4: SMOE Scale is compared with several other efficient statistical methods. The Y-axis is the combined score per scale layer over all three image sets. The $\\mathbf { X }$ -axis is the network layer with L1 being the earliest layer in the network and L5 near the end. A difference score of zero means the result was about the same as for a randomly generated saliency map. Less than zero means it is worse. SMOE Scale differentiates itself the most early on in the network where most statistical methods score at the level of a random saliency map. About mid way through, the difference between methods becomes relatively small. This may be because information contains more message and less noise by this point in processing. Finer grain details can be seen in Appendix Table 4 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            99,
+            825,
+            237
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1: KAR and ROAR results per dataset. The Difference Score shows the results using Eq 8. The Information Score uses Eq 9. They are sorted by the average difference score (AVG). The SMOE Scale from Eq 2 performs best overall using both scoring methods. The vanilla standard deviation is second best. Recall it is SMOE with normal entropy. Truncated normal entropy is best on the COWC set and ranks third overall. It is interesting to note that the difference in scores over COWC are not as large as the other two datasets. The top four methods all are information related and mean activation style methods are towards the bottom. Finer grain details can be seen in Appendix Table 4 ",
+        "bbox": [
+            173,
+            392,
+            825,
+            502
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/eed6592e431fec1d86b26fd5404c0ac3c6172360615d0d39ff799be8de09e6b3.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"4\">Difference Score</td><td colspan=\"4\">Information Score</td></tr><tr><td>Method</td><td>ImNet</td><td>Places</td><td>COWC</td><td>AVG</td><td>ImNet</td><td>Places</td><td>COWC</td><td>AVG</td></tr><tr><td>SMOE Scale</td><td>1.70</td><td>0.90</td><td>1.61</td><td>1.40</td><td>1.13</td><td>0.68</td><td>1.31</td><td>1.04</td></tr><tr><td>Standard Dev</td><td>1.64</td><td>0.83</td><td>1.61</td><td>1.36</td><td>1.07</td><td>0.61</td><td>1.30</td><td>0.99</td></tr><tr><td>Trunc Normal Ent</td><td>1.56</td><td>0.77</td><td>1.64</td><td>1.32</td><td>1.00</td><td>0.56</td><td>1.32</td><td>0.96</td></tr><tr><td>Shanon Ent</td><td>1.61</td><td>0.80</td><td>1.51</td><td>1.31</td><td>0.98</td><td>0.59</td><td>1.23</td><td>0.93</td></tr><tr><td>Trunc Normal Std</td><td>1.51</td><td>0.71</td><td>1.64</td><td>1.28</td><td>1.00</td><td>0.52</td><td>1.32</td><td>0.94</td></tr><tr><td>Trunc Normal Mean</td><td>1.38</td><td>0.67</td><td>1.64</td><td>1.23</td><td>0.96</td><td>0.49</td><td>1.32</td><td>0.92</td></tr><tr><td>Normal Mean</td><td>1.29</td><td>0.63</td><td>1.42</td><td>1.11</td><td>0.75</td><td>0.44</td><td>1.18</td><td>0.79</td></tr><tr><td>Log Normal Ent</td><td>1.16</td><td>0.66</td><td>1.44</td><td>1.09</td><td>0.82</td><td>0.47</td><td>1.20</td><td>0.83</td></tr><tr><td>Log Normal Mean</td><td>1.46</td><td>0.55</td><td>1.09</td><td>1.03</td><td>0.54</td><td>0.35</td><td>0.88</td><td>0.59</td></tr></table>",
+        "bbox": [
+            176,
+            517,
+            820,
+            688
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "tested method’s score and a randomized mask score. We have five $\\kappa \\in [ 0 , 1 ]$ KAR scores for a method. We have five $\\rho \\in [ 0 , 1 ]$ ROAR scores for a method and five $z \\in \\ [ 0 , 1 ]$ scores from a random mask condition. This corresponds to each saliency map spatial scale which we tested. We compute a simple difference score as: ",
+        "bbox": [
+            173,
+            718,
+            825,
+            773
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d022db01bcd17933812b6bd9a38b0fed6e7a67e5d5f5a22e475ce89165120dbc.jpg",
+        "text": "$$\nD \\left( \\rho , \\kappa \\right) = \\sum _ { p = 1 } ^ { 5 } { \\left( z _ { p } - \\rho _ { p } \\right) } + \\sum _ { q = 1 } ^ { 5 } { \\left( \\kappa _ { q } - z _ { q } \\right) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            789,
+            640,
+            834
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The second method is an information gain score given by: ",
+        "bbox": [
+            174,
+            837,
+            555,
+            852
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3ed7abba47116e2823f497213af9be2a650cf1d09a3155f134485777739bf876.jpg",
+        "text": "$$\nI \\left( \\rho , \\kappa \\right) = - \\sum _ { p = 1 } ^ { 5 } { { { \\rho } _ { p } } \\cdot l o { { g } _ { 2 } } \\left( \\frac { { { \\rho } _ { p } } } { { { z } _ { p } } } \\right) } - \\sum _ { q = 1 } ^ { 5 } { { { z } _ { q } } \\cdot l o { { g } _ { 2 } } \\left( \\frac { { { z } _ { q } } } { { { \\kappa } _ { q } } } \\right) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            858,
+            681,
+            902
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows the results. ",
+        "bbox": [
+            174,
+            909,
+            343,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/a3dbc6264ebf770673200175de8e3c00a557c5a9ba66b15780fbc10ec00f51ee.jpg",
+        "image_caption": [
+            "Figure 5: SMOE Scale with prior layer weights is compared with three popular baseline methods that all use Squared SmoothGrad. Scores for these three are taken from (Hooker et al., 2018). The Yaxis is the model accuracy on ImageNet only. The $\\mathbf { X }$ -axis is how much of the input image salient pixels are kept or removed. KAR keeps the most salient locations. Higher accuracy values are better. ROAR removes the most salient regions. Lower values are better. Our method does not seem to suffer as much when the $10 \\%$ least salient parts are removed in KAR and in general maintains a better score. Our ROAR scores are very similar to Guided Backprop. Finer grain details can be seen in Appendix Table 5. Note that these results are not per layer. For a closer numerical comparison with the mask layer method, see Appendix Table 4. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            99,
+            818,
+            244
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.2 COMPARISON WITH POPULAR METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            410,
+            500,
+            425
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare our method with three popular saliency map methods using the standard ROAR/KAR methodology. These are Gradient Heatmaps (Simonyan et al., 2014), Guided Backprop (Springenberg et al., 2015) and Integrated Gradients (Sundararajan et al., 2017). All methods use SmoothGrad-Squared (Smilkov et al., 2017) which gives generally the best results. We should note that without SmoothGrad or another augmentation, all three do not yield very good ROAR/KAR scores. ",
+        "bbox": [
+            174,
+            439,
+            825,
+            520
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare three different weighting strategies when combining the saliency maps from all five scales. In the first strategy, we weight all five maps equal [1,1,1,1,1]. In the second, we use a ruleof-thumb like approach where we weight the first layer the least since it should be less accurate. Then each successive layer is weighted more. For this we choose the weights to be [1,2,3,4,5]. The third method weights the maps based on the expected accuracy given our results when we computed Table 1. These prior weights are [0.18, 0.15, 0.37, 0.4, 0.72]. The reason for showing the rule-ofthumb results is to give an idea of performance given imperfect weights since one may not want to spend time computing optimal prior weights. ",
+        "bbox": [
+            174,
+            527,
+            825,
+            636
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To fairly compare the three popular saliency map methods with our own, we adopt a methodology as close as possible to (Hooker et al., 2018). We train a ResNet-50 from scratch on ImageNet with either ROAR or KAR masking (computed by each of the different saliency mapping approaches in turn) at the start of the network. Otherwise, our training method is the same as (He et al., 2015). The comparison results are shown in Figure 5. We can try and refine these results into fewer scores by subtracting the sum of the ROAR scores from the sum of the KAR scores. The results can be seen in Table 2. The KAR score for our method is superior to all three comparison methods. The ROAR score is better than Guided Backpropagation and Integrated Gradients. This suggests our method is superior at correctly determining which locations are most salient, but is not as good as Gradient Heatmaps for determining which parts of the image are least informative. ",
+        "bbox": [
+            173,
+            642,
+            825,
+            777
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            805,
+            310,
+            821
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1 METHOD EFFICIENCY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            840,
+            364,
+            854
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The method as proposed is much faster than the three baseline comparison methods. Given a ResNet-50 network, we only process five layers. The other methods require a special back propagation step over all layers. We can compute the cost in time by looking at operations that come from three sources. The first is the computation of statistics on tensors in five layers. The second is ",
+        "bbox": [
+            176,
+            869,
+            823,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Combined KAR and ROAR scores for several methods on ImageNet Only. The top three rows show several popular methods with Squared SmoothGrad (Smilkov et al., 2017). These scores are created by simply summing the individual scores together. ROAR is negative since we want it to be as small as possible. Prior Layer Weights means we applied layer weights based on the prior determined accuracy of the layer saliency map. We include our top three scoring methods. The SMOE Scale method outperforms the three baseline methods on KAR. It outperforms Guided Backprop and Integrated Gradients on ROAR as well as overall. The Gradient method is best overall, but as we discuss later, it is at least 1456 times more computationally expensive to compute. Truncated normal entropy scores about the same as SMOE Scale. Since SMOE Scale gains its largest performance boost in the earlier layers, when we apply prior weighting, we reduce that advantage. Finer grain details can be seen in Appendix Table 5. ",
+        "bbox": [
+            174,
+            112,
+            825,
+            261
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/6f5f7441a17c7eaf09321d8df126aaea2703deb137b03ffe3762151079ca15f0.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>KAR</td><td>ROAR</td><td>SUM</td></tr><tr><td>Gradient (Simonyan et al., 2014) Guided Backprop (Springenberg et al., 2015)</td><td>3.57 3.60</td><td>-3.54 -3.57</td><td>0.04 0.04</td></tr><tr><td>Integrated Grad (Sundararajan et al., 2017) Gradient -w- SmoothGrad Sq.</td><td>3.62</td><td>-3.58</td><td>0.03</td></tr><tr><td>Guided Backprop -w- SmoothGrad Sq.</td><td>3.52 3.49</td><td>-2.12</td><td>1.41</td></tr><tr><td></td><td></td><td>-2.33</td><td>1.16</td></tr><tr><td>Integrated Grad -w- SmoothGrad Sq.</td><td>3.56</td><td>-2.68</td><td>0.88</td></tr><tr><td>SMOE Scale + Prior Layer Weights</td><td>3.61</td><td>-2.31</td><td>1.30</td></tr><tr><td>SMOE Scale + Layer Weights [1,2,3,4,5]</td><td>3.62</td><td>-2.34</td><td></td></tr><tr><td>SMOE Scale + Layer Weights [1,1,1,1,1]</td><td>3.62</td><td></td><td>1.28</td></tr><tr><td></td><td>3.61</td><td>-2.46</td><td>1.15</td></tr><tr><td>Normal Std + Prior Layer Weights</td><td></td><td>-2.32</td><td>1.29</td></tr><tr><td>Trunc Normal Ent + Prior Layer Weights</td><td>3.61</td><td>-2.31</td><td> 1.30</td></tr></table>",
+        "bbox": [
+            253,
+            266,
+            743,
+            454
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "the normalization of each 2D saliency map. Third we account for the cost of combing the saliency maps. ",
+        "bbox": [
+            176,
+            494,
+            821,
+            523
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ops for our solution ranges from $1 . 1 x 1 0 ^ { 7 }$ to $3 . 9 x 1 0 ^ { 7 }$ FLOPs (using terminology from (He et al., 2015)) for a ResNet-50. The network itself has $3 . 8 x 1 0 ^ { 9 }$ FLOPs in total. The range in our count comes from how we measure Log and Error Function operations that are computationally expensive compared to more standard ops and whose implementations vary. We estimate the worst case from available software instantiations. Most of the work comes from the initial computation of statistics over activation tensors. This ranges from $9 . 2 x 1 0 ^ { 6 }$ to $3 . 7 \\mathrm { ~ x ~ } 1 0 ^ { 7 }$ FLOPs. In total, this gives us an overhead of $0 . 3 \\%$ to $1 . 0 \\%$ relative to a ResNet-50 forward pass. All gradient methods have a nominal overhead of at least $100 \\%$ . A breakdown of the FLOPs per layer and component can be seen in Table 6 in the appendix. ",
+        "bbox": [
+            174,
+            527,
+            825,
+            651
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Compared to any method which requires a full backward pass, such as gradient methods, our solution is nominally between $9 7 x$ and $3 4 4 x$ faster for non-SmoothGrad techniques, which according to (Hooker et al., 2018) performs poorly on ROAR/KAR scores. We are between $1 4 5 6 x$ and $5 1 8 1 x$ faster than a 15-iteration SmoothGrad implementation that yields the competitive results in Table 2. 15 iterations as well as other parameters was chosen by (Hooker et al., 2018) who describe this selection in more detail. ",
+        "bbox": [
+            174,
+            657,
+            825,
+            738
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The memory footprint of our method is minuscule. Computation over tensors can be done inline which leaves the largest storage demand being the retention of 2D saliency maps. This is increased slightly by needing to store one extra $1 1 2 x 1 \\bar { 1 } 2$ image during bilinear up-sampling. Peak memory overhead related to data is about 117 kilobytes per $2 2 4 x 2 2 4$ input image. ",
+        "bbox": [
+            174,
+            746,
+            823,
+            800
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2 USAGE WITH A CLASS ACTIVATION MAP ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            827,
+            498,
+            840
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our method does not have a class activation map (Selvaraju et al., 2017; Chattopadhyay et al., 2018; Omeiza et al., 2019) in the current implementation. This is because what we have is more akin to Guided Backprop which Grad-CAM etc. combine with their class activation map to improve their pixel level accuracy. The overhead for the class activation map itself is not large since in practice, it involves computing gradients over the last few network layers only. This makes Guided Backprop the most expensive computational part. By replacing it with our method, accuracy should increase as per Table 2 while dramatically reducing both computational and memory overhead. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/7062e83599c46341a621b7cafdec1fb537ed354e7961d57954b254fa2fa716cc.jpg",
+        "image_caption": [
+            "Figure 6: These are examples of the first level saliency maps from SMOE Scale and Standard Deviation. It is common for both std and truncated normal entropy to flood in areas with modest texture. This may explain why difference scores for these two methods are at or below the performance of a random saliency map. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            102,
+            820,
+            454
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            571,
+            821,
+            599
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.3 SMOE SCALE IS THE MOST ROBUST MEASURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            630,
+            549,
+            643
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "SMOE Scale is the only metric without a failure case among all the statistics we tested. It is the only static that reliably scores in the top half of all the ones we tested. For Image Net and Places, it is the only one always in the top three. All statistics except for SMOE Scale and Shannon Entropy have at least one layer where they have a difference score at or below zero. This means they are as accurate as a random saliency map for at least one condition. SMOE Scale is the most robust statistic to use in terms of expected accuracy. The next highest scoring statistics, standard deviation and truncated normal entropy, are no better than a random on layer 1. Figure 6 shows why this may be. It is important to note that layer 1 contains the finest pixel details and should be expected to be important in rendering visual detail in the final combined saliency map. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            782
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            815,
+            318,
+            832
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have created a method of XAI saliency which is extremely efficent and is quantitatively comparable or better than several popular methods. It can also be used to create a saliency map with interpretability of individual scale layers. Future work includes creating a class specific activation map and expanding it to non-DNN architectures. We are currently testing our class activation map integration Fast-CAM and will introduce it in a future work. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chun-Hao Chang, Elliot Creager, Anna Goldenberg, and David Duvenaud. Explaining image classifiers by adaptive dropout and generative in-filling. In ICLR, 2018. ",
+        "bbox": [
+            173,
+            126,
+            821,
+            154
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aditya Chattopadhyay, Anirban Sarkar, Prantik Howlader, and Vineeth N Balasubramanian. Grad$\\mathrm { c a m + + }$ : Improved visual explanations for deep convolutional networks. In WACV, 2018. ",
+        "bbox": [
+            174,
+            161,
+            821,
+            190
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "S. C. Choi and R. Wette. Maximum likelihood estimation of the parameters of the gamma distribution and their bias. Technometrics, 11:683690, 1969. ",
+        "bbox": [
+            174,
+            198,
+            820,
+            227
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Piotr Dabkowski and Yarin Gal. Real time image saliency for black box classifiers. In NIPS, 2017. ",
+        "bbox": [
+            171,
+            234,
+            820,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "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 CVPR, 2009. ",
+        "bbox": [
+            174,
+            257,
+            820,
+            286
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ruth Fong and Andrea Vedaldi. Interpretable explanation of black boxes by meaningful perturbation. In ICCV, 2017. ",
+        "bbox": [
+            173,
+            294,
+            823,
+            323
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In arXiv:1512.03385, 2015. ",
+        "bbox": [
+            174,
+            330,
+            821,
+            359
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sara Hooker, Dumitru Erhan, Pieter-Jan Kindermans, and Been Kim. Evaluating feature importance estimates. In ICML workshop on Human Interpretability in Machine Learning, 2018. ",
+        "bbox": [
+            173,
+            367,
+            823,
+            396
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Kilian Q. Weinberger, and Laurens van der Maaten. Densely connected convolutional networks. In CVPR, 2017. ",
+        "bbox": [
+            174,
+            404,
+            823,
+            433
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015. ",
+        "bbox": [
+            174,
+            440,
+            823,
+            469
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Laurent Itti and Christof Koch. Computational modelling of visual attention. Nature Neuroscience, 2:194203, 2001. ",
+        "bbox": [
+            173,
+            477,
+            823,
+            506
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Laurent Itti, Ernst Niebur, and Christof Koch. A model of saliency-based visual attention for rapid scene analysis. IEEE Transactions on Pattern Analysis & Machine Intelligence, 20:1254–1259, 1998. ",
+        "bbox": [
+            176,
+            512,
+            823,
+            554
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jongheon Jeong and Jinwoo Shin. Training cnns with selective allocation of channels. In ICML, 2019. ",
+        "bbox": [
+            173,
+            563,
+            823,
+            592
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "George H. Joblove and Donald Greenberg. Color spaces for computer graphics. Computer Graphics, 12:20–25, 1978. ",
+        "bbox": [
+            174,
+            599,
+            823,
+            628
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. ImageNet classification with deep convolutional neural networks. In NIPS, 2013. ",
+        "bbox": [
+            174,
+            636,
+            823,
+            665
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "T Nathan Mundhenk, Goran Konjevod, Wesam A Sakla, and Kofi Boakye. A large contextual dataset for classification, detection and counting of cars with deep learning. In ECCV, 2016. ",
+        "bbox": [
+            174,
+            672,
+            823,
+            702
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vinod Nair and Geoffrey E. Hinton. Rectified linear units improve restricted boltzmann machines. In ICML, 2010. ",
+        "bbox": [
+            173,
+            708,
+            820,
+            738
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Omeiza, Skyler Speakman, Celia Cintas, and Komminist Weldemariam. Smooth gradcam++: An enhanced inference level visualization technique for deep convolutional neural network models. In arXiv:1908.01224, 2019. ",
+        "bbox": [
+            173,
+            744,
+            821,
+            787
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Badri N Patro, Mayank Lunayach, Shivansh Patel, and Vinay P. Namboodiri. U-cam: Visual explanation using uncertanty based class activation maps. In ICCV, 2019. ",
+        "bbox": [
+            171,
+            795,
+            821,
+            825
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wojciech Samek, Alexander Binder, Gregoire Montavon, Sebastian Lapuschkin, and Klaus-Robert ´ Muller. Evaluating the visualization of what a deep neural network has learned. ¨ IEEE Transactions on Neural Networks and Learning Systems, 28:2660–2673, 2017. ",
+        "bbox": [
+            176,
+            832,
+            823,
+            875
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ramprasaath R. Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruv Batra. Grad-cam: Visual explanations from deep networks via gradient-based localization. In ICCV, 2017. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. In arXiv:1312.6034, 2014. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            169
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel Smilkov, Nikhil Thorat, Been Kim, Fernanda Vigas, and Martin Wattenberg. Smoothgrad: removing noise by adding noise. In arXiv:1706.03825, 2017. ",
+        "bbox": [
+            173,
+            176,
+            821,
+            205
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmille. Striving for simplicity: The all convolutional net. In ICLR Workshop, 2015. ",
+        "bbox": [
+            171,
+            214,
+            823,
+            242
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. In ICML, 2017. ",
+        "bbox": [
+            174,
+            251,
+            823,
+            280
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Naftali Tishby, Fernando C. Pereira, and William Bialek. The information bottleneck method, 2000. ",
+        "bbox": [
+            174,
+            287,
+            823,
+            303
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Peter Welinder, Steve Branson, Takeshi Mita, Catherine Wah, Florian Schroff, Serge Belongie, and Pietro Perona. Caltech-UCSD Birds 200. Technical Report CNS-TR-2010-001, California Institute of Technology, 2010. ",
+        "bbox": [
+            173,
+            311,
+            821,
+            353
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Linjie Yang, Ping Luo, Chen Change Loy, and Xiaoou Tang. A large-scale car dataset for finegrained categorization and verification. In CVPR, 2015. ",
+        "bbox": [
+            173,
+            361,
+            823,
+            390
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthew D. Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In ECCV, 2014. ",
+        "bbox": [
+            174,
+            398,
+            823,
+            428
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bolei Zhou, Agata Lapedriza Garcia, Jianxiong Xiao, Antonio Torralba, and Aude Oliva. Learning deep features for scene recognition using places database. In NIPS, 2014. ",
+        "bbox": [
+            173,
+            435,
+            823,
+            464
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            299,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 DERIVATION OF SMOE SCALE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            132,
+            433,
+            147
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The maximum likelihood estimator of scale in the Gamma probability distribution is given as: ",
+        "bbox": [
+            169,
+            157,
+            787,
+            174
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/611b17d1653e4fe993f858dfd83be5abee9b7e92e759569aa14e6d70dbe26a6d.jpg",
+        "text": "$$\n{ \\hat { \\theta } } = { \\frac { 1 } { k n } } \\sum _ { i = 1 } ^ { n } x _ { i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            449,
+            179,
+            550,
+            220
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "This requires the additional iterative estimation of the shape parameter $k$ starting with an estimate $s$ ",
+        "bbox": [
+            174,
+            227,
+            823,
+            242
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8225e05371a08b67f7a6e8897ba8ba0633b4bfed462e5b6ca3e2b04aaf0851f5.jpg",
+        "text": "$$\ns = \\ln \\left( { \\frac { 1 } { n } } \\sum _ { i = 1 } ^ { n } x _ { i } \\right) - { \\frac { 1 } { n } } \\sum _ { i = 1 } ^ { n } \\ln ( x _ { i } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            247,
+            617,
+            291
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Then we get to within $1 . 5 \\%$ of the correct answer via: ",
+        "bbox": [
+            173,
+            296,
+            527,
+            311
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2130e9a7e42afd25872f6ce39e9ee2a5e1292f09130286ccded95a138ff6956e.jpg",
+        "text": "$$\nk \\approx \\frac { 3 - s + \\sqrt { ( s - 3 ) ^ { 2 } + 2 4 s } } { 1 2 s }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            318,
+            604,
+            352
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Then we use the Newton-Ralphson update to finish: ",
+        "bbox": [
+            174,
+            357,
+            514,
+            372
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/be6eee47fe0a2e8245160bad217d367a77c06689c455e1be367cb8c79eb6eed1.jpg",
+        "text": "$$\nk  k - \\frac { \\ln ( k ) - \\psi ( k ) - s } { \\frac { 1 } { k } - \\psi ^ { \\prime } ( k ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            377,
+            591,
+            415
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "But we can see application of Eqs 12 and 13 is monotonic. This is also apparent from the example which we can see in Figure 7. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            449
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/20a109aa6c4b2c46a71c8484b1cd42dc4b33941c173d40a41105519f9b24960e.jpg",
+        "image_caption": [
+            "Figure 7: A plot of the resulting $k$ values from input $s$ values in the gamma probability distribution maximum likelihood estimation. It is monotonic and reciprocal. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            375,
+            465,
+            622,
+            588
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "$k$ is SMOE to $\\frac { 1 } { s }$ , so we rewrite Eq 10 with the reciprocal of $k$ and optionally use the more efficient $l o g _ { 2 }$ as: ",
+        "bbox": [
+            171,
+            643,
+            823,
+            671
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0fa761babfdebb26f016333b15140b10cf303ee8dc842a7f7eaacd62d5b7869f.jpg",
+        "text": "$$\n{ \\hat { \\theta } } _ { S M O E } = { \\frac { 1 } { n } } \\cdot \\sum _ { i = 1 } ^ { n } x _ { i } \\cdot \\left[ l o g _ { 2 } \\left( { \\frac { 1 } { n } } \\cdot \\sum _ { i = 1 } ^ { n } x _ { i } \\right) - { \\frac { 1 } { n } } \\cdot \\sum _ { i = 1 } ^ { n } l o g _ { 2 } \\left( x _ { i } \\right) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            670,
+            714,
+            713
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "This then simplifies to: ",
+        "bbox": [
+            174,
+            714,
+            326,
+            729
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/60415a4dc6bbe909d3f5207b3226f9e1d22c4eaedf25cbb602ff4ef74292d206.jpg",
+        "text": "$$\n{ \\hat { \\theta } } _ { S M O E } = { \\frac { 1 } { n } } \\cdot \\sum _ { i = 1 } ^ { n } \\mu \\cdot \\log _ { 2 } \\left( { \\frac { \\mu } { x _ { n } } } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            727,
+            612,
+            768
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We can see the results this gives with different kinds of data in Table 3 ",
+        "bbox": [
+            173,
+            770,
+            635,
+            786
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/355f258e801735d9316096a4dfce794bd02bcfeaad96be948823443c9c4b5cef.jpg",
+        "table_caption": [
+            "Table 3: Examples of SMOE Scale results given different data. This shows in particular when log variance and standard deviation give similar or diverging results. It is easier to see how SMOE Scale as a measure or variance is proportional to the mean. So, if we have lots of large values in an output, we also need them to exhibit more variance relative to the mean activation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"7\">Input Values</td><td></td><td>Mean</td><td>STD</td><td>SMOE Scale</td></tr><tr><td>0.5</td><td>1</td><td></td><td>0.5</td><td>1</td><td>0.5</td><td>1</td><td>0.5</td><td>1</td><td>0.75</td><td>0.25</td><td>0.064</td></tr><tr><td>1</td><td>2</td><td></td><td>1</td><td>2</td><td>1</td><td>2</td><td>1</td><td>2</td><td>1.5</td><td>0.5</td><td>0.127</td></tr><tr><td>2</td><td>4</td><td>.</td><td>2</td><td>4</td><td>2</td><td>4</td><td>2</td><td>4</td><td>3</td><td>1</td><td>0.255</td></tr><tr><td>1</td><td>2</td><td>…</td><td>1</td><td>2</td><td>1</td><td>2</td><td>1</td><td>2</td><td>1.5</td><td>0.5</td><td>0.127</td></tr><tr><td>2</td><td>3</td><td>.</td><td>2</td><td>3</td><td>2</td><td>3</td><td>2</td><td>3</td><td>2.5</td><td>0.5</td><td>0.074</td></tr><tr><td>2</td><td>4</td><td>.</td><td>2</td><td>4</td><td>2</td><td>4</td><td>2</td><td>4</td><td>3</td><td>1</td><td>0.255</td></tr><tr><td>0.6125</td><td>1.8375</td><td>…</td><td>0.6125</td><td>1.8375</td><td>0.6125</td><td>1.8375</td><td>0.6125</td><td>1.8375</td><td>1.225</td><td>0.6125</td><td>0.254</td></tr></table>",
+        "bbox": [
+            173,
+            492,
+            823,
+            602
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.2 MORE EXAMPLES OF KAR SALIENCY MASKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            537,
+            117
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/689b48f8ed5920e3d7b883963071abe025d9036d6200602046170013b35a1d58.jpg",
+        "image_caption": [
+            "Figure 8: These are the last mini-batch images in our GPU:0 buffer when running the ImageNet validation set. The top images are the original input images and the ones on the bottom are $10 \\%$ KAR images of the most salient pixels. These are images used when computing KAR scores. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            135,
+            787,
+            856
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/4fb6f38a1d785a042afaa1ae11357e80d8c1eaf69c8648d5051ec9340b417156.jpg",
+        "image_caption": [
+            "Figure 9: These are more examples of combined saliency maps using the same images that appear in Figure 8. These images are not alpha blending with the original. Above each image is the ground truth label, while the label the network gave it is below. This was auto-generated by our training scripts. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            131,
+            830,
+            637
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/e20d8b495f81143fecc49a5a79078af88846ae7447d0026a048a2a2dc5927b87.jpg",
+        "image_caption": [
+            "Figure 10: These are the same as Figure 9 except with the original image gray scaled and alpha blended at $2 5 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            236,
+            831,
+            744
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "A.4 MORE EXAMPLES OF LOVI SALIENCY MAPS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            531,
+            118
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/35239414fc28cea60719589da148b885a04daf51f64c15cfec181f4651c6e9df.jpg",
+        "image_caption": [
+            "Figure 11: These are more examples of visualizing multiple saliency maps using the same images that are in Figure 8. These images are not alpha blending with the original. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            131,
+            831,
+            638
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/b379c8b0f3b814b5e14edf9d54cef0694aab2d470c9744e98aa1d13a326928a3.jpg",
+        "image_caption": [
+            "Figure 12: These are the same as Figure 11 with the original image gray scaled and alpha blended at $2 5 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            237,
+            830,
+            744
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "A.5 COMPARING DIFFERENT EFFICIENT STATISTICS IN MORE DETAIL ",
+        "bbox": [
+            174,
+            103,
+            669,
+            118
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "This subsection shows the raw scores for each statistic over each dataset. ",
+        "bbox": [
+            179,
+            128,
+            648,
+            143
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "table",
+        "img_path": "images/73acd27d2d205b0a33163941c6cfab804cf386eeb1309e40d338ae8ee1c0eb40.jpg",
+        "table_caption": [
+            "Table 4: KAR and ROAR results per dataset. This is a more detailed version of Table 1 and Figure 4. The differing effects of the distribution of data in the three sets seems to manifest itself in the L5 scores whereby the more concentrated the information is spatially, the better the ROAR/L5 score seems to be. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"5\">KAR Kept Percent</td><td colspan=\"5\">ROAR Removed Percent</td></tr><tr><td>Method</td><td>L1</td><td>L2</td><td>L3</td><td>L4</td><td>L5</td><td>L1</td><td>L2</td><td>L3</td><td>L4</td><td>L5</td></tr><tr><td colspan=\"9\">ImageNet</td><td></td></tr><tr><td>Random</td><td>66.42</td><td>61.28</td><td>50.67</td><td>40.81</td><td>42.98</td><td>73.48</td><td>72.41</td><td>68.90</td><td>64.63</td><td>66.04</td></tr><tr><td>SMOE Scale</td><td>56.61</td><td>50.69</td><td>51.25</td><td>46.40</td><td>63.00</td><td>44.48</td><td>44.81</td><td>36.35</td><td>33.88</td><td>21.15</td></tr><tr><td>STD</td><td>51.84</td><td>50.73</td><td>50.72</td><td>46.16</td><td>62.82</td><td>45.78</td><td>42.74</td><td>36.17</td><td>34.41</td><td>22.88</td></tr><tr><td>Mean</td><td>53.21</td><td>40.34</td><td>50.88</td><td>46.85</td><td>62.56</td><td>52.66</td><td>64.10</td><td>37.85</td><td>34.15</td><td>19.19</td></tr><tr><td>Shannon Ent</td><td>55.43</td><td>45.69</td><td>50.89</td><td>47.17</td><td>61.18</td><td>44.74</td><td>51.38</td><td>38.73</td><td>35.78</td><td>18.07</td></tr><tr><td>Log Normal Mean</td><td>55.98</td><td>32.28</td><td>51.08</td><td>47.21</td><td>62.02</td><td>57.20</td><td>68.22</td><td>44.42</td><td>34.98</td><td>18.50</td></tr><tr><td>Log Normal ENT</td><td>53.01</td><td>42.52</td><td>51.13</td><td>46.85</td><td>62.26</td><td>47.92</td><td>62.64</td><td>38.73</td><td>34.50</td><td>18.91</td></tr><tr><td>Trunc Normal Mean</td><td>50.67</td><td>49.69</td><td>50.69</td><td>43.52</td><td>62.87</td><td>46.88</td><td>49.76</td><td>35.44</td><td>37.58</td><td>20.92</td></tr><tr><td>Trunc Normal Std</td><td>50.66</td><td>51.02</td><td>50.60</td><td>42.54</td><td>62.97</td><td>46.78</td><td>43.70</td><td>35.68</td><td>38.18</td><td>21.57</td></tr><tr><td>Trunc Normal Ent</td><td>50.84</td><td>50.62</td><td>50.57</td><td>43.63</td><td>62.97</td><td>46.92</td><td>45.48</td><td>35.56</td><td>37.64</td><td>21.25</td></tr><tr><td>Best</td><td>56.61</td><td>51.02</td><td>51.25</td><td>47.21</td><td>63.00</td><td>44.48</td><td>42.74</td><td>35.44</td><td>33.88</td><td>18.07</td></tr><tr><td>Worst</td><td>50.66</td><td>32.28</td><td>50.57</td><td>42.54</td><td>61.18</td><td>57.20</td><td>68.22</td><td>44.42</td><td>38.18</td><td>22.88</td></tr><tr><td colspan=\"9\">Places</td><td></td></tr><tr><td>Random</td><td>57.20</td><td>53.59</td><td>47.83</td><td>41.26</td><td>39.45</td><td>60.77</td><td>60.25</td><td>58.14</td><td>56.41</td><td>55.26</td></tr><tr><td>SMOE Scale</td><td>49.76</td><td>45.67</td><td>46.39</td><td>40.57</td><td>53.50</td><td>44.35</td><td>44.61</td><td>39.80</td><td>40.26</td><td>27.94</td></tr><tr><td>STD</td><td>47.15</td><td>44.75</td><td>46.28</td><td>39.41</td><td>53.53</td><td>46.41</td><td>43.69</td><td>39.28</td><td>41.38</td><td>29.12</td></tr><tr><td>Mean</td><td>47.93</td><td>40.38</td><td>45.94</td><td>41.10</td><td>52.33</td><td>50.66</td><td>56.58</td><td>41.26</td><td>39.90</td><td>27.38</td></tr><tr><td>Shannon Ent</td><td>48.80</td><td>43.20</td><td>45.92</td><td>41.31</td><td>50.62</td><td>41.97</td><td>49.28</td><td>42.93</td><td>39.98</td><td>27.06</td></tr><tr><td>Log Normal Mean</td><td>50.05</td><td>35.87</td><td>46.23</td><td>41.45</td><td>51.67</td><td>52.21</td><td>57.91</td><td>45.17</td><td>39.73</td><td>26.88</td></tr><tr><td>Log Normal ENT</td><td>47.77</td><td>41.41</td><td>46.02</td><td>41.39</td><td>52.25</td><td>48.96</td><td>56.34</td><td>41.91</td><td>39.68</td><td>27.00</td></tr><tr><td>Trunc Normal Mean</td><td>46.25</td><td>44.76</td><td>46.12</td><td>38.08</td><td>53.18</td><td>46.92</td><td>46.92</td><td>48.83</td><td>42.09</td><td>28.06</td></tr><tr><td>Trunc Normal Std</td><td>45.96</td><td>45.35</td><td>46.38</td><td>37.61</td><td>53.38</td><td>46.41</td><td>46.76</td><td>44.86</td><td>42.43</td><td>28.68</td></tr><tr><td>Trunc Normal Ent</td><td>46.06</td><td>45.01</td><td>46.38</td><td>37.57</td><td>53.15</td><td>46.67</td><td>46.67</td><td>38.85</td><td>42.09</td><td>28.11</td></tr><tr><td>Best</td><td>50.05</td><td>45.67</td><td>46.39</td><td>41.45</td><td>53.53</td><td>41.97</td><td>43.69</td><td>38.85</td><td>39.68</td><td>26.88</td></tr><tr><td>Worst</td><td>45.96</td><td>35.87</td><td>45.92</td><td>37.57</td><td>50.62</td><td>52.21</td><td>57.91</td><td>48.83</td><td>42.43</td><td>29.12</td></tr><tr><td colspan=\"9\">CowC</td><td></td><td></td></tr><tr><td>Random</td><td>65.05</td><td>57.43</td><td>52.30</td><td>64.31</td><td>65.55</td><td>77.38</td><td>75.44</td><td>71.11</td><td>78.25</td><td>77.32</td></tr><tr><td>SMOE Scale</td><td>64.19</td><td>63.02</td><td>71.05</td><td>62.87</td><td>80.65</td><td>45.16</td><td>44.09</td><td>43.97</td><td>62.78</td><td>59.49</td></tr><tr><td>STD</td><td>60.36</td><td>61.95</td><td>70.89</td><td>64.57</td><td>80.55</td><td>44.12</td><td>43.52</td><td>44.10</td><td>60.69</td><td>59.73</td></tr><tr><td>Mean</td><td>63.82</td><td>59.90</td><td>73.20</td><td>61.83</td><td>80.54</td><td>45.79</td><td>59.24</td><td>44.61</td><td>64.02</td><td>58.86</td></tr><tr><td>Shannon Ent</td><td>62.64</td><td>63.78</td><td>73.29</td><td>60.99</td><td>78.77</td><td>46.50</td><td>44.23</td><td>46.42</td><td>68.31</td><td>57.98</td></tr><tr><td>Log Normal Mean</td><td>66.37</td><td>46.05</td><td>72.89</td><td>60.21</td><td>80.38</td><td>48.98</td><td>71.02</td><td>46.69</td><td>67.19</td><td>58.16</td></tr><tr><td>Log Normal ENT</td><td>63.23</td><td>62.78</td><td>73.26</td><td>60.99</td><td>80.44</td><td>45.10</td><td>57.12</td><td>44.92</td><td>65.61</td><td>58.56</td></tr><tr><td>Trunc Normal Mean</td><td>60.00</td><td>63.35</td><td>72.08</td><td>65.62</td><td>80.54</td><td>42.98</td><td>44.44</td><td>44.15</td><td>61.60</td><td>59.45</td></tr><tr><td>Trunc Normal Std</td><td>59.52</td><td>63.74</td><td>71.58</td><td>65.58</td><td>80.54</td><td>42.76</td><td>43.45</td><td>43.98</td><td>62.07</td><td>59.81</td></tr><tr><td>Trunc Normal Ent</td><td>59.79</td><td>63.48</td><td>71.77</td><td>65.68</td><td>80.59</td><td>43.04</td><td>43.80</td><td>43.89</td><td>61.79 60.69</td><td>59.89 57.98</td></tr><tr><td>Best Worst</td><td>66.37 59.52</td><td>63.78 46.05</td><td>73.29 70.89</td><td>65.68 60.21</td><td>80.65 78.77</td><td>42.76 48.98</td><td>43.45 71.02</td><td>43.89 46.69</td></table>",
+        "bbox": [
+            173,
+            228,
+            825,
+            748
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "A.6 COMBINED KAR AND ROAR SCORES WITH MORE DETAIL ",
+        "bbox": [
+            174,
+            103,
+            622,
+            117
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "This subsection shows the raw scores for each ROAR and KAR mask. We also added the nonSmoothGrad methods so we can see how much of an improvement it makes. ",
+        "bbox": [
+            174,
+            128,
+            821,
+            157
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "table",
+        "img_path": "images/ea63d924a4fa65dcc3e8548b84f10d91c5fb5e9fea71231a3447ab90679d1180.jpg",
+        "table_caption": [
+            "Table 5: Combined KAR and ROAR scores for several methods. This is a more detailed version of Table 2 and Figure 5. The top six rows show several popular methods with and without Squared SmoothGrad applied to give optimal results. These are taken from (Hooker et al., 2018). Prior Layer Weights means we applied layer weights based on the prior determined accuracy of the layer saliency map. We include our top three scoring methods. The SMOE Scale method outperforms the three baseline methods on KAR. It outperforms Guided Backprop and Integrated Gradients on ROAR as well as overall. The Gradient method is best overall, but as we discussed, it is much more expensive to compute. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"5\">KAR Kept Percent</td><td colspan=\"5\">ROAR Removed Percent</td></tr><tr><td>Method</td><td>10%</td><td>30%</td><td>50%</td><td>70%</td><td>90%</td><td>10%</td><td>30%</td><td>50%</td><td>70%</td><td>90%</td></tr><tr><td>Rand</td><td>63.53</td><td>67.06</td><td>69.13</td><td>71.02</td><td>72.65</td><td>72.65</td><td>71.02</td><td>69.13</td><td>67.06</td><td>63.53</td></tr><tr><td>Gradient</td><td>67.63</td><td>71.45</td><td>72.02</td><td>72.85</td><td>73.46</td><td>72.94</td><td>72.22</td><td>70.97</td><td>70.72</td><td>66.75</td></tr><tr><td>Guided Backprop</td><td>71.03</td><td>72.45</td><td>72.28</td><td>72.69</td><td>71.56</td><td>72.29</td><td>71.91</td><td>71.18</td><td>71.48</td><td>70.38</td></tr><tr><td>Integrated Grad.</td><td>70.38</td><td>72.51</td><td>72.66</td><td>72.88</td><td>73.32</td><td>73.17</td><td>72.72</td><td>72.03</td><td>71.68</td><td>68.20</td></tr><tr><td>Gradient -w- SmoothGrad Sq.</td><td>63.25</td><td>69.79</td><td>72.20</td><td>73.18</td><td>73.96</td><td>69.35</td><td>60.28</td><td>41.55</td><td>29.45</td><td>11.09</td></tr><tr><td>Guided Backprop -w- SmoothGrad Sq.</td><td>62.42</td><td>68.96</td><td>71.17</td><td>72.72</td><td>73.77</td><td>69.74</td><td>60.56</td><td>52.21</td><td>34.98</td><td>15.53</td></tr><tr><td>Integrated Grad.-w- SmoothGrad Sq.</td><td>67.55</td><td>68.96</td><td>72.24</td><td>73.09</td><td>73.80</td><td>70.76</td><td>65.71</td><td>58.34</td><td>43.71</td><td>29.41</td></tr><tr><td>SMOE Scale+ Prior Layer Weights</td><td>65.44</td><td>72.14</td><td>74.28</td><td>74.51</td><td>75.01</td><td>70.40</td><td>60.33</td><td>48.48</td><td>34.23</td><td>17.72</td></tr><tr><td>SMOE Scale+ Layer Weights [1...,5]</td><td>65.76</td><td>72.60</td><td>73.97</td><td>74.53</td><td>74.94</td><td>70.28</td><td>60.93</td><td>48.73</td><td>35.66</td><td>18.01</td></tr><tr><td>SMOE Scale + Layer Weights [1...,1]</td><td>66.13</td><td>72.28</td><td>73.72</td><td>74.52</td><td>74.97</td><td>71.28</td><td>63.58</td><td>52.85</td><td>38.74</td><td>19.72</td></tr><tr><td>Normal Std + Prior L.Weights</td><td>65.48</td><td>72.17</td><td>73.93</td><td>74.62</td><td>74.67</td><td>69.98</td><td>60.39</td><td>48.75</td><td>34.63</td><td>18.13</td></tr><tr><td>Trunc Normal Ent + Prior L.Weights</td><td>65.45</td><td>72.38</td><td>74.10</td><td>74.40</td><td>74.75</td><td>69.85</td><td>60.08</td><td>48.05</td><td>34.32</td><td>18.37</td></tr></table>",
+        "bbox": [
+            173,
+            303,
+            825,
+            478
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "A.7 OPERATIONS COMPUTATION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            415,
+            117
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "table",
+        "img_path": "images/327b6754a8079faaa56de9787b3101a56709aded2ef3acb7004442a8013dbcf7.jpg",
+        "table_caption": [
+            "Table 6: FLOPs for each layer. This is the breakdown of FLOPs for each layer. Log and Error Function are counted as one operation in this example. SMOE Ops is how many operations it takes to compute the initial saliency map using the SMOE Scale statistic. Norm Ops is the number of operations needed to normalize the saliency map. Combine Ops is the number of ops needed to upsample and combine each saliency map. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"4\">Layer Dimensions</td><td colspan=\"3\">FLOPS</td></tr><tr><td>Layer</td><td>Channels</td><td>Size H</td><td>Size W</td><td> SMOE Ops</td><td>Norm Ops</td><td>Combine Ops</td></tr><tr><td>Layer 1</td><td>64</td><td>112</td><td>112</td><td>3223808</td><td>150528</td><td>225792</td></tr><tr><td>Layer 2</td><td>256</td><td>56</td><td>56</td><td>3214400</td><td>37632</td><td>338688</td></tr><tr><td>Layer 3</td><td>512</td><td>28</td><td>28</td><td>1606416</td><td>9408</td><td>338688</td></tr><tr><td>Layer 4</td><td>1024</td><td>14</td><td>14</td><td>803012</td><td>2352</td><td>338688</td></tr><tr><td>Layer 5</td><td>2048</td><td>7</td><td>7</td><td>401457</td><td>588</td><td>338688</td></tr><tr><td>Total</td><td></td><td></td><td></td><td>9249093</td><td>200508</td><td>1580544</td></tr></table>",
+        "bbox": [
+            173,
+            224,
+            825,
+            383
+        ],
+        "page_idx": 21
+    }
+]