Add files using upload-large-folder tool

parse/train/HJz6tiCqYm/HJz6tiCqYm.md

@@ -0,0 +1,341 @@
+# BENCHMARKING NEURAL NETWORK ROBUSTNESS TO COMMON CORRUPTIONS AND PERTURBATIONS
+
+Dan Hendrycks University of California, Berkeley hendrycks@berkeley.edu
+
+Thomas Dietterich Oregon State University tgd@oregonstate.edu
+
+# ABSTRACT
+
+In this paper we establish rigorous benchmarks for image classifier robustness. Our first benchmark, IMAGENET-C, standardizes and expands the corruption robustness topic, while showing which classifiers are preferable in safety-critical applications. Then we propose a new dataset called IMAGENET-P which enables researchers to benchmark a classifier’s robustness to common perturbations. Unlike recent robustness research, this benchmark evaluates performance on common corruptions and perturbations not worst-case adversarial perturbations. We find that there are negligible changes in relative corruption robustness from AlexNet classifiers to ResNet classifiers. Afterward we discover ways to enhance corruption and perturbation robustness. We even find that a bypassed adversarial defense provides substantial common perturbation robustness. Together our benchmarks may aid future work toward networks that robustly generalize.
+
+# 1 INTRODUCTION
+
+The human vision system is robust in ways that existing computer vision systems are not (Recht et al., 2018; Azulay & Weiss, 2018). Unlike current deep learning classifiers (Krizhevsky et al., 2012; He et al., 2015; Xie et al., 2016), the human vision system is not fooled by small changes in query images. Humans are also not confused by many forms of corruption such as snow, blur, pixelation, and novel combinations of these. Humans can even deal with abstract changes in structure and style. Achieving these kinds of robustness is an important goal for computer vision and machine learning. It is also essential for creating deep learning systems that can be deployed in safety-critical applications.
+
+Most work on robustness in deep learning methods for vision has focused on the important challenges of robustness to adversarial examples (Szegedy et al., 2014; Carlini & Wagner, 2017; 2016), unknown unknowns (Hendrycks et al., 2019; Hendrycks & Gimpel, 2017b; Liu et al., 2018), and model or data poisoning (Steinhardt et al., 2017; Hendrycks et al., 2018). In contrast, we develop and validate datasets for two other forms of robustness. Specifically, we introduce the IMAGETNET-C dataset for input corruption robustness and the IMAGENET-P dataset for input perturbation robustness.
+
+To create IMAGENET-C, we introduce a set of 75 common visual corruptions and apply them to the ImageNet object recognition challenge (Deng et al., 2009). We hope that this will serve as a general dataset for benchmarking robustness to image corruptions and prevent methodological problems such as moving goal posts and result cherry picking. We evaluate the performance of current deep learning systems and show that there is wide room for improvement on IMAGENET-C. We also introduce a total of three methods and architectures that improve corruption robustness without losing accuracy.
+
+To create IMAGENET-P, we introduce a set of perturbed or subtly differing ImageNet images. Using metrics we propose, we measure the stability of the network’s predictions on these perturbed images. Although these perturbations are not chosen by an adversary, currently existing networks exhibit surprising instability on common perturbations. Then we then demonstrate that approaches which enhance corruption robustness can also improve perturbation robustness. For example, some recent architectures can greatly improve both types of robustness. More, we show that the Adversarial Logit Pairing $\ell _ { \infty }$ adversarial example defense can yield substantial robustness gains on diverse and common perturbations. By defining and benchmarking perturbation and corruption robustness, we facilitate research that can be overcome by future networks which do not rely on spurious correlations or cues inessential to the object’s class.
+
+# 2 RELATED WORK
+
+Adversarial Examples. An adversarial image is a clean image perturbed by a small distortion carefully crafted to confuse a classifier. These deceptive distortions can occasionally fool black-box classifiers (Kurakin et al., 2017). Algorithms have been developed that search for the smallest additive distortions in RGB space that are sufficient to confuse a classifier (Carlini et al., 2017). Thus adversarial distortions serve as type of worst-case analysis for network robustness. Its popularity has often led “adversarial robustness” to become interchangeable with “robustness” in the literature (Bastani et al., 2016; Rauber et al., 2017). In the literature, new defenses (Lu et al., 2017; Papernot et al., 2017; Metzen et al., 2017; Hendrycks & Gimpel, 2017a) often quickly succumb to new attacks (Evtimov et al., 2017; Carlini & Wagner, 2017; 2016), with some exceptions for perturbations on small images (Schott et al., 2018; Madry et al., 2018). For some simple datasets, the existence of any classification error ensures the existence of adversarial perturbations of size $\mathcal { O } ( d ^ { - 1 / 2 } )$ , $d$ the input dimensionality (Gilmer et al., 2018b). For some simple models, adversarial robustness requires an increase in the training set size that is polynomial in $d$ (Schmidt et al., 2018). Gilmer et al. (2018a) suggest modifying the problem of adversarial robustness itself for increased real-world applicability.
+
+Robustness in Speech. Speech recognition research emphasizes robustness to common corruptions rather than worst-case, adversarial corruptions (Li et al., 2014; Mitra et al., 2017). Common acoustic corruptions (e.g., street noise, background chatter, wind) receive greater focus than adversarial audio, because common corruptions are ever-present and unsolved. There are several popular datasets containing noisy test audio (Hirsch & Pearce, 2000; Hirsch, 2007). Robustness in noisy environments requires robust architectures, and some research finds convolutional networks more robust than fully connected networks (Abdel-Hamid et al., 2013). Additional robustness has been achieved through pre-processing techniques such as standardizing the statistics of the input (Liu et al., 1993; Torre et al., 2005; Harvilla & Stern, 2012; Kim & Stern, 2016).
+
+ConvNet Fragility Studies. Several studies demonstrate the fragility of convolutional networks on simple corruptions. For example, Hosseini et al. (2017) apply impulse noise to break Google’s Cloud Vision API. Using Gaussian noise and blur, Dodge & Karam (2017b) demonstrate the superior robustness of human vision to convolutional networks, even after networks are fine-tuned on Gaussian noise or blur. Geirhos et al. (2017) compare networks to humans on noisy and elastically deformed images. They find that fine-tuning on specific corruptions does not generalize and that classification error patterns underlying network and human predictions are not similar. Temel et al. (2017; 2018); Temel & AlRegib (2018) propose different corrupted datasets for object and traffic sign recognition.
+
+Robustness Enhancements. In an effort to reduce classifier fragility, Vasiljevic et al. (2016) finetune on blurred images. They find it is not enough to fine-tune on one type of blur to generalize to other blurs. Furthermore, fine-tuning on several blurs can marginally decrease performance. Zheng et al. (2016) also find that fine-tuning on noisy images can cause underfitting, so they encourage the noisy image softmax distribution to match the clean image softmax. Dodge & Karam (2017a) address underfitting via a mixture of corruption-specific experts assuming corruptions are known beforehand.
+
+# 3 CORRUPTIONS, PERTURBATIONS, AND ADVERSARIAL PERTURBATIONS
+
+We now define corruption and perturbation robustness and distinguish them from adversarial perturbation robustness. To begin, we consider a classifier $f : \mathcal { X }  \mathcal { Y }$ trained on samples from distribution $\mathcal { D }$ , a set of corruption functions $C$ , and a set of perturbation functions $\mathcal { E }$ . We let $\mathbb { P } _ { C } ( c ) , \mathbb { P } _ { \mathcal { E } } ( \varepsilon )$ approximate the real-world frequency of these corruptions and perturbations. Most classifiers are judged by their accuracy on test queries drawn from $\mathcal { D }$ , i.e., $\mathbb { P } _ { ( x , y ) \sim \mathcal { D } } ( f ( x ) = y )$ . Yet in a vast range of cases the classifier is tasked with classifying low-quality or corrupted inputs. In view of this, we suggest also computing the classifier’s corruption robustness $\mathbb { E } _ { c \sim C } [ \mathbb { P } _ { ( { \boldsymbol x } , { \boldsymbol y } ) \sim \mathcal { D } } ( f ( c ( { \boldsymbol x } ) = { \boldsymbol y } ) ) ]$ . This contrasts with a popular notion of adversarial robustness, often formulated $\operatorname* { m i n } _ { \| \delta \| _ { p } < b } \mathbb { P } _ { ( { \boldsymbol { x } } , { \boldsymbol { y } } ) \sim \mathcal { D } } ( f ( { \boldsymbol { x } } + { \boldsymbol { \delta } } ) = { \boldsymbol { y } } )$ , $b$ a small budget. Thus, corruption robustness measures the classifier’s average-case performance on corruptions $C$ , while adversarial robustness measures the worst-case performance on small, additive, classifier-tailored perturbations.
+
+Average-case performance on small, general, classifier-agnostic perturbations motivates us to define perturbation robustness, namely $\mathbb { E } _ { \varepsilon \sim \varepsilon } [ \mathbb { P } _ { ( x , y ) \sim \mathcal { D } } ( f ( \varepsilon ( \bar { x ) } ) = f ( x ) ) ]$ ]. Consequently, in measuring perturbation robustness, we track the classifier’s prediction stability, reliability, or consistency in the face of minor input changes. Now in order to approximate $C , \mathcal { E }$ and these robustness measures, we designed a set of corruptions and perturbations which are frequently encountered in natural images. We will refer to these as “common” corruptions and perturbations. These common corruptions and perturbations are available in the form of IMAGENET-C and IMAGENET-P.
+
+![](images/660a2d4193294467ceea562bde8433a94f413c493acd8b5013f5737a8cf4af1f.jpg)  
+Figure 1: Our IMAGENET-C dataset consists of 15 types of algorithmically generated corruptions from noise, blur, weather, and digital categories. Each type of corruption has five levels of severity, resulting in 75 distinct corruptions. See different severity levels in Appendix B.
+
+# 4 THE IMAGENET-C AND IMAGENET-P ROBUSTNESS BENCHMARKS
+
+# 4.1 THE DATA OF IMAGENET-C AND IMAGENET-P
+
+IMAGENET-C Design. The IMAGENET-C benchmark consists of 15 diverse corruption types applied to validation images of ImageNet. The corruptions are drawn from four main categories— noise, blur, weather, and digital—as shown in Figure 1. Research that improves performance on this benchmark should indicate general robustness gains, as the corruptions are diverse and numerous. Each corruption type has five levels of severity since corruptions can manifest themselves at varying intensities. Appendix A gives an example of the five different severity levels for impulse noise. Real-world corruptions also have variation even at a fixed intensity. To simulate these, we introduce variation for each corruption when possible. For example, each fog cloud is unique to each image. These algorithmically generated corruptions are applied to the ImageNet (Deng et al., 2009) validation images to produce our corruption robustness dataset IMAGENET-C. The dataset can be downloaded or re-created by visiting https://github.com/hendrycks/robustness. IMAGENET-C images are saved as lightly compressed JPEGs; this implies an image corrupted by Gaussian noise is also slightly corrupted by JPEG compression. Our benchmark tests networks with IMAGENET-C images, but networks should not be trained on these images. Networks should be trained on datasets such as ImageNet and not be trained on IMAGENET-C corruptions. To enable further experimentation, we designed an extra corruption type for each corruption category (Appendix B), and we provide CIFAR-10-C, TINY IMAGENET-C, IMAGENET $6 4 \times 6 4 – \mathrm { C }$ , and Inception-sized editions. Overall, the IMAGENET-C dataset consists of 75 corruptions, all applied to ImageNet validation images for testing a pre-existing network.
+
+Common Corruptions. The first corruption type is Gaussian noise. This corruption can appear in low-lighting conditions. Shot noise, also called Poisson noise, is electronic noise caused by the discrete nature of light itself. Impulse noise is a color analogue of salt-and-pepper noise and can be caused by bit errors. Defocus blur occurs when an image is out of focus. Frosted Glass Blur appears with “frosted glass” windows or panels. Motion blur appears when a camera is moving quickly. Zoom blur occurs when a camera moves toward an object rapidly. Snow is a visually obstructive form of precipitation. Frost forms when lenses or windows are coated with ice crystals. Fog shrouds objects and is rendered with the diamond-square algorithm. Brightness varies with daylight intensity. Contrast can be high or low depending on lighting conditions and the photographed object’s color. Elastic transformations stretch or contract small image regions. Pixelation occurs when upsampling a lowresolution image. JPEG is a lossy image compression format which introduces compression artifacts.
+
+IMAGENET-P Design. The second benchmark that we propose tests the classifier’s perturbation robustness. Models lacking in perturbation robustness produce erratic predictions which undermines user trust. When perturbations have a high propensity to change the model’s response, then perturbations could also misdirect or destabilize iterative image optimization procedures appearing in style transfer (Gatys et al., 2016), decision explanations (Fong & Vedaldi, 2017), feature visualization (Olah et al., 2017), and so on. Like IMAGENET-C, IMAGENETP consists of noise, blur, weather, and digital distortions. Also as before, the dataset has validation perturbations; has difficulty levels; has CIFAR-10, Tiny ImageNet, ImageNet $6 4 \times 6 4$ standard, and Inception-sized editions; and has been designed for benchmarking not training networks. IMAGENET-P departs from IMAGENET-C by having perturbation sequences generated from each ImageNet validation image; examples are in Figure 2. Each sequence contains more than 30 frames, so we counteract an increase in dataset size and evaluation time by using only 10 common perturbations.
+
+Common Perturbations. Appearing more subtly than the corruption from IMAGENET-C, the Gaussian noise perturbation sequence begins with the clean ImageNet image. The following frames in the sequence consist in the same image but with minute Gaussian noise perturbations applied. This sequence design is similar for the shot noise perturbation sequence. However the remaining perturbation sequences have temporality, so that each frame of the sequence is a perturbation of the previous frame. Since each perturbation is small, repeated application of a perturbation does not bring the image far out-of-distribution. For example, an IMAGENET-P translation perturbation sequence shows a clean ImageNet image sliding from right to left one pixel at a time; with each perturbation of the pixel locations, the resulting frame is still of high quality. The perturbation sequences with temporality are created with motion blur, zoom blur, snow, brightness, translate, rotate, tilt (viewpoint variation through minor 3D rotations), and scale perturbations.
+
+![](images/5eadeb9445cbd05f3b967e8a0ac289ebaec911114710a56d07a556ff265efbd2.jpg)  
+Figure 2: Example frames from the beginning $( T = 0$ ) to end $( T = 3 0$ ) of some Tilt and Brightness perturbation sequences.
+
+# 4.2 IMAGENET-C AND IMAGENET-P METRICS AND SETUP
+
+IMAGENET-C Metrics. Common corruptions such as Gaussian noise can be benign or destructive depending on their severity. In order to comprehensively evaluate a classifier’s robustness to a given type of corruption, we score the classifier’s performance across five corruption severity levels and aggregate these scores. The first evaluation step is to take a trained classifier f, which has not been $E _ { \mathrm { { c l e a n } } } ^ { f }$ d on IMAGENET-C, and compute the clean dataset top-1 error. The second step is to test the classifier on each corruption type $c$ te. Denote this error raat each level of severity $s$ $( 1 \le s \le 5 )$ ). This top-1 error is written $E _ { s , c } ^ { f }$ . Before we aggregate the classifier’s performance across severities and corruption types, we will make error rates more comparable since different corruptions pose different levels of difficulty. For example, fog corruptions often obscure an object’s class more than brightness corruptions. We adjust for the varying difficulties by dividing by AlexNet’s errors, but any baseline will do (even a baseline with $100 \%$ error rates, corresponding to an average of CEs). This standardized aggregate performance measure is the Corruption Error, computed with the formula
+
+$$
+\mathrm { { C E } } _ { c } ^ { f } = \biggl ( \sum _ { s = 1 } ^ { 5 } E _ { s , c } ^ { f } \biggr ) \bigg / \biggl ( \sum _ { s = 1 } ^ { 5 } E _ { s , c } ^ { \mathrm { A l e x N e t } } \biggr ) .
+$$
+
+$\mathrm { C E } _ { \mathrm { G a u s s i a n N o i s e } } ^ { f }$ , $\mathbf { C E } _ { \mathrm { { S h o t N o i s e } } } ^ { f } , \dotsc , \mathbf { C E } _ { \mathrm { { J P E G } } } ^ { f }$ ion robustness by averag. This results in the mean $C E$ theor $m C E$ orruption Error valuesfor short.
+
+We now introduce a more nuanced corruption robustness measure. Consider a classifier that withstands most corruptions, so that the gap between the $\mathrm { m C E }$ and the clean data error is minuscule. Contrast this with a classifier with a low clean error rate which has its error rate spike in the presence of corruptions; this corresponds to a large gap between the mCE and clean data error. It is possible that the former classifier has a larger mCE than the latter, despite the former degrading more gracefully in the presence of corruptions. The amount that the classifier declines on corrupted inputs is given by the formula Relative $\begin{array} { r } { \mathbf { \bar { C } E } _ { c } ^ { f } = \big ( \sum _ { s = 1 } ^ { 5 } E _ { s , c } ^ { f } - E _ { \mathrm { c l e a n } } ^ { f } \big ) \big / \big ( \sum _ { s = 1 } ^ { 5 } E _ { s , c } ^ { \mathrm { A l e x N e t } } - E _ { \mathrm { c l e a n } } ^ { \mathrm { A l e x N e t } } \big ) } \end{array}$ . Averaging these 15 Relative Corruption Errors results in the Relative $m C E$ . This measures the relative robustness or the performance degradation when encountering corruptions.
+
+IMAGENET-P Metrics. A straightforward approach to estimate $\mathbb { E } _ { \varepsilon \sim \mathcal { E } } [ \mathbb { P } _ { ( x , y ) \sim \mathcal { D } } ( f ( \varepsilon ( x ) ) \neq f ( x ) ) ]$ falls into place when using IMAGENET-P perturbation sequences. Let us denote $m$ perturbation sequences with $\mathcal { S } = \{ \left( x _ { 1 } ^ { ( i ) } , x _ { 2 } ^ { ( i ) } , \ldots , x _ { n } ^ { ( i ) } \right) \bar  \} _ { i = 1 } ^ { m }$ where each sequence is made with perturbation $p$ . The “Flip Probability” of network $f : \mathcal { X }  \bar { \{ 1 , 2 , \dots , 1 0 0 0 \} }$ on perturbation sequences $s$ is
+
+$$
+\mathrm { F P } _ { p } ^ { f } = \frac { 1 } { m ( n - 1 ) } \sum _ { i = 1 } ^ { m } \sum _ { j = 2 } ^ { n } \mathbb { 1 } \left( f \big ( x _ { j } ^ { ( i ) } \big ) \neq f \big ( x _ { j - 1 } ^ { ( i ) } \big ) \right) = \mathbb { P } _ { x \sim { \mathscr { S } } } ( f ( x _ { j } ) \neq f ( x _ { j - 1 } ) ) .
+$$
+
+For noise perturbation sequences, which are not temporally related, $x _ { 1 } ^ { ( i ) }$ is clean and $\boldsymbol { x } _ { j } ^ { ( i ) }$ $( j ~ > ~ 1 )$ are perturbed images of $x _ { 1 } ^ { ( i ) }$ . We can recast the FP formula for noise sequences as $\begin{array} { r } { \mathrm { F P } _ { p } ^ { f } = \frac { 1 } { m ( n - 1 ) } \sum _ { i = 1 } ^ { m } \sum _ { j = 2 } ^ { n } \mathbb { I } \big ( f \big ( x _ { j } ^ { ( i ) } \big ) \ne f \big ( x _ { 1 } ^ { ( i ) } \big ) \big ) = \mathbb { P } _ { x \sim S } ( f ( x _ { j } ) \ne f ( x _ { 1 } ) \mid j > 1 ) } \end{array}$ . As was done with the Corruption Error formula, we now standardize the Flip Probability by the sequence’s difficulty for increased commensurability. We have, then, the “Flip Rate” FRfp = FPfp /FPAlexNetp . Averaging the Flip Rate across all perturbations yields the mean Flip Rate or $m F R$ . We do not define a “relative mFR” since we did not find any natural formulation, nor do we directly use predicted class probabilities due to differences in model calibration (Guo et al., 2017).
+
+When the top-5 predictions are relevant, perturbations should not cause the list of top-5 predictions to shuffle chaotically, nor should classes sporadically vanish from the list. We penalize top-5 inconsistency of this kind with a different measure. Let the ranked predictions of network $f$ on $x$ be the permutation $\tau ( x ) \in S _ { 1 0 0 0 }$ . Concretely, if “Toucan” has the label 97 in the output space and “Pelican” has the label 145, and if $f$ on $x$ predicts “Toucan” and “Pelican” to be the most and second-most likely classes, respectively, then $\tau ( x ) ( 9 7 ) = 1$ and $\tau ( x ) ( 1 4 4 ) = 2$ . These permutations contain the top-5 predictions, so we use permutations to compare top-5 lists. To do this, we define
+
+$$
+d ( \tau ( x ) , \tau ( x ^ { \prime } ) ) = \sum _ { i = 1 } ^ { 5 } \sum _ { j = \operatorname* { m i n } \{ i , \sigma ( i ) \} + 1 } ^ { \operatorname* { m a x } \{ i , \sigma ( i ) \} } \mathbb { 1 } ( 1 \leq j - 1 \leq 5 )
+$$
+
+where $\sigma = ( \tau ( x ) ) ^ { - 1 } \tau ( x ^ { \prime } )$ . If the top-5 predictions represented within $\tau ( x )$ and $\tau ( x ^ { \prime } )$ are identical, then $d ( \tau ( x ) , \tau ( x ^ { \prime } ) ) = 0$ . More examples of $d$ on several permutations are in Appendix C. Comparing the top-5 predictions across entire perturbation sequences results in the unstandardized Top-5 Distance $\begin{array} { r } { \mathfrak { u } \mathrm { T } 5 \mathbf { D } _ { p } ^ { f } = \frac { 1 } { m ( n - 1 ) } \sum _ { i = 1 } ^ { m } \sum _ { j = 2 } ^ { n } d ( \tau ( x _ { j } ) , \tau ( x _ { j - 1 } ) ) = \mathbb { P } _ { x \sim \mathcal { S } } ( d ( \tau ( x _ { j } ) , \tau ( x _ { j - 1 } ) ) , \tau ( x _ { j - 1 } ) ) . } \end{array}$ . For noise perturbation sequences, we have $\mathsf { u T 5 D } _ { p } ^ { f } \ : = \ : \mathbb { E } _ { x \sim { \cal S } } [ d ( \tau ( x _ { j } ) , \tau ( x _ { 1 } ) ) \mid j$ > 1]. Once the uT5D is standardized, we have the Top-5 Distance $\mathrm { T } 5 \mathrm { D } _ { p } ^ { f } \ = \ \mathrm { u T } 5 \mathrm { D } _ { p } ^ { f } / \mathrm { u T } 5 \mathrm { D } _ { p } ^ { \mathrm { A l e x N e t } }$ . The T5Ds averaged together correspond to the mean Top-5 Distance or $m T 5 D$ .
+
+Preserving Metric Validity. The goal of IMAGENET-C and IMAGENET-P is to evaluate the robustness of machine learning algorithms on novel corruptions and perturbations. Humans are able to generalize to novel corruptions quite well; for example, they can easily deal with new Instagram filters. Likewise for perturbations; humans relaxing in front of an undulating ocean do not give turbulent accounts of the scenery before them. Hence, we propose the following protocol. The image recognition network should be trained on the ImageNet training set and on whatever other training sets the investigator wishes to include. Researchers should clearly state whether they trained on these corruptions or perturbations; however, this training strategy is discouraged (see Section 2). We allow training with other distortions (e.g., uniform noise) and standard data augmentation (i.e., cropping, mirroring), even though cropping overlaps with translations. Then the resulting trained model should be evaluated on IMAGENET-C or IMAGENET-P using the above metrics. Optionally, researchers can test with the separate set of validation corruptions and perturbations we provide for IMAGENET-C and IMAGENET-P.
+
+![](images/0ae51795bbaa947988dcc03ee415e7c0850b08ccc5c4917ef642f8723b53f965.jpg)  
+Figure 3: Robustness (mCE) and Relative mCE IMAGENET-C values. Relative mCE values suggest robustness in itself declined from AlexNet to ResNet. “BN” abbreviates Batch Normalization.
+
+![](images/6f5e6c2c82e059e09dc82a275eba0929fb7fcf91d2eb6271011fc6dbb29ea191.jpg)  
+Figure 4: Perturbation robustness of various architectures as measured by the mT5D on IMAGENET-P. Observe that corruption and perturbation robustness track distinct concepts.
+
+<table><tr><td></td><td></td><td></td><td></td><td>Noise</td><td></td><td></td><td>Blur</td><td></td><td></td><td></td><td>Weather</td><td></td><td></td><td></td><td>Digital</td><td></td></tr><tr><td>Network</td><td>Error</td><td>mCE</td><td>Gauss.Shot Impulse</td><td></td><td></td><td></td><td>Defocus Glass Motion Zoom</td><td></td><td></td><td>SnowFrostFogBright</td><td></td><td></td><td></td><td></td><td>Contrast Elastic Pixel JPEG</td><td></td></tr><tr><td>AlexNet</td><td>43.5</td><td>100.0</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>1001 100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td></tr><tr><td>SqueezeNet</td><td>41.8</td><td>104.4</td><td>107</td><td>106</td><td>105</td><td>100</td><td>103</td><td>101</td><td>100</td><td>101</td><td>103 97</td><td>97</td><td></td><td>98</td><td>106 109</td><td>134</td></tr><tr><td>VGG-11</td><td>31.0</td><td>93.5</td><td>97</td><td>97</td><td>100</td><td>92</td><td>99</td><td>93</td><td>91</td><td>92</td><td>91 84</td><td>75</td><td>86</td><td>97</td><td>107</td><td>100</td></tr><tr><td>VGG-19</td><td>27.6</td><td>88.9</td><td>89</td><td>91</td><td>95</td><td>89</td><td>98</td><td>90</td><td>90</td><td>89</td><td>86 75</td><td>68</td><td>80</td><td>97</td><td>102</td><td>94</td></tr><tr><td>VGG-19+BN</td><td>25.8</td><td>81.6</td><td>82</td><td>83</td><td>88</td><td>82</td><td>94</td><td>84</td><td>86</td><td>80</td><td>78 69</td><td>61</td><td>74</td><td>94</td><td>85</td><td>83</td></tr><tr><td>ResNet-18</td><td>30.2</td><td>84.7</td><td>87</td><td>88</td><td>91</td><td>84</td><td>91</td><td>87</td><td>89</td><td>86</td><td>84 78</td><td>69</td><td>78</td><td>90</td><td>80</td><td>85</td></tr><tr><td>ResNet-50</td><td>23.9</td><td>76.7</td><td>80</td><td>82</td><td>83</td><td>75</td><td>89</td><td>78</td><td>80</td><td>78</td><td>75 66</td><td>57</td><td>71</td><td>85</td><td>77</td><td>77</td></tr></table>
+
+Table 1: Clean Error, mCE, and Corruption Error values of different corruptions and architectures on IMAGENET-C. The mCE value is the mean Corruption Error of the corruptions in Noise, Blur, Weather, and Digital columns. Models are trained only on clean ImageNet images.
+
+# 5 EXPERIMENTS
+
+# 5.1 ARCHITECTURE ROBUSTNESS
+
+How robust are current methods, and has progress in computer vision been achieved at the expense of robustness? As seen in Figure 3, as architectures improve, so too does the mean Corruption Error (mCE). By this measure, architectures have become progressively more successful at generalizing to corrupted distributions. Note that models with similar clean error rates have fairly similar CEs, and in Table 1 there are no large shifts in a corruption type’s CE. Consequently, it would seem that architectures have slowly and consistently improved their representations over time. However, it appears that corruption robustness improvements are mostly explained by accuracy improvements. Recall that the Relative mCE tracks a classifier’s accuracy decline in the presence of corruptions. Figure 3 shows that the Relative mCEs of many subsequent models are worse than that of AlexNet (Krizhevsky et al., 2012). Full results are in Appendix D. In consequence, from AlexNet to ResNet, corruption robustness in itself has barely changed. Thus our “superhuman” classifiers are decidedly subhuman.
+
+On perturbed inputs, current classifiers are unexpectedly bad. For example, a ResNet-18 on Scale perturbation sequences have a $1 5 . 6 \%$ probability of flipping its top-1 prediction between adjacent frames (i.e., perturbation $\mathrm { F P _ { S c a l e } ^ { R e s N e t - 1 8 } = 1 5 . 6 \% }$ ; therial t $\mathrm { u T 5 D } _ { \mathrm { S c a l e } } ^ { \mathrm { R e s N e t - 1 8 } }$ is 3.6. More results are in Appendix E. Clearly classifiers. What is also surprising is that while VGGNets are worse than ResNets at generalizing to corrupted examples, on perturbed examples they can be just as robust or even more robust. Likewise, Batch Normalization made VGG-19 less robust to perturbations but more robust to corruptions. Yet this is not to suggest that there is a fundamental trade-off between corruption and perturbation robustness. In fact, both corruption and perturbation robustness can improve together, as we shall see later.
+
+# 5.2 ROBUSTNESS ENHANCEMENTS
+
+Be aware that Appendix F contains many informative failures in robustness enhancement. Those experiments underscore the necessity in testing on a a diverse test set, the difficulty in cleansing corruptions from image, and the futility in expecting robustness gains from some “simpler” models.
+
+Histogram Equalization. Histogram equalization successfully standardizes speech data for robust speech recognition (Torre et al., 2005; Harvilla & Stern, 2012). For images, we find that preprocessing with Contrast Limited Adaptive Histogram Equalization (Pizer et al., 1987) is quite effective. Unlike our image denoising attempt (Appendix F), CLAHE reduces the effect of some corruptions while not worsening performance on most others, thereby improving the mCE. We demonstrate CLAHE’s net improvement by taking a pre-trained ResNet-50 and fine-tuning the whole model for five epochs on images processed with CLAHE. The ResNet-50 has a $2 3 . 8 7 \%$ error rate, but ResNet-50 with CLAHE has an error rate of $2 3 . 5 5 \%$ . On nearly all corruptions, CLAHE slightly decreases the Corruption Error. The ResNet-50 without CLAHE preprocessing has an mCE of $7 6 . 7 \%$ , while with CLAHE the ResNet-50’s mCE decreases to $7 4 . 5 \%$ .
+
+Multiscale Networks. Multiscale architectures achieve greater corruption robustness by propagating features across scales at each layer rather than slowly gaining a global representation of the input as in typical convolutional neural networks. Some multiscale architectures are called Multigrid Networks (Ke et al., 2017). Multigrid networks each have a pyramid of grids in each layer which enables the subsequent layer to operate across scales. Along similar lines, Multi-Scale Dense Networks (MSDNets) (Huang et al., 2018) use information across scales. MSDNets bind network layers with DenseNet-like (Huang et al., 2017b) skip connections. These two different multiscale networks both enhance corruption robustness, but they do not provide any noticeable benefit in perturbation robustness. Now before comparing mCE values, we first note the Multigrid network has a $2 4 . 6 \%$ top-1 error rate, as does the MSDNet, while the ResNet-50 has a $2 3 . 9 \%$ top-1 error rate. On noisy inputs, Multigrid networks noticeably surpass ResNets and MSDNets, as shown in Figure 5. Since multiscale architectures have high-level representations processed in tandem with fine details, the architectures appear better equipped to suppress otherwise distracting pixel noise. When all corruptions are evaluated, ResNet-50 has an mCE of $7 6 . 7 \%$ , the MSDNet has an mCE of $7 3 . 6 \%$ , and the Multigrid network has an mCE of $7 3 . 3 \%$ .
+
+Feature Aggregating and Larger Networks. Some recent models enhance the ResNet architecture by increasing what is called feature aggregation. Of these, DenseNets and ResNeXts (Xie et al., 2016) are most prominent. Each purports to have stronger representations than ResNets, and the evidence is largely a hard-won ImageNet error-rate downtick. Interestingly, the IMAGENET-C mCE clearly indicates that DenseNets and ResNeXts have superior representations. Accordingly, a switch from a ResNet-50 $2 3 . 9 \%$ top-1 error) to a DenseNet-121 $2 5 . 6 \%$ error) decreases the mCE from $7 6 . 7 \%$ to $7 3 . 4 \%$ (and the relative $\mathrm { m C E }$ from $1 0 5 . 0 \%$ to $9 2 . 8 \%$ ). More starkly, switching from a ResNet-50 to a ResNeXt-50 $2 2 . 9 \%$ top-1) drops the mCE from $7 6 . 7 \%$ to $6 8 . 2 \%$ (relative mCE decreases from $1 0 5 . 0 \%$ to $8 8 . 6 \%$ ). Corruption robustness results are summarized in Figure 5. This shows that corruption robustness may be a better way to measure future progress in representation learning than the clean dataset top-1 error rate.
+
+Some of the greatest and simplest robustness gains sometimes emerge from making recent models more monolithic. Apparently more representations, more redundancy, and more capacity allow these massive models to operate more stably on corrupted inputs. We saw earlier that making models smaller does the opposite. Swapping a DenseNet-121 ( $2 5 . 6 \%$ top-1) with the larger DenseNet-161 $2 2 . 9 \%$ top1) decreases the mCE from $7 3 . 4 \%$ to $6 6 . 4 \%$ (and the relative mCE from $9 2 . 8 \%$ to $8 4 . 6 \%$ ). In a similar fashion, a ResNeXt-50 $2 2 . 9 \%$ top-1) is less robust than the a giant ResNeXt-101 $( 2 1 . 0 \%$ top-1). The mCEs are $6 8 . 2 \%$ and $6 2 . 2 \%$ respectively (and the relative mCEs are $8 8 . 6 \%$ and $8 0 . 1 \%$ respectively).
+
+![](images/95ff99774b48cc8ef86d290388b67b127dd23de5905c58bc9df9dc0ac5c8aa8e.jpg)  
+Figure 5: Architectures such as Multigrid networks and DenseNets resist noise corruptions more effectively than ResNets.
+
+![](images/c982f6349009115326615064b893f7cd583bb01a4f06238651494fe23f705e1c.jpg)  
+Figure 6: Larger feature aggregating networks achieve robustness gains that substantially outpace their accuracy gains.
+
+Both model size and feature aggregation results are summarized in Figure 6. Consequently, future models with even more depth, width, and feature aggregation may attain further corruption robustness.
+
+Feature aggregation and their larger counterparts similarly improve perturbation robustness. While a ResNet-50 has a $5 8 . 0 \%$ mFR and a $7 8 . 3 \%$ mT5D, a DenseNet-121 obtains a $5 6 . 4 \%$ mFR and $7 6 . 8 \%$ mT5D, and a ResNeXt-50 does even better with a $5 2 . 4 \%$ mFR and a $7 4 . 2 \%$ mT5D. Reflecting the corruption robustness findings further, the larger DenseNet-161 has a $4 6 . 9 \%$ mFR and $6 9 . 5 \%$ mT5D, while the ResNeXt-101 has a $4 3 . 2 \%$ mFR and $6 5 . 9 \%$ mT5D. Thus in two senses feature aggregating networks and their larger versions markedly enhance robustness.
+
+Stylized ImageNet. Geirhos et al. (2019) propose a novel data augmentation scheme where ImageNet images are stylized with style transfer. The intent is that classifiers trained on stylized images will rely less on textural cues for classification. When a ResNet-50 is trained on typical ImageNet images and stylized ImageNet images, the resulting model has an mCE of $6 9 . 3 \%$ , down from $7 6 . 7 \%$
+
+Adversarial Logit Pairing. ALP is an adversarial example defense for large-scale image classifiers (Kannan et al., 2018). Like nearly all other adversarial defenses, ALP was bypassed and has unclear value as an adversarial defense going forward (Engstrom et al., 2018), yet this is not a decisive reason dismiss it. ALP provides significant perturbation robustness even though it does not provide much adversarial perturbation robustness against all adversaries. Although ALP was designed to increase robustness to small gradient perturbations, it markedly improves robustness to all sorts of noise, blur, weather, and digital IMAGENET-P perturbations—methods generalizing this well is a rarity. In point of fact, a publicly available Tiny ImageNet ResNet-50 model fine-tuned with ALP has a $41 \%$ and $40 \%$ relative decrease in the mFP and mT5D on TINY IMAGENET-P, respectively. ALP’s success in enhancing common perturbation robustness and its modest utility for adversarial perturbation robustness highlights that the interplay between these problems should be better understood.
+
+# 6 CONCLUSION
+
+In this paper, we introduced what are to our knowledge the first comprehensive benchmarks for corruption and perturbation robustness. This was made possible by introducing two new datasets, IMAGENET-C and IMAGENET-P. The first of which showed that many years of architectural advancements corresponded to minuscule changes in relative corruption robustness. Therefore benchmarking and improving robustness deserves attention, especially as top-1 clean ImageNet accuracy nears its ceiling. We also saw that classifiers exhibit unexpected instability on simple perturbations. Thereafter we found that methods such as histogram equalization, multiscale architectures, and larger featureaggregating models improve corruption robustness. These larger models also improve perturbation robustness. However, we found that even greater perturbation robustness can come from an adversarial defense designed for adversarial $\ell _ { \infty }$ perturbations, indicating a surprising interaction between adversarial and common perturbation robustness. In this work, we found several methods to increase robustness, introduced novel experiments and metrics, and created new datasets for the rigorous study of model robustness, a pressing necessity as models are unleashed into safety-critical real-world settings.
+
+# 7 ACKNOWLEDGEMENTS
+
+We should like to thank Justin Gilmer, David Wagner, Kevin Gimpel, Tom Brown, Mantas Mazeika, and Steven Basart for their helpful suggestions. This research was supported by a grant from the Future of Life Institute.
+
+# REFERENCES
+
+Ossama Abdel-Hamid, Abdel rahman Mohamed, Hui Jiang, and Gerald Penn. Applying convolutional neural networks concepts to hybrid nn-hmm model for speech recognition. ICASSP, 2013.
+
+Aharon Azulay and Yair Weiss. Why do deep convolutional networks generalize so poorly to small image transformations? arXiv preprint, 2018.
+
+Osbert Bastani, Yani Ioannou, Leonidas Lampropoulos, Dimitrios Vytiniotis, Aditya Nori, and Antonio Criminisi. Measuring neural net robustness with constraints. In NIPS. 2016.
+
+Antoni Buades and Bartomeu Coll. A non-local algorithm for image denoising. In CVPR, 2005.
+
+Nicholas Carlini and David Wagner. Defensive distillation is not robust to adversarial examples, 2016.
+
+Nicholas Carlini and David Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods, 2017.
+
+Nicholas Carlini, Guy Katz, Clark Barrett, and David L. Dill. Ground-truth adversarial examples, 2017.
+
+Jia Deng, Wei Dong, Richard Socher, Li jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. CVPR, 2009.
+
+Samuel Dodge and Lina Karam. Quality resilient deep neural networks, 2017a.
+
+Samuel Dodge and Lina Karam. A study and comparison of human and deep learning recognition performance under visual distortions, 2017b.
+
+David Donoho and Iain Johnstone. Ideal spatial adaptation by wavelet shrinkage. Biometrika, 1993.
+
+Logan Engstrom, Andrew Ilyas, and Anish Athalye. Evaluating and understanding the robustness of adversarial logit pairing. arXiv preprint, 2018.
+
+Ivan Evtimov, Kevin Eykholt, Earlence Fernandes, Tadayoshi Kohno, Bo Li, Atul Prakash, Amir Rahmati, and Dawn Song. Robust physical-world attacks on deep learning models, 2017.
+
+Ruth Fong and Andrea Vedaldi. Interpretable explanations of black boxes by meaningful perturbation. ICCV, 2017.
+
+Leon Gatys, Alexander Ecker, and Matthias Bethge. Image style transfer using convolutional neural networks. CVPR, 2016.
+
+Robert Geirhos, David H. J. Janssen, Heiko H. Schütt, Jonas Rauber, Matthias Bethge, and Felix A. Wichmann. Comparing deep neural networks against humans: object recognition when the signal gets weaker, 2017.
+
+Robert Geirhos, Patricia Rubisch, Claudio Michaelis, Matthias Bethge, Felix A Wichmann, and Wieland Brendel. Imagenet-trained cnns are biased towards texture; increasing shape bias improves accuracy and robustness. ICLR, 2019.
+
+Justin Gilmer, Ryan P. Adams, Ian Goodfellow, David Andersen, and George E. Dahl. Motivating the rules of the game for adversarial example research. arXiv preprint, 2018a.
+
+Justin Gilmer, Luke Metz, Fartash Faghri, Samuel S. Schoenholz, Maithra Raghu, Martin Wattenberg, and Ian Goodfellow. Adversarial spheres. ICLR Workshop, 2018b.
+
+Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q. Weinberger. On calibration of modern neural networks. International Conference on Machine Learning, 2017.
+
+Mark Harvilla and Richard Stern. Histogram-based subband powerwarping and spectral averaging for robust speech recognition under matched and multistyle training, 2012.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CVPR, 2015.
+
+Dan Hendrycks and Kevin Gimpel. Early methods for detecting adversarial images, 2017a.
+
+Dan Hendrycks and Kevin Gimpel. A baseline for detecting misclassified and out-of-distribution examples in neural networks. In ICLR, 2017b.
+
+Dan Hendrycks, Mantas Mazeika, Duncan Wilson, and Kevin Gimpel. Using trusted data to train deep networks on labels corrupted by severe noise. NIPS, 2018.
+
+Dan Hendrycks, Mantas Mazeika, and Thomas Dietterich. Deep anomaly detection with outlier exposure. ICLR, 2019.
+
+Hans-Günter Hirsch. Aurora-5 experimental framework for the performance evaluation of speech recognition in case of a hands-free speech input in noisy environments, 2007.
+
+Hans-Günter Hirsch and David Pearce. The Aurora experimental framework for the performance evaluation of speech recognition systems under noisy conditions. ISCA ITRW ASR2000, 2000.
+
+Hossein Hosseini, Baicen Xiao, and Radha Poovendran. Google’s cloud vision api is not robust to noise, 2017.
+
+Gao Huang, Shichen Liu, Laurens van der Maaten, and Kilian Q Weinberger. Condensenet: An efficient DenseNet using learned group convolutions. arXiv preprint, 2017a.
+
+Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2017b.
+
+Gao Huang, Danlu Chen, Tianhong Li, Felix Wu, Laurens van der Maaten, and Kilian Q. Weinberger. Multi-scale dense networks for resource efficient image classification. ICLR, 2018.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. JMLR, 2015.
+
+Harini Kannan, Alexey Kurakin, and Ian Goodfellow. Adversarial logit pairing. NIPS, 2018.
+
+Tsung-Wei Ke, Michael Maire, and Stella X. Yu. Multigrid neural architectures, 2017.
+
+Chanwoo Kim and Richard M. Stern. Power-normalized cepstral coefficients (PNCC) for robust speech recognition. IEEE/ACM Trans. Audio, Speech and Lang. Proc., 24(7):1315–1329, July 2016. ISSN 2329-9290.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. NIPS, 2012.
+
+Ravi Kumar and Sergei Vassilvitskii. Generalized distances between rankings, 2010.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. ICLR, 2017.
+
+Jinyu Li, Li Deng, Yifan Gong, and Reinhold Haeb-Umbach. An overview of noise-robust automatic speech recognition. 2014.
+
+Fu-Hua Liu, Richard M. Stern, Xuedong Huang, and Alex Acero. Efficient cepstral normalization for robust speech recognition. In Proc. of DARPA Speech and Natural Language Workshop, 1993.
+
+Si Liu, Risheek Garrepalli, Thomas Dietterich, Alan Fern, and Dan Hendrycks. Open category detection with PAC guarantees. In ICML, 2018.
+
+Jiajun Lu, Hussein Sibai, Evan Fabry, and David Forsyth. Standard detectors aren’t (currently) fooled by physical adversarial stop signs, 2017.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. ICLR, 2018.
+
+Jan Hendrik Metzen, Tim Genewein, Volker Fischer, and Bastian Bischoff. On detecting adversarial perturbations, 2017.
+
+Vikramjit Mitra, Horacio Franco, Richard Stern, Julien Van Hout, Luciana Ferrer, Martin Graciarena, Wen Wang, Dimitra Vergyri, Abeer Alwan, and John H.L. Hansen. Robust features in deep learning based speech recognition, 2017.
+
+Chris Olah, Alexander Mordvintsev, and Ludwig Schubert. Feature visualization. Distill, 2017.
+
+Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks, 2017.
+
+Stephen M. Pizer, E. Philip Amburn, John D. Austin, Robert Cromartie, Ari Geselowitz, Trey Greer, Bart Ter Haar Romeny, and John B. Zimmerman. Adaptive histogram equalization and its variations. Computer Vision, Graphics, and Image Processing, 1987.
+
+Jonas Rauber, Wieland Brendel, and Matthias Bethge. Foolbox v0.8.0: A python toolbox to benchmark the robustness of machine learning models, 2017.
+
+Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do cifar-10 classifiers generalize to cifar-10? arXiv preprint, 2018.
+
+Ludwig Schmidt, Shibani Santurkar, Dimitris Tsipras, Kunal Talwar, and Aleksander Madry. Adversarially robust generalization requires more data. arXiv preprint, 2018.
+
+Lukas Schott, Jonas Rauber, Matthias Bethge, and Wieland Brendel. Towards deep learning models resistant to adversarial attacks. arXiv preprint, 2018.
+
+Jacob Steinhardt, Pang Wei Koh, and Percy Liang. Certified defenses for data poisoning attacks. NIPS, 2017.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks, 2014.
+
+Dogancan Temel and Ghassan AlRegib. Traffic signs in the wild: Highlights from the ieee video and image processing cup 2017 student competition. IEEE Signal Processing Magazine, 2018.
+
+Dogancan Temel, Gukyeong Kwon, Mohit Prabhushankar, and Ghassan AlRegib. Cure-tsr: Challenging unreal and real environments for traffic sign recognition. NIPS Workshop, 2017.
+
+Dogancan Temel, Jinsol Lee, and Ghassan AlRegib. Cure-or: Challenging unreal and real environments for object recognition. ICMLA, 2018.
+
+Ángel de la Torre, Antonio Peinado, José Segura, José Pérez-Córdoba, Ma Carmen Benítez, and Antonio Rubio. Histogram equalization of speech representation for robust speech recognition. IEEE Signal Processing Society, 2005.
+
+Igor Vasiljevic, Ayan Chakrabarti, and Gregory Shakhnarovich. Examining the impact of blur on recognition by convolutional networks, 2016.
+
+Saining Xie, Ross Girshick, Piotr Dollár, Zhuowen Tu, and Kaiming He. Aggregated residual transformations for deep neural networks. CVPR, 2016.
+
+Stephan Zheng, Yang Song, Thomas Leung, and Ian Goodfellow. Improving the robustness of deep neural networks via stability training, 2016.
+
+# A EXAMPLE OF IMAGENET-C SEVERITIES
+
+![](images/4ebc2a59533ab7e5503288d47241397745080192eebfbfb68bc4fc56579b421a.jpg)  
+Figure 7: Impulse noise modestly to markedly corrupts a frog, showing our benchmark’s varying severities.
+
+In Figure 7, we show the Impulse noise corruption type in five different severities. Clearly, IMAGENETC corruptions can range from negligible to pulverizing. Because of this range, the benchmark comprehensively assesses each corruption type.
+
+# B EXTRA IMAGENET-C CORRUPTIONS
+
+![](images/271a75e209df01146ee8e90621b94a2c4bb79515c99306cb6f82ca36d8e8c93d.jpg)  
+Figure 8: Extra IMAGENET-C corruption examples are available for model validation and sounder experimentation.
+
+Directly fitting the types of IMAGENET-C corruptions should be avoided, as it would cause researchers to overestimate a model’s robustness. Therefore, it is incumbent on us to simplify model validation. This is why we provide an additional form of corruption for each of the four general types. These are available for download at https://github.com/hendrycks/robustness. There is one corruption type for each noise, blur, weather, and digital category in the validation set. The first corruption type is speckle noise, an additive noise where the noise added to a pixel tends to be larger if the original pixel intensity is larger. Gaussian blur is a low-pass filter where a blurred pixel is a result of a weighted average of its neighbors, and farther pixels have decreasing weight in this average. Spatter can occlude a lens in the form of rain or mud. Finally, saturate is common in edited images where images are made more or less colorful. See Figure 8 for instances of each corruption type.
+
+# C MORE ON THE IMAGENET-P METRICS AND SETUP
+
+For some readers, the following function may be opaque,
+
+$$
+d ( \tau ( x ) , \tau ( x ^ { \prime } ) ) = \sum _ { i = 1 } ^ { 5 } \sum _ { j = \operatorname* { m i n } \{ i , \sigma ( i ) \} + 1 } ^ { \operatorname* { m a x } \{ i , \sigma ( i ) \} } \mathbb { 1 } ( 1 \leq j - 1 \leq 5 )
+$$
+
+where $\sigma = ( \tau ( x ) ) ^ { - 1 } \tau ( x ^ { \prime } )$ and the empty sum is understood to be zero. A high-level view of $d$ is that it computes the deviation between the top-5 predictions of two prediction lists. For simplicity we find the deviation between the identity and $\sigma$ rather than $\tau ( x )$ and $\tau ( x ^ { \prime } )$ . In consequence we can consider $d ^ { \prime } ( \sigma ) : = d ( 1 , \sigma )$ where 1 the identity permutation. To give some intuition, we provide concrete examples of $d ^ { \prime }$ on permutations.
+
+If $\sigma$ is the identity, then $d ^ { \prime } ( \bar { \sigma } ) = 0$ .   
+If $\sigma = ( 1 , 2 , 3 , 4 , 6 , 5 , 7 , 8 , \dot { . } . . )$ , $d ^ { \prime } ( \sigma ) = 1$ . If $\sigma = ( 1 , 2 , 3 , 4 , 6 , 7 , 5 , 8 , . . . )$ , $d ^ { \prime } ( \sigma ) = 1$ . Once 5 fell out of the top-5, its displacement did not accumulate any further; this may happen when only the top-5 predictions are shown to the user.   
+If $\sigma = ( 2 , 1 , 3 , 4 , 5 , 6 , \dots )$ , $d ^ { \prime } ( \sigma ) = \mathrm { \bar { 2 } }$ .   
+If $\sigma = ( 3 , 1 , 2 , 4 , 5 , 6 , \dots ) ,$ $d ^ { \prime } ( \sigma ) = 4$ .   
+Also, $d ^ { \prime } ( ( 2 , 3 , 4 , 5 , 6 , \dots , 1 ) ) = 5$ .   
+Distinctly, $d ^ { \prime } ( ( 1 , 2 , 3 , 5 , 6 , 4 , 7 , 8 , . . . ) ) = 2$ .   
+As a final example, $d ^ { \prime } ( ( 5 , 4 , 3 , 2 , 1 , 6 , 7 , 8 , 9 , . . . ) ) = 1 2 .$ .
+
+It may be that we want perturbation robustness for all predictions, including classes with lesser relevance. In such cases, it is still common that the displacement of the top prediction matters more than themeasure $\begin{array} { r } { d ^ { \prime } \hat { ( \sigma ) } = \sum _ { i = 1 } ^ { 1 0 0 0 } w _ { i } \hat { | } w _ { i } - w _ { \sigma ( i ) } | } \end{array}$ ranked cl such that $w _ { i } = 1 / i$ is there are many possibilities, such as the. This uses a Zipfian assumption about the rankings of the classes: the first class is $n$ times as relevant as the nth class. Other possibilities involve using logarithms rather than hyperbolic functions as in the discounted cumulative gain (Kumar & Vassilvitskii, 2010). One could also use the class probabilities provided by the model (should they exist). However such a measure could make it difficult to compare models since some models tend to be more uncalibrated than others (Guo et al., 2017).
+
+As progress is made on this task, researchers may be interested in perturbations which are more likely to cause unstable predictions. To accomplish that, researchers can simply compare a frame with the frame two frames ahead rather than just one frame ahead. We provide concrete code of this slight change in the metric at https://github.com/hendrycks/robustness. For nontemporal perturbation sequences, i.e., noise sequences, we provide sequences where the noise perturbation is larger.
+
+# D FULL CORRUPTION ROBUSTNESS RESULTS
+
+IMAGENET-C corruption relative robustness results are in Tnormalize Corruption Error values, we now specify the value $\begin{array} { r } { { \frac { 1 } { 5 } } \sum _ { s = 1 } ^ { 5 } E _ { s , \mathrm { C o r r u p t i o n } } ^ { \mathrm { A l e x N e t } } } \end{array}$ e AlexNet errors tofor each corruption type. Gaussian Noise: , Shot Noise: , Impulse Noise: $9 2 . 3 \%$ , Defocus Blur: $8 2 . 0 \%$ , Glass Blur: $8 2 . 6 \%$ , Motion Blur: $7 8 . 6 \%$ , Zoom Blur: $7 9 . 8 \%$ , Snow: $8 6 . 7 \%$ , Frost: $8 2 . 7 \%$ , Fog: $8 1 . 9 \%$ , Brightness: $5 6 . 5 \%$ , Contrast: $8 5 . 3 \%$ , Elastic Transformation: $6 4 . 6 \%$ , Pixelate: $7 1 . 8 \%$ , JPEG: $6 0 . 7 \%$ , Speckle Noise: $8 4 . 5 \%$ , Gaussian Blur: $7 8 . 7 \%$ , Spatter: $7 1 . 8 \%$ , Saturate: $6 5 . 8 \%$ .
+
+<table><tr><td></td><td></td><td></td><td></td><td>Noise</td><td></td><td></td><td>Blur</td><td></td><td></td><td></td><td>Weather</td><td></td><td></td><td>Digital</td><td></td><td></td></tr><tr><td>Network</td><td>Error</td><td>Rel.mCEGauss.Shot Impulse</td><td></td><td></td><td></td><td>Defocus Glass Motion Zoom</td><td></td><td></td><td></td><td>SnowFrost FogBright</td><td></td><td></td><td></td><td></td><td>Contrast Elastic Pixel JPEG</td><td></td></tr><tr><td>AlexNet</td><td>43.5</td><td>100.0</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100100100</td><td></td><td></td><td>100</td><td>100</td><td>100</td><td>100100</td></tr><tr><td>SqueezeNet</td><td>41.8</td><td>117.9</td><td>118</td><td>116</td><td>114</td><td>104</td><td>110</td><td>106</td><td>105</td><td>106 110 98</td><td></td><td></td><td>101</td><td>100</td><td>126</td><td>129 229</td></tr><tr><td>VGG-11</td><td>31.0</td><td>123.3</td><td>122</td><td>121</td><td>125</td><td>116</td><td>129</td><td>121</td><td>115</td><td>114</td><td>113</td><td>99</td><td>86</td><td>102</td><td>151 161</td><td>174</td></tr><tr><td>VGG-19</td><td>27.6</td><td>122.9</td><td>114</td><td>117</td><td>122</td><td>118</td><td>136</td><td>123</td><td>122</td><td>114</td><td>111</td><td>88</td><td>82</td><td>98</td><td>165 161</td><td>172</td></tr><tr><td>VGG-19+BN1</td><td>25.8</td><td>111.1</td><td>104</td><td>105</td><td>114</td><td>108</td><td>132</td><td>114</td><td>119</td><td>102</td><td>100</td><td>79</td><td>68</td><td>89</td><td>165 125</td><td>144</td></tr><tr><td>ResNet-18</td><td>30.2</td><td>103.9</td><td>104</td><td>106</td><td>111</td><td>100</td><td>116</td><td>108</td><td>112</td><td>103101</td><td></td><td>89</td><td>67</td><td>87</td><td>133 97</td><td>126</td></tr><tr><td>ResNet-50</td><td>23.9</td><td>105.0</td><td>104</td><td>107</td><td>107</td><td>97</td><td>126</td><td>107</td><td>110</td><td>101</td><td>97</td><td>79</td><td>62</td><td>89</td><td>146 111</td><td>132</td></tr></table>
+
+Table 2: Clean Error, Relative mCE, and Relative Corruption Errors values of different corruptions and architectures on IMAGENET-C. All models are trained on clean ImageNet images, not IMAGENET-C images. Here “BN” abbreviates Batch Normalization (Ioffe & Szegedy, 2015).
+
+# E FULL PERTURBATION ROBUSTNESS RESULTS
+
+IMAGENET-P mFerrors to normali $2 3 . 6 5 \%$ s are in Table 3,easures, we now $3 0 . 0 6 \%$ 5D values are in  the value FPAlexPertu $9 . 3 0 \%$ . Since we use Aor each corrupti $5 . 9 4 \%$ t. Snow: $1 1 . 9 3 \%$ , Brightness: $4 . 8 9 \%$ , Translate: $1 1 . 0 1 \%$ , Rotate: $1 3 . 1 0 \%$ , Tilt: $7 . 0 5 \%$ , Scale: $2 3 . 5 3 \%$ , Speckle Noise: $1 8 . 6 5 \%$ , Gaussian Blur: $2 . 7 8 \%$ , Spatter: $5 . 0 5 \%$ , Shear: $1 0 . 6 6 \%$ . Also, the uT5DAlexNetPerturbati on values are as follows. Gaussian Noise: 4.77, Shot Noise: 5.76, Motion Blur: 1.93, Zoom Blur: 1.34, Snow: 2.42, Brightness: 1.19, Translate: 2.63, Rotate: 2.95,
+
+Tilt: 1.75, Scale: 4.48, Speckle Noise: 3.89, Gaussian Blur: 0.70, Spatter: 1.26, Shear: 2.48.   
+
+<table><tr><td>Noise</td><td></td><td colspan="3"></td><td colspan="2">Blur</td><td colspan="2">Weather</td><td colspan="3">Digital</td></tr><tr><td>Network</td><td>Error</td><td>mFR</td><td>Gaussian</td><td>Shot</td><td>Motion</td><td>Zoom</td><td>Snow Bright</td><td>Translate</td><td>Rotate</td><td>Tilt</td><td>Scale</td></tr><tr><td>AlexNet</td><td>43.5</td><td>100.0</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100 100</td><td>100</td><td>100</td><td>100</td><td>100</td></tr><tr><td>SqueezeNet</td><td>41.8</td><td>112.6</td><td>147</td><td>140</td><td>109</td><td>109</td><td>105 110</td><td>101</td><td>103</td><td>109</td><td>93</td></tr><tr><td>VGG-11</td><td>31.0</td><td>74.9</td><td>89</td><td>90</td><td>85</td><td>84</td><td>80 76</td><td>52</td><td>64</td><td>69</td><td>59</td></tr><tr><td>VGG-19</td><td>27.6</td><td>66.9</td><td>75</td><td>76</td><td>82</td><td>84</td><td>73 74</td><td>41</td><td>54</td><td>60</td><td>49</td></tr><tr><td>VGG-19+BN</td><td>25.8</td><td>65.1</td><td>67</td><td>66</td><td>75</td><td>86</td><td>70 72</td><td>45</td><td>56</td><td>56</td><td>51</td></tr><tr><td>ResNet-18</td><td>30.2</td><td>72.8</td><td>74</td><td>73</td><td>75</td><td>85</td><td>75 78</td><td>63</td><td>66</td><td>73</td><td>66</td></tr><tr><td>ResNet-50</td><td>23.9</td><td>58.0</td><td>59</td><td>58</td><td>64</td><td>72</td><td>63 62</td><td>44</td><td>52</td><td>57</td><td>48</td></tr></table>
+
+Table 3: Flip Rates and the mFR values of different perturbations and architectures on IMAGENET-P. All models are trained on clean ImageNet images, not IMAGENET-P images. Here “BN” abbreviates Batch Normalization.   
+Table 4: Top-5 Distances and the mT5D values of different perturbations and architectures on IMAGENET-P.   
+
+<table><tr><td></td><td></td><td></td><td colspan="2">Noise</td><td colspan="2">Blur</td><td colspan="2">Weather</td><td colspan="4">Digital</td></tr><tr><td>Network</td><td>Error</td><td>mT5D</td><td>Gaussian</td><td>Shot</td><td>Motion</td><td>Zoom</td><td>Snow</td><td>Bright</td><td>Translate</td><td>Rotate</td><td>Tilt</td><td>Scale</td></tr><tr><td>AlexNet</td><td>43.5</td><td>100.0</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td></tr><tr><td>SqueezeNet</td><td>41.8</td><td>112.9</td><td>139</td><td>133</td><td>109</td><td>111</td><td>107</td><td>112</td><td>104</td><td>106</td><td>111</td><td>98</td></tr><tr><td>VGG-11</td><td>31.0</td><td>83.9</td><td>98</td><td>97</td><td>93</td><td>90</td><td>87</td><td>85</td><td>63</td><td>75</td><td>79</td><td>71</td></tr><tr><td>VGG-19</td><td>27.6</td><td>78.6</td><td>89</td><td>88</td><td>92</td><td>93</td><td>82</td><td>86</td><td>53</td><td>67</td><td>74</td><td>62</td></tr><tr><td>VGG-19+BN</td><td>25.8</td><td>80.5</td><td>85</td><td>82</td><td>90</td><td>97</td><td>84</td><td>88</td><td>61</td><td>72</td><td>80</td><td>66</td></tr><tr><td>ResNet-18</td><td>30.2</td><td>87.0</td><td>89</td><td>87</td><td>89</td><td>95</td><td>88</td><td>92</td><td>78</td><td>82</td><td>89</td><td>80</td></tr><tr><td>ResNet-50</td><td>23.9</td><td>78.3</td><td>82</td><td>79</td><td>84</td><td>89</td><td>80</td><td>84</td><td>64</td><td>73</td><td>80</td><td>67</td></tr></table>
+
+# F INFORMATIVE ROBUSTNESS ENHANCEMENT ATTEMPTS
+
+Stability Training. Stability training is a technique to improve the robustness of deep networks (Zheng et al., 2016). The method’s creators found that training on images corrupted with noise can lead to underfitting, so they instead propose minimizing the cross-entropy from the noisy image’s softmax distribution to the softmax of the clean image. The authors evaluated performance on images with subtle differences and suggested that the method provides additional robustness to JPEG corruptions. We fine-tune a ResNet-50 with stability training for five epochs. For training with noisy images, we corrupt images with uniform noise, where the maximum and minimum of the uniform noise is tuned over $\{ 0 . 0 1 , 0 . 0 5 , 0 . 1 \}$ , and the stability weight is tuned over $\{ 0 . 0 1 , 0 . 0 5 , 0 . 1 \}$ . Across all noise strengths and stability weight combinations, the models with stability training tested on IMAGENET-C have a larger mCEs than the baseline ResNet-50’s mCE. Even on unseen noise corruptions, stability training does not increase robustness. However, the perturbation robustness slightly improves. The best model according to the IMAGENET-P validation set has an mFR of $5 7 \%$ , while the original ResNet’s mFR is $5 8 \%$ . An upshot of this failure is that benchmarking robustness-enhancing techniques requires a diverse test set.
+
+Image Denoising. An approach orthogonal to modifying model representations is to improve the inputs using image restoration techniques. Although general image restoration techniques are not yet mature, denoising restoration techniques are not. We thus attempt restore an image with the denoising technique called non-local means (Buades & Coll, 2005). The amount of denoising applied is determined by the noise estimation technique of Donoho & Johnstone (1993). Therefore clean images receive should nearly no modifications from the restoration method, while noisy images should undergo considerable restoration. We found that denoising increased the mCE from $7 6 . 7 \%$ to $8 2 . 1 \%$ . A plausible account is that the non-local means algorithm striped the images of their subtle details even when images lacked noise, despite having the non-local means algorithm governed by the noise estimate. Therefore, the gains in noise robustness were wiped away by subtle blurs to images with other types of corruptions, showing that targeted image restoration can prove harmful for robustness.
+
+10-Crop Classification. Viewing an object at several different locations may give way to a more stable prediction. Having this intuition in mind, we perform 10-crop classification. 10-crop classification is executed by cropping all four corners and cropping the center of an image. These crops and their horizontal mirrors are processed through a network to produce 10 predicted class probability distributions. We average these distributions to compute the final prediction. Of course, a prediction informed by 10-crops rather than a single central crop is more accurate. Ideally, this revised prediction should be more robust too. However, the gains in mCE do not outpace the gains in accuracy on a ResNet-50. In all, 10-crop classification is a computationally expensive option which contributes to classification accuracy but not noticeably to robustness.
+
+Smaller Models. All else equal, “simpler” models often generalize better, and “simplicity” frequently translates to model size. Accordingly, smaller models may be more robust. We test this hypothesis with CondenseNets (Huang et al., 2017a). A CondenseNet attains its small size via sparse convolutions and pruned filter weights. An off-the-shelf CondenseNet $C = G = 4 ,$ ) obtains a $2 6 . 3 \%$ error rate and a $8 0 . 8 \%$ mCE. On the whole, this CondenseNet is slightly less robust than larger models of similar accuracy. Even more pruning and sparsification yields a CondenseNet ( $C = G = 8$ ) with both deteriorated performance $2 8 . 9 \%$ error rate) and robustness $8 4 . 6 \%$ mCE). Here again robustness is worse than larger model robustness. Though models fashioned for mobile devices are smaller and in some sense simpler, this does not improve robustness.
+
+# G A SEPARATE TYPE OF ROBUSTNESS
+
+Another goal for machine learning is to learn the fundamental structure of categories. Broad categories, such as “bird,” have many subtypes, such as “cardinal” or “bluejay.” Humans can observe previously unseen bird species yet still know that they are birds. A test of learned fundamental structure beyond superficial features is subtype robustness. In subtype robustness we test generalization to unseen subtypes which share share essential characteristics of a broader type. We repurpose the ImageNet-22K dataset for a closer investigation into subtype robustness.
+
+Subtype Robustness. A natural image dataset with a hierarchical taxonomy and numerous types and subtypes is ImageNet-22K, an ImageNet-1K superset. In this subtype robustness experiment, we manually select 25 broad types from ImageNet-22K, listed in the next paragraph. Each broad type has many subtypes. We call a subtype “seen” if and only if it is in ImageNet-1K and a subtype of one of the 25 broad types. The subtype is “unseen” if and only if it is a subtype of the 25 broad types and is from ImageNet-22K but not ImageNet-1K. In this experiment, the correct classification decision for an image of a subtype is the broad type label. We take pre-trained ImageNet-1K classifiers which have not trained on unseen subtypes. Next we fine-tune the last layer of these pre-trained ImageNet-1K classifiers on seen subtypes so that they predict one of 25 broad types. Then, we test the accuracy on images of seen
+
+![](images/5f0410e3592e5c217096ea491035539be3dd9b5b9f2d67895b26ec23ec61f28f.jpg)  
+Figure 9: ImageNet classifiers and their robustness to unseen subtypes. Unseen subtypes of known broad types are noticeably harder for classifiers.
+
+subtypes and on images of unseen subtypes. Accuracy on unseen subtypes is our measure of subtype robustness. Seen and unseen accuracies are shown in Figure 9, while the ImageNet-1K classification accuracy before fine-tuning is on the horizontal axis. Despite only having 25 classes and having trained on millions of images, these classifiers demonstrate a subtype robustness performance gap that should be far less pronounced. We also observe that the architectures proposed so far hardly deviate from the trendline.
+
+The 25 broad types which we selected from ImageNet are as follows. Amphibian (n01627424), Appliance (n02729837), Aquatic Mammal (n02062017), Bird (n01503061), Bear (n02131653), Beverage (n07881800), Big cat (n02127808), Building (n02913152), Cat (n02121620), Clothing (n03051540), Dog (n02084071), Electronic Equipment (n03278248), Fish (n02512053), Footwear (n03380867), Fruit (n13134947), Fungus (n12992868), Geological Formation (n09287968), Hoofed Animal (n02370806), Insect (n02159955), Musical Instrument (n03800933), Primate (n02469914), Reptile (n01661091), Utensil (n04516672), Vegetable (n07707451), Vehicle (n04576211).

parse/train/HJz6tiCqYm/HJz6tiCqYm_content_list.json

@@ -0,0 +1,1879 @@
+[
+    {
+        "type": "text",
+        "text": "BENCHMARKING NEURAL NETWORK ROBUSTNESS TO COMMON CORRUPTIONS AND PERTURBATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            790,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks University of California, Berkeley hendrycks@berkeley.edu ",
+        "bbox": [
+            183,
+            170,
+            408,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Thomas Dietterich Oregon State University tgd@oregonstate.edu ",
+        "bbox": [
+            526,
+            170,
+            714,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper we establish rigorous benchmarks for image classifier robustness. Our first benchmark, IMAGENET-C, standardizes and expands the corruption robustness topic, while showing which classifiers are preferable in safety-critical applications. Then we propose a new dataset called IMAGENET-P which enables researchers to benchmark a classifier’s robustness to common perturbations. Unlike recent robustness research, this benchmark evaluates performance on common corruptions and perturbations not worst-case adversarial perturbations. We find that there are negligible changes in relative corruption robustness from AlexNet classifiers to ResNet classifiers. Afterward we discover ways to enhance corruption and perturbation robustness. We even find that a bypassed adversarial defense provides substantial common perturbation robustness. Together our benchmarks may aid future work toward networks that robustly generalize. ",
+        "bbox": [
+            233,
+            281,
+            766,
+            448
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            470,
+            336,
+            486
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The human vision system is robust in ways that existing computer vision systems are not (Recht et al., 2018; Azulay & Weiss, 2018). Unlike current deep learning classifiers (Krizhevsky et al., 2012; He et al., 2015; Xie et al., 2016), the human vision system is not fooled by small changes in query images. Humans are also not confused by many forms of corruption such as snow, blur, pixelation, and novel combinations of these. Humans can even deal with abstract changes in structure and style. Achieving these kinds of robustness is an important goal for computer vision and machine learning. It is also essential for creating deep learning systems that can be deployed in safety-critical applications. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            597
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Most work on robustness in deep learning methods for vision has focused on the important challenges of robustness to adversarial examples (Szegedy et al., 2014; Carlini & Wagner, 2017; 2016), unknown unknowns (Hendrycks et al., 2019; Hendrycks & Gimpel, 2017b; Liu et al., 2018), and model or data poisoning (Steinhardt et al., 2017; Hendrycks et al., 2018). In contrast, we develop and validate datasets for two other forms of robustness. Specifically, we introduce the IMAGETNET-C dataset for input corruption robustness and the IMAGENET-P dataset for input perturbation robustness. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To create IMAGENET-C, we introduce a set of 75 common visual corruptions and apply them to the ImageNet object recognition challenge (Deng et al., 2009). We hope that this will serve as a general dataset for benchmarking robustness to image corruptions and prevent methodological problems such as moving goal posts and result cherry picking. We evaluate the performance of current deep learning systems and show that there is wide room for improvement on IMAGENET-C. We also introduce a total of three methods and architectures that improve corruption robustness without losing accuracy. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            777
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To create IMAGENET-P, we introduce a set of perturbed or subtly differing ImageNet images. Using metrics we propose, we measure the stability of the network’s predictions on these perturbed images. Although these perturbations are not chosen by an adversary, currently existing networks exhibit surprising instability on common perturbations. Then we then demonstrate that approaches which enhance corruption robustness can also improve perturbation robustness. For example, some recent architectures can greatly improve both types of robustness. More, we show that the Adversarial Logit Pairing $\\ell _ { \\infty }$ adversarial example defense can yield substantial robustness gains on diverse and common perturbations. By defining and benchmarking perturbation and corruption robustness, we facilitate research that can be overcome by future networks which do not rely on spurious correlations or cues inessential to the object’s class. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            344,
+            117
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Examples. An adversarial image is a clean image perturbed by a small distortion carefully crafted to confuse a classifier. These deceptive distortions can occasionally fool black-box classifiers (Kurakin et al., 2017). Algorithms have been developed that search for the smallest additive distortions in RGB space that are sufficient to confuse a classifier (Carlini et al., 2017). Thus adversarial distortions serve as type of worst-case analysis for network robustness. Its popularity has often led “adversarial robustness” to become interchangeable with “robustness” in the literature (Bastani et al., 2016; Rauber et al., 2017). In the literature, new defenses (Lu et al., 2017; Papernot et al., 2017; Metzen et al., 2017; Hendrycks & Gimpel, 2017a) often quickly succumb to new attacks (Evtimov et al., 2017; Carlini & Wagner, 2017; 2016), with some exceptions for perturbations on small images (Schott et al., 2018; Madry et al., 2018). For some simple datasets, the existence of any classification error ensures the existence of adversarial perturbations of size $\\mathcal { O } ( d ^ { - 1 / 2 } )$ , $d$ the input dimensionality (Gilmer et al., 2018b). For some simple models, adversarial robustness requires an increase in the training set size that is polynomial in $d$ (Schmidt et al., 2018). Gilmer et al. (2018a) suggest modifying the problem of adversarial robustness itself for increased real-world applicability. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            329
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Robustness in Speech. Speech recognition research emphasizes robustness to common corruptions rather than worst-case, adversarial corruptions (Li et al., 2014; Mitra et al., 2017). Common acoustic corruptions (e.g., street noise, background chatter, wind) receive greater focus than adversarial audio, because common corruptions are ever-present and unsolved. There are several popular datasets containing noisy test audio (Hirsch & Pearce, 2000; Hirsch, 2007). Robustness in noisy environments requires robust architectures, and some research finds convolutional networks more robust than fully connected networks (Abdel-Hamid et al., 2013). Additional robustness has been achieved through pre-processing techniques such as standardizing the statistics of the input (Liu et al., 1993; Torre et al., 2005; Harvilla & Stern, 2012; Kim & Stern, 2016). ",
+        "bbox": [
+            174,
+            335,
+            825,
+            462
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "ConvNet Fragility Studies. Several studies demonstrate the fragility of convolutional networks on simple corruptions. For example, Hosseini et al. (2017) apply impulse noise to break Google’s Cloud Vision API. Using Gaussian noise and blur, Dodge & Karam (2017b) demonstrate the superior robustness of human vision to convolutional networks, even after networks are fine-tuned on Gaussian noise or blur. Geirhos et al. (2017) compare networks to humans on noisy and elastically deformed images. They find that fine-tuning on specific corruptions does not generalize and that classification error patterns underlying network and human predictions are not similar. Temel et al. (2017; 2018); Temel & AlRegib (2018) propose different corrupted datasets for object and traffic sign recognition. ",
+        "bbox": [
+            173,
+            468,
+            825,
+            579
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Robustness Enhancements. In an effort to reduce classifier fragility, Vasiljevic et al. (2016) finetune on blurred images. They find it is not enough to fine-tune on one type of blur to generalize to other blurs. Furthermore, fine-tuning on several blurs can marginally decrease performance. Zheng et al. (2016) also find that fine-tuning on noisy images can cause underfitting, so they encourage the noisy image softmax distribution to match the clean image softmax. Dodge & Karam (2017a) address underfitting via a mixture of corruption-specific experts assuming corruptions are known beforehand. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            670
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 CORRUPTIONS, PERTURBATIONS, AND ADVERSARIAL PERTURBATIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            690,
+            795,
+            707
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We now define corruption and perturbation robustness and distinguish them from adversarial perturbation robustness. To begin, we consider a classifier $f : \\mathcal { X }  \\mathcal { Y }$ trained on samples from distribution $\\mathcal { D }$ , a set of corruption functions $C$ , and a set of perturbation functions $\\mathcal { E }$ . We let $\\mathbb { P } _ { C } ( c ) , \\mathbb { P } _ { \\mathcal { E } } ( \\varepsilon )$ approximate the real-world frequency of these corruptions and perturbations. Most classifiers are judged by their accuracy on test queries drawn from $\\mathcal { D }$ , i.e., $\\mathbb { P } _ { ( x , y ) \\sim \\mathcal { D } } ( f ( x ) = y )$ . Yet in a vast range of cases the classifier is tasked with classifying low-quality or corrupted inputs. In view of this, we suggest also computing the classifier’s corruption robustness $\\mathbb { E } _ { c \\sim C } [ \\mathbb { P } _ { ( { \\boldsymbol x } , { \\boldsymbol y } ) \\sim \\mathcal { D } } ( f ( c ( { \\boldsymbol x } ) = { \\boldsymbol y } ) ) ]$ . This contrasts with a popular notion of adversarial robustness, often formulated $\\operatorname* { m i n } _ { \\| \\delta \\| _ { p } < b } \\mathbb { P } _ { ( { \\boldsymbol { x } } , { \\boldsymbol { y } } ) \\sim \\mathcal { D } } ( f ( { \\boldsymbol { x } } + { \\boldsymbol { \\delta } } ) = { \\boldsymbol { y } } )$ , $b$ a small budget. Thus, corruption robustness measures the classifier’s average-case performance on corruptions $C$ , while adversarial robustness measures the worst-case performance on small, additive, classifier-tailored perturbations. ",
+        "bbox": [
+            173,
+            719,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Average-case performance on small, general, classifier-agnostic perturbations motivates us to define perturbation robustness, namely $\\mathbb { E } _ { \\varepsilon \\sim \\varepsilon } [ \\mathbb { P } _ { ( x , y ) \\sim \\mathcal { D } } ( f ( \\varepsilon ( \\bar { x ) } ) = f ( x ) ) ]$ ]. Consequently, in measuring perturbation robustness, we track the classifier’s prediction stability, reliability, or consistency in the face of minor input changes. Now in order to approximate $C , \\mathcal { E }$ and these robustness measures, we designed a set of corruptions and perturbations which are frequently encountered in natural images. We will refer to these as “common” corruptions and perturbations. These common corruptions and perturbations are available in the form of IMAGENET-C and IMAGENET-P. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/660a2d4193294467ceea562bde8433a94f413c493acd8b5013f5737a8cf4af1f.jpg",
+        "image_caption": [
+            "Figure 1: Our IMAGENET-C dataset consists of 15 types of algorithmically generated corruptions from noise, blur, weather, and digital categories. Each type of corruption has five levels of severity, resulting in 75 distinct corruptions. See different severity levels in Appendix B. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            99,
+            818,
+            452
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            530,
+            825,
+            585
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 THE IMAGENET-C AND IMAGENET-P ROBUSTNESS BENCHMARKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            602,
+            758,
+            618
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.1 THE DATA OF IMAGENET-C AND IMAGENET-P ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            632,
+            539,
+            647
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "IMAGENET-C Design. The IMAGENET-C benchmark consists of 15 diverse corruption types applied to validation images of ImageNet. The corruptions are drawn from four main categories— noise, blur, weather, and digital—as shown in Figure 1. Research that improves performance on this benchmark should indicate general robustness gains, as the corruptions are diverse and numerous. Each corruption type has five levels of severity since corruptions can manifest themselves at varying intensities. Appendix A gives an example of the five different severity levels for impulse noise. Real-world corruptions also have variation even at a fixed intensity. To simulate these, we introduce variation for each corruption when possible. For example, each fog cloud is unique to each image. These algorithmically generated corruptions are applied to the ImageNet (Deng et al., 2009) validation images to produce our corruption robustness dataset IMAGENET-C. The dataset can be downloaded or re-created by visiting https://github.com/hendrycks/robustness. IMAGENET-C images are saved as lightly compressed JPEGs; this implies an image corrupted by Gaussian noise is also slightly corrupted by JPEG compression. Our benchmark tests networks with IMAGENET-C images, but networks should not be trained on these images. Networks should be trained on datasets such as ImageNet and not be trained on IMAGENET-C corruptions. To enable further experimentation, we designed an extra corruption type for each corruption category (Appendix B), and we provide CIFAR-10-C, TINY IMAGENET-C, IMAGENET $6 4 \\times 6 4 – \\mathrm { C }$ , and Inception-sized editions. Overall, the IMAGENET-C dataset consists of 75 corruptions, all applied to ImageNet validation images for testing a pre-existing network. ",
+        "bbox": [
+            174,
+            659,
+            826,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Common Corruptions. The first corruption type is Gaussian noise. This corruption can appear in low-lighting conditions. Shot noise, also called Poisson noise, is electronic noise caused by the discrete nature of light itself. Impulse noise is a color analogue of salt-and-pepper noise and can be caused by bit errors. Defocus blur occurs when an image is out of focus. Frosted Glass Blur appears with “frosted glass” windows or panels. Motion blur appears when a camera is moving quickly. Zoom blur occurs when a camera moves toward an object rapidly. Snow is a visually obstructive form of precipitation. Frost forms when lenses or windows are coated with ice crystals. Fog shrouds objects and is rendered with the diamond-square algorithm. Brightness varies with daylight intensity. Contrast can be high or low depending on lighting conditions and the photographed object’s color. Elastic transformations stretch or contract small image regions. Pixelation occurs when upsampling a lowresolution image. JPEG is a lossy image compression format which introduces compression artifacts. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "IMAGENET-P Design. The second benchmark that we propose tests the classifier’s perturbation robustness. Models lacking in perturbation robustness produce erratic predictions which undermines user trust. When perturbations have a high propensity to change the model’s response, then perturbations could also misdirect or destabilize iterative image optimization procedures appearing in style transfer (Gatys et al., 2016), decision explanations (Fong & Vedaldi, 2017), feature visualization (Olah et al., 2017), and so on. Like IMAGENET-C, IMAGENETP consists of noise, blur, weather, and digital distortions. Also as before, the dataset has validation perturbations; has difficulty levels; has CIFAR-10, Tiny ImageNet, ImageNet $6 4 \\times 6 4$ standard, and Inception-sized editions; and has been designed for benchmarking not training networks. IMAGENET-P departs from IMAGENET-C by having perturbation sequences generated from each ImageNet validation image; examples are in Figure 2. Each sequence contains more than 30 frames, so we counteract an increase in dataset size and evaluation time by using only 10 common perturbations. ",
+        "bbox": [
+            176,
+            263,
+            581,
+            526
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Common Perturbations. Appearing more subtly than the corruption from IMAGENET-C, the Gaussian noise perturbation sequence begins with the clean ImageNet image. The following frames in the sequence consist in the same image but with minute Gaussian noise perturbations applied. This sequence design is similar for the shot noise perturbation sequence. However the remaining perturbation sequences have temporality, so that each frame of the sequence is a perturbation of the previous frame. Since each perturbation is small, repeated application of a perturbation does not bring the image far out-of-distribution. For example, an IMAGENET-P translation perturbation sequence shows a clean ImageNet image sliding from right to left one pixel at a time; with each perturbation of the pixel locations, the resulting frame is still of high quality. The perturbation sequences with temporality are created with motion blur, zoom blur, snow, brightness, translate, rotate, tilt (viewpoint variation through minor 3D rotations), and scale perturbations. ",
+        "bbox": [
+            174,
+            535,
+            583,
+            645
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/5eadeb9445cbd05f3b967e8a0ac289ebaec911114710a56d07a556ff265efbd2.jpg",
+        "image_caption": [
+            "Figure 2: Example frames from the beginning $( T = 0$ ) to end $( T = 3 0$ ) of some Tilt and Brightness perturbation sequences. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            593,
+            265,
+            820,
+            560
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            645,
+            825,
+            728
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 IMAGENET-C AND IMAGENET-P METRICS AND SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            750,
+            593,
+            765
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "IMAGENET-C Metrics. Common corruptions such as Gaussian noise can be benign or destructive depending on their severity. In order to comprehensively evaluate a classifier’s robustness to a given type of corruption, we score the classifier’s performance across five corruption severity levels and aggregate these scores. The first evaluation step is to take a trained classifier f, which has not been $E _ { \\mathrm { { c l e a n } } } ^ { f }$ d on IMAGENET-C, and compute the clean dataset top-1 error. The second step is to test the classifier on each corruption type $c$ te. Denote this error raat each level of severity $s$ $( 1 \\le s \\le 5 )$ ). This top-1 error is written $E _ { s , c } ^ { f }$ . Before we aggregate the classifier’s performance across severities and corruption types, we will make error rates more comparable since different corruptions pose different levels of difficulty. For example, fog corruptions often obscure an object’s class more than brightness corruptions. We adjust for the varying difficulties by dividing by AlexNet’s errors, but any baseline will do (even a baseline with $100 \\%$ error rates, corresponding to an average of CEs). This standardized aggregate performance measure is the Corruption Error, computed with the formula ",
+        "bbox": [
+            174,
+            780,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3b668e4002a85a55995eb012169619af005f78e84930ffccc81affe42b17d775.jpg",
+        "text": "$$\n\\mathrm { { C E } } _ { c } ^ { f } = \\biggl ( \\sum _ { s = 1 } ^ { 5 } E _ { s , c } ^ { f } \\biggr ) \\bigg / \\biggl ( \\sum _ { s = 1 } ^ { 5 } E _ { s , c } ^ { \\mathrm { A l e x N e t } } \\biggr ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            133,
+            629,
+            176
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\mathrm { C E } _ { \\mathrm { G a u s s i a n N o i s e } } ^ { f }$ , $\\mathbf { C E } _ { \\mathrm { { S h o t N o i s e } } } ^ { f } , \\dotsc , \\mathbf { C E } _ { \\mathrm { { J P E G } } } ^ { f }$ ion robustness by averag. This results in the mean $C E$ theor $m C E$ orruption Error valuesfor short. ",
+        "bbox": [
+            173,
+            178,
+            825,
+            209
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now introduce a more nuanced corruption robustness measure. Consider a classifier that withstands most corruptions, so that the gap between the $\\mathrm { m C E }$ and the clean data error is minuscule. Contrast this with a classifier with a low clean error rate which has its error rate spike in the presence of corruptions; this corresponds to a large gap between the mCE and clean data error. It is possible that the former classifier has a larger mCE than the latter, despite the former degrading more gracefully in the presence of corruptions. The amount that the classifier declines on corrupted inputs is given by the formula Relative $\\begin{array} { r } { \\mathbf { \\bar { C } E } _ { c } ^ { f } = \\big ( \\sum _ { s = 1 } ^ { 5 } E _ { s , c } ^ { f } - E _ { \\mathrm { c l e a n } } ^ { f } \\big ) \\big / \\big ( \\sum _ { s = 1 } ^ { 5 } E _ { s , c } ^ { \\mathrm { A l e x N e t } } - E _ { \\mathrm { c l e a n } } ^ { \\mathrm { A l e x N e t } } \\big ) } \\end{array}$ . Averaging these 15 Relative Corruption Errors results in the Relative $m C E$ . This measures the relative robustness or the performance degradation when encountering corruptions. ",
+        "bbox": [
+            173,
+            214,
+            826,
+            343
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "IMAGENET-P Metrics. A straightforward approach to estimate $\\mathbb { E } _ { \\varepsilon \\sim \\mathcal { E } } [ \\mathbb { P } _ { ( x , y ) \\sim \\mathcal { D } } ( f ( \\varepsilon ( x ) ) \\neq f ( x ) ) ]$ falls into place when using IMAGENET-P perturbation sequences. Let us denote $m$ perturbation sequences with $\\mathcal { S } = \\{ \\left( x _ { 1 } ^ { ( i ) } , x _ { 2 } ^ { ( i ) } , \\ldots , x _ { n } ^ { ( i ) } \\right) \\bar  \\} _ { i = 1 } ^ { m }$ where each sequence is made with perturbation $p$ . The “Flip Probability” of network $f : \\mathcal { X }  \\bar { \\{ 1 , 2 , \\dots , 1 0 0 0 \\} }$ on perturbation sequences $s$ is ",
+        "bbox": [
+            173,
+            348,
+            826,
+            411
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4f2079435ab632fc1f953758d8d83d18b4d8f68402f1e79a75e4d3244a880fa9.jpg",
+        "text": "$$\n\\mathrm { F P } _ { p } ^ { f } = \\frac { 1 } { m ( n - 1 ) } \\sum _ { i = 1 } ^ { m } \\sum _ { j = 2 } ^ { n } \\mathbb { 1 } \\left( f \\big ( x _ { j } ^ { ( i ) } \\big ) \\neq f \\big ( x _ { j - 1 } ^ { ( i ) } \\big ) \\right) = \\mathbb { P } _ { x \\sim { \\mathscr { S } } } ( f ( x _ { j } ) \\neq f ( x _ { j - 1 } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            414,
+            759,
+            455
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For noise perturbation sequences, which are not temporally related, $x _ { 1 } ^ { ( i ) }$ is clean and $\\boldsymbol { x } _ { j } ^ { ( i ) }$ $( j ~ > ~ 1 )$ are perturbed images of $x _ { 1 } ^ { ( i ) }$ . We can recast the FP formula for noise sequences as $\\begin{array} { r } { \\mathrm { F P } _ { p } ^ { f } = \\frac { 1 } { m ( n - 1 ) } \\sum _ { i = 1 } ^ { m } \\sum _ { j = 2 } ^ { n } \\mathbb { I } \\big ( f \\big ( x _ { j } ^ { ( i ) } \\big ) \\ne f \\big ( x _ { 1 } ^ { ( i ) } \\big ) \\big ) = \\mathbb { P } _ { x \\sim S } ( f ( x _ { j } ) \\ne f ( x _ { 1 } ) \\mid j > 1 ) } \\end{array}$ . As was done with the Corruption Error formula, we now standardize the Flip Probability by the sequence’s difficulty for increased commensurability. We have, then, the “Flip Rate” FRfp = FPfp /FPAlexNetp . Averaging the Flip Rate across all perturbations yields the mean Flip Rate or $m F R$ . We do not define a “relative mFR” since we did not find any natural formulation, nor do we directly use predicted class probabilities due to differences in model calibration (Guo et al., 2017). ",
+        "bbox": [
+            173,
+            457,
+            826,
+            587
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "When the top-5 predictions are relevant, perturbations should not cause the list of top-5 predictions to shuffle chaotically, nor should classes sporadically vanish from the list. We penalize top-5 inconsistency of this kind with a different measure. Let the ranked predictions of network $f$ on $x$ be the permutation $\\tau ( x ) \\in S _ { 1 0 0 0 }$ . Concretely, if “Toucan” has the label 97 in the output space and “Pelican” has the label 145, and if $f$ on $x$ predicts “Toucan” and “Pelican” to be the most and second-most likely classes, respectively, then $\\tau ( x ) ( 9 7 ) = 1$ and $\\tau ( x ) ( 1 4 4 ) = 2$ . These permutations contain the top-5 predictions, so we use permutations to compare top-5 lists. To do this, we define ",
+        "bbox": [
+            173,
+            592,
+            825,
+            691
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/92f0338f9a2e5aca60b691756ec3878ba37a68a58d11edfa4d4eaeeb88e98bf6.jpg",
+        "text": "$$\nd ( \\tau ( x ) , \\tau ( x ^ { \\prime } ) ) = \\sum _ { i = 1 } ^ { 5 } \\sum _ { j = \\operatorname* { m i n } \\{ i , \\sigma ( i ) \\} + 1 } ^ { \\operatorname* { m a x } \\{ i , \\sigma ( i ) \\} } \\mathbb { 1 } ( 1 \\leq j - 1 \\leq 5 )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            691,
+            683,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma = ( \\tau ( x ) ) ^ { - 1 } \\tau ( x ^ { \\prime } )$ . If the top-5 predictions represented within $\\tau ( x )$ and $\\tau ( x ^ { \\prime } )$ are identical, then $d ( \\tau ( x ) , \\tau ( x ^ { \\prime } ) ) = 0$ . More examples of $d$ on several permutations are in Appendix C. Comparing the top-5 predictions across entire perturbation sequences results in the unstandardized Top-5 Distance $\\begin{array} { r } { \\mathfrak { u } \\mathrm { T } 5 \\mathbf { D } _ { p } ^ { f } = \\frac { 1 } { m ( n - 1 ) } \\sum _ { i = 1 } ^ { m } \\sum _ { j = 2 } ^ { n } d ( \\tau ( x _ { j } ) , \\tau ( x _ { j - 1 } ) ) = \\mathbb { P } _ { x \\sim \\mathcal { S } } ( d ( \\tau ( x _ { j } ) , \\tau ( x _ { j - 1 } ) ) , \\tau ( x _ { j - 1 } ) ) . } \\end{array}$ . For noise perturbation sequences, we have $\\mathsf { u T 5 D } _ { p } ^ { f } \\ : = \\ : \\mathbb { E } _ { x \\sim { \\cal S } } [ d ( \\tau ( x _ { j } ) , \\tau ( x _ { 1 } ) ) \\mid j$ > 1]. Once the uT5D is standardized, we have the Top-5 Distance $\\mathrm { T } 5 \\mathrm { D } _ { p } ^ { f } \\ = \\ \\mathrm { u T } 5 \\mathrm { D } _ { p } ^ { f } / \\mathrm { u T } 5 \\mathrm { D } _ { p } ^ { \\mathrm { A l e x N e t } }$ . The T5Ds averaged together correspond to the mean Top-5 Distance or $m T 5 D$ . ",
+        "bbox": [
+            173,
+            742,
+            826,
+            852
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Preserving Metric Validity. The goal of IMAGENET-C and IMAGENET-P is to evaluate the robustness of machine learning algorithms on novel corruptions and perturbations. Humans are able to generalize to novel corruptions quite well; for example, they can easily deal with new Instagram filters. Likewise for perturbations; humans relaxing in front of an undulating ocean do not give turbulent accounts of the scenery before them. Hence, we propose the following protocol. The image recognition network should be trained on the ImageNet training set and on whatever other training sets the investigator wishes to include. Researchers should clearly state whether they trained on these corruptions or perturbations; however, this training strategy is discouraged (see Section 2). We allow training with other distortions (e.g., uniform noise) and standard data augmentation (i.e., cropping, mirroring), even though cropping overlaps with translations. Then the resulting trained model should be evaluated on IMAGENET-C or IMAGENET-P using the above metrics. Optionally, researchers can test with the separate set of validation corruptions and perturbations we provide for IMAGENET-C and IMAGENET-P. ",
+        "bbox": [
+            174,
+            857,
+            826,
+            915
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/0ae51795bbaa947988dcc03ee415e7c0850b08ccc5c4917ef642f8723b53f965.jpg",
+        "image_caption": [
+            "Figure 3: Robustness (mCE) and Relative mCE IMAGENET-C values. Relative mCE values suggest robustness in itself declined from AlexNet to ResNet. “BN” abbreviates Batch Normalization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            82,
+            483,
+            280
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/6f5e6c2c82e059e09dc82a275eba0929fb7fcf91d2eb6271011fc6dbb29ea191.jpg",
+        "image_caption": [
+            "Figure 4: Perturbation robustness of various architectures as measured by the mT5D on IMAGENET-P. Observe that corruption and perturbation robustness track distinct concepts. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            509,
+            83,
+            813,
+            279
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/7d85f262f231c5f9fd2823ba93b0e96b772157391914641fccd37e851318f236.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Clean Error, mCE, and Corruption Error values of different corruptions and architectures on IMAGENET-C. The mCE value is the mean Corruption Error of the corruptions in Noise, Blur, Weather, and Digital columns. Models are trained only on clean ImageNet images. "
+        ],
+        "table_body": "<table><tr><td></td><td></td><td></td><td></td><td>Noise</td><td></td><td></td><td>Blur</td><td></td><td></td><td></td><td>Weather</td><td></td><td></td><td></td><td>Digital</td><td></td></tr><tr><td>Network</td><td>Error</td><td>mCE</td><td>Gauss.Shot Impulse</td><td></td><td></td><td></td><td>Defocus Glass Motion Zoom</td><td></td><td></td><td>SnowFrostFogBright</td><td></td><td></td><td></td><td></td><td>Contrast Elastic Pixel JPEG</td><td></td></tr><tr><td>AlexNet</td><td>43.5</td><td>100.0</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>1001 100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td></tr><tr><td>SqueezeNet</td><td>41.8</td><td>104.4</td><td>107</td><td>106</td><td>105</td><td>100</td><td>103</td><td>101</td><td>100</td><td>101</td><td>103 97</td><td>97</td><td></td><td>98</td><td>106 109</td><td>134</td></tr><tr><td>VGG-11</td><td>31.0</td><td>93.5</td><td>97</td><td>97</td><td>100</td><td>92</td><td>99</td><td>93</td><td>91</td><td>92</td><td>91 84</td><td>75</td><td>86</td><td>97</td><td>107</td><td>100</td></tr><tr><td>VGG-19</td><td>27.6</td><td>88.9</td><td>89</td><td>91</td><td>95</td><td>89</td><td>98</td><td>90</td><td>90</td><td>89</td><td>86 75</td><td>68</td><td>80</td><td>97</td><td>102</td><td>94</td></tr><tr><td>VGG-19+BN</td><td>25.8</td><td>81.6</td><td>82</td><td>83</td><td>88</td><td>82</td><td>94</td><td>84</td><td>86</td><td>80</td><td>78 69</td><td>61</td><td>74</td><td>94</td><td>85</td><td>83</td></tr><tr><td>ResNet-18</td><td>30.2</td><td>84.7</td><td>87</td><td>88</td><td>91</td><td>84</td><td>91</td><td>87</td><td>89</td><td>86</td><td>84 78</td><td>69</td><td>78</td><td>90</td><td>80</td><td>85</td></tr><tr><td>ResNet-50</td><td>23.9</td><td>76.7</td><td>80</td><td>82</td><td>83</td><td>75</td><td>89</td><td>78</td><td>80</td><td>78</td><td>75 66</td><td>57</td><td>71</td><td>85</td><td>77</td><td>77</td></tr></table>",
+        "bbox": [
+            173,
+            359,
+            826,
+            477
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            547,
+            826,
+            660
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            676,
+            326,
+            693
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 ARCHITECTURE ROBUSTNESS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            708,
+            421,
+            722
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "How robust are current methods, and has progress in computer vision been achieved at the expense of robustness? As seen in Figure 3, as architectures improve, so too does the mean Corruption Error (mCE). By this measure, architectures have become progressively more successful at generalizing to corrupted distributions. Note that models with similar clean error rates have fairly similar CEs, and in Table 1 there are no large shifts in a corruption type’s CE. Consequently, it would seem that architectures have slowly and consistently improved their representations over time. However, it appears that corruption robustness improvements are mostly explained by accuracy improvements. Recall that the Relative mCE tracks a classifier’s accuracy decline in the presence of corruptions. Figure 3 shows that the Relative mCEs of many subsequent models are worse than that of AlexNet (Krizhevsky et al., 2012). Full results are in Appendix D. In consequence, from AlexNet to ResNet, corruption robustness in itself has barely changed. Thus our “superhuman” classifiers are decidedly subhuman. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On perturbed inputs, current classifiers are unexpectedly bad. For example, a ResNet-18 on Scale perturbation sequences have a $1 5 . 6 \\%$ probability of flipping its top-1 prediction between adjacent frames (i.e., perturbation $\\mathrm { F P _ { S c a l e } ^ { R e s N e t - 1 8 } = 1 5 . 6 \\% }$ ; therial t $\\mathrm { u T 5 D } _ { \\mathrm { S c a l e } } ^ { \\mathrm { R e s N e t - 1 8 } }$ is 3.6. More results are in Appendix E. Clearly classifiers. What is also surprising is that while VGGNets are worse than ResNets at generalizing to corrupted examples, on perturbed examples they can be just as robust or even more robust. Likewise, Batch Normalization made VGG-19 less robust to perturbations but more robust to corruptions. Yet this is not to suggest that there is a fundamental trade-off between corruption and perturbation robustness. In fact, both corruption and perturbation robustness can improve together, as we shall see later. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            102,
+            825,
+            202
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 ROBUSTNESS ENHANCEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            226,
+            429,
+            239
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Be aware that Appendix F contains many informative failures in robustness enhancement. Those experiments underscore the necessity in testing on a a diverse test set, the difficulty in cleansing corruptions from image, and the futility in expecting robustness gains from some “simpler” models. ",
+        "bbox": [
+            174,
+            256,
+            825,
+            299
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Histogram Equalization. Histogram equalization successfully standardizes speech data for robust speech recognition (Torre et al., 2005; Harvilla & Stern, 2012). For images, we find that preprocessing with Contrast Limited Adaptive Histogram Equalization (Pizer et al., 1987) is quite effective. Unlike our image denoising attempt (Appendix F), CLAHE reduces the effect of some corruptions while not worsening performance on most others, thereby improving the mCE. We demonstrate CLAHE’s net improvement by taking a pre-trained ResNet-50 and fine-tuning the whole model for five epochs on images processed with CLAHE. The ResNet-50 has a $2 3 . 8 7 \\%$ error rate, but ResNet-50 with CLAHE has an error rate of $2 3 . 5 5 \\%$ . On nearly all corruptions, CLAHE slightly decreases the Corruption Error. The ResNet-50 without CLAHE preprocessing has an mCE of $7 6 . 7 \\%$ , while with CLAHE the ResNet-50’s mCE decreases to $7 4 . 5 \\%$ . ",
+        "bbox": [
+            174,
+            305,
+            825,
+            444
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Multiscale Networks. Multiscale architectures achieve greater corruption robustness by propagating features across scales at each layer rather than slowly gaining a global representation of the input as in typical convolutional neural networks. Some multiscale architectures are called Multigrid Networks (Ke et al., 2017). Multigrid networks each have a pyramid of grids in each layer which enables the subsequent layer to operate across scales. Along similar lines, Multi-Scale Dense Networks (MSDNets) (Huang et al., 2018) use information across scales. MSDNets bind network layers with DenseNet-like (Huang et al., 2017b) skip connections. These two different multiscale networks both enhance corruption robustness, but they do not provide any noticeable benefit in perturbation robustness. Now before comparing mCE values, we first note the Multigrid network has a $2 4 . 6 \\%$ top-1 error rate, as does the MSDNet, while the ResNet-50 has a $2 3 . 9 \\%$ top-1 error rate. On noisy inputs, Multigrid networks noticeably surpass ResNets and MSDNets, as shown in Figure 5. Since multiscale architectures have high-level representations processed in tandem with fine details, the architectures appear better equipped to suppress otherwise distracting pixel noise. When all corruptions are evaluated, ResNet-50 has an mCE of $7 6 . 7 \\%$ , the MSDNet has an mCE of $7 3 . 6 \\%$ , and the Multigrid network has an mCE of $7 3 . 3 \\%$ . ",
+        "bbox": [
+            174,
+            450,
+            825,
+            659
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Feature Aggregating and Larger Networks. Some recent models enhance the ResNet architecture by increasing what is called feature aggregation. Of these, DenseNets and ResNeXts (Xie et al., 2016) are most prominent. Each purports to have stronger representations than ResNets, and the evidence is largely a hard-won ImageNet error-rate downtick. Interestingly, the IMAGENET-C mCE clearly indicates that DenseNets and ResNeXts have superior representations. Accordingly, a switch from a ResNet-50 $2 3 . 9 \\%$ top-1 error) to a DenseNet-121 $2 5 . 6 \\%$ error) decreases the mCE from $7 6 . 7 \\%$ to $7 3 . 4 \\%$ (and the relative $\\mathrm { m C E }$ from $1 0 5 . 0 \\%$ to $9 2 . 8 \\%$ ). More starkly, switching from a ResNet-50 to a ResNeXt-50 $2 2 . 9 \\%$ top-1) drops the mCE from $7 6 . 7 \\%$ to $6 8 . 2 \\%$ (relative mCE decreases from $1 0 5 . 0 \\%$ to $8 8 . 6 \\%$ ). Corruption robustness results are summarized in Figure 5. This shows that corruption robustness may be a better way to measure future progress in representation learning than the clean dataset top-1 error rate. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            819
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Some of the greatest and simplest robustness gains sometimes emerge from making recent models more monolithic. Apparently more representations, more redundancy, and more capacity allow these massive models to operate more stably on corrupted inputs. We saw earlier that making models smaller does the opposite. Swapping a DenseNet-121 ( $2 5 . 6 \\%$ top-1) with the larger DenseNet-161 $2 2 . 9 \\%$ top1) decreases the mCE from $7 3 . 4 \\%$ to $6 6 . 4 \\%$ (and the relative mCE from $9 2 . 8 \\%$ to $8 4 . 6 \\%$ ). In a similar fashion, a ResNeXt-50 $2 2 . 9 \\%$ top-1) is less robust than the a giant ResNeXt-101 $( 2 1 . 0 \\%$ top-1). The mCEs are $6 8 . 2 \\%$ and $6 2 . 2 \\%$ respectively (and the relative mCEs are $8 8 . 6 \\%$ and $8 0 . 1 \\%$ respectively). ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/95ff99774b48cc8ef86d290388b67b127dd23de5905c58bc9df9dc0ac5c8aa8e.jpg",
+        "image_caption": [
+            "Figure 5: Architectures such as Multigrid networks and DenseNets resist noise corruptions more effectively than ResNets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            98,
+            485,
+            291
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/c982f6349009115326615064b893f7cd583bb01a4f06238651494fe23f705e1c.jpg",
+        "image_caption": [
+            "Figure 6: Larger feature aggregating networks achieve robustness gains that substantially outpace their accuracy gains. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            93,
+            808,
+            295
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Both model size and feature aggregation results are summarized in Figure 6. Consequently, future models with even more depth, width, and feature aggregation may attain further corruption robustness. ",
+        "bbox": [
+            174,
+            358,
+            823,
+            387
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Feature aggregation and their larger counterparts similarly improve perturbation robustness. While a ResNet-50 has a $5 8 . 0 \\%$ mFR and a $7 8 . 3 \\%$ mT5D, a DenseNet-121 obtains a $5 6 . 4 \\%$ mFR and $7 6 . 8 \\%$ mT5D, and a ResNeXt-50 does even better with a $5 2 . 4 \\%$ mFR and a $7 4 . 2 \\%$ mT5D. Reflecting the corruption robustness findings further, the larger DenseNet-161 has a $4 6 . 9 \\%$ mFR and $6 9 . 5 \\%$ mT5D, while the ResNeXt-101 has a $4 3 . 2 \\%$ mFR and $6 5 . 9 \\%$ mT5D. Thus in two senses feature aggregating networks and their larger versions markedly enhance robustness. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            477
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Stylized ImageNet. Geirhos et al. (2019) propose a novel data augmentation scheme where ImageNet images are stylized with style transfer. The intent is that classifiers trained on stylized images will rely less on textural cues for classification. When a ResNet-50 is trained on typical ImageNet images and stylized ImageNet images, the resulting model has an mCE of $6 9 . 3 \\%$ , down from $7 6 . 7 \\%$ ",
+        "bbox": [
+            174,
+            483,
+            825,
+            540
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Logit Pairing. ALP is an adversarial example defense for large-scale image classifiers (Kannan et al., 2018). Like nearly all other adversarial defenses, ALP was bypassed and has unclear value as an adversarial defense going forward (Engstrom et al., 2018), yet this is not a decisive reason dismiss it. ALP provides significant perturbation robustness even though it does not provide much adversarial perturbation robustness against all adversaries. Although ALP was designed to increase robustness to small gradient perturbations, it markedly improves robustness to all sorts of noise, blur, weather, and digital IMAGENET-P perturbations—methods generalizing this well is a rarity. In point of fact, a publicly available Tiny ImageNet ResNet-50 model fine-tuned with ALP has a $41 \\%$ and $40 \\%$ relative decrease in the mFP and mT5D on TINY IMAGENET-P, respectively. ALP’s success in enhancing common perturbation robustness and its modest utility for adversarial perturbation robustness highlights that the interplay between these problems should be better understood. ",
+        "bbox": [
+            173,
+            546,
+            825,
+            699
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            714,
+            318,
+            731
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduced what are to our knowledge the first comprehensive benchmarks for corruption and perturbation robustness. This was made possible by introducing two new datasets, IMAGENET-C and IMAGENET-P. The first of which showed that many years of architectural advancements corresponded to minuscule changes in relative corruption robustness. Therefore benchmarking and improving robustness deserves attention, especially as top-1 clean ImageNet accuracy nears its ceiling. We also saw that classifiers exhibit unexpected instability on simple perturbations. Thereafter we found that methods such as histogram equalization, multiscale architectures, and larger featureaggregating models improve corruption robustness. These larger models also improve perturbation robustness. However, we found that even greater perturbation robustness can come from an adversarial defense designed for adversarial $\\ell _ { \\infty }$ perturbations, indicating a surprising interaction between adversarial and common perturbation robustness. In this work, we found several methods to increase robustness, introduced novel experiments and metrics, and created new datasets for the rigorous study of model robustness, a pressing necessity as models are unleashed into safety-critical real-world settings. ",
+        "bbox": [
+            174,
+            743,
+            826,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            398,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We should like to thank Justin Gilmer, David Wagner, Kevin Gimpel, Tom Brown, Mantas Mazeika, and Steven Basart for their helpful suggestions. This research was supported by a grant from the Future of Life Institute. ",
+        "bbox": [
+            174,
+            130,
+            825,
+            172
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            188,
+            287,
+            204
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ossama Abdel-Hamid, Abdel rahman Mohamed, Hui Jiang, and Gerald Penn. Applying convolutional neural networks concepts to hybrid nn-hmm model for speech recognition. ICASSP, 2013. ",
+        "bbox": [
+            174,
+            215,
+            823,
+            244
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aharon Azulay and Yair Weiss. Why do deep convolutional networks generalize so poorly to small image transformations? arXiv preprint, 2018. ",
+        "bbox": [
+            173,
+            253,
+            823,
+            284
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Osbert Bastani, Yani Ioannou, Leonidas Lampropoulos, Dimitrios Vytiniotis, Aditya Nori, and Antonio Criminisi. Measuring neural net robustness with constraints. In NIPS. 2016. ",
+        "bbox": [
+            173,
+            292,
+            825,
+            321
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Antoni Buades and Bartomeu Coll. A non-local algorithm for image denoising. In CVPR, 2005. ",
+        "bbox": [
+            173,
+            330,
+            803,
+            347
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Defensive distillation is not robust to adversarial examples, 2016. ",
+        "bbox": [
+            174,
+            356,
+            820,
+            385
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods, 2017. ",
+        "bbox": [
+            173,
+            393,
+            823,
+            422
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini, Guy Katz, Clark Barrett, and David L. Dill. Ground-truth adversarial examples, 2017. ",
+        "bbox": [
+            173,
+            433,
+            823,
+            462
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. CVPR, 2009. ",
+        "bbox": [
+            174,
+            470,
+            823,
+            500
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Samuel Dodge and Lina Karam. Quality resilient deep neural networks, 2017a. ",
+        "bbox": [
+            173,
+            510,
+            694,
+            525
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Samuel Dodge and Lina Karam. A study and comparison of human and deep learning recognition performance under visual distortions, 2017b. ",
+        "bbox": [
+            176,
+            535,
+            823,
+            563
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Donoho and Iain Johnstone. Ideal spatial adaptation by wavelet shrinkage. Biometrika, 1993. ",
+        "bbox": [
+            173,
+            573,
+            823,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Logan Engstrom, Andrew Ilyas, and Anish Athalye. Evaluating and understanding the robustness of adversarial logit pairing. arXiv preprint, 2018. ",
+        "bbox": [
+            173,
+            597,
+            823,
+            627
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ivan Evtimov, Kevin Eykholt, Earlence Fernandes, Tadayoshi Kohno, Bo Li, Atul Prakash, Amir Rahmati, and Dawn Song. Robust physical-world attacks on deep learning models, 2017. ",
+        "bbox": [
+            176,
+            636,
+            823,
+            665
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ruth Fong and Andrea Vedaldi. Interpretable explanations of black boxes by meaningful perturbation. ICCV, 2017. ",
+        "bbox": [
+            174,
+            674,
+            823,
+            703
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Leon Gatys, Alexander Ecker, and Matthias Bethge. Image style transfer using convolutional neural networks. CVPR, 2016. ",
+        "bbox": [
+            173,
+            713,
+            823,
+            742
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Robert Geirhos, David H. J. Janssen, Heiko H. Schütt, Jonas Rauber, Matthias Bethge, and Felix A. Wichmann. Comparing deep neural networks against humans: object recognition when the signal gets weaker, 2017. ",
+        "bbox": [
+            174,
+            751,
+            823,
+            795
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Robert Geirhos, Patricia Rubisch, Claudio Michaelis, Matthias Bethge, Felix A Wichmann, and Wieland Brendel. Imagenet-trained cnns are biased towards texture; increasing shape bias improves accuracy and robustness. ICLR, 2019. ",
+        "bbox": [
+            176,
+            804,
+            825,
+            847
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Justin Gilmer, Ryan P. Adams, Ian Goodfellow, David Andersen, and George E. Dahl. Motivating the rules of the game for adversarial example research. arXiv preprint, 2018a. ",
+        "bbox": [
+            173,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Justin Gilmer, Luke Metz, Fartash Faghri, Samuel S. Schoenholz, Maithra Raghu, Martin Wattenberg, and Ian Goodfellow. Adversarial spheres. ICLR Workshop, 2018b. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q. Weinberger. On calibration of modern neural networks. International Conference on Machine Learning, 2017. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mark Harvilla and Richard Stern. Histogram-based subband powerwarping and spectral averaging for robust speech recognition under matched and multistyle training, 2012. ",
+        "bbox": [
+            171,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CVPR, 2015. ",
+        "bbox": [
+            171,
+            178,
+            823,
+            207
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks and Kevin Gimpel. Early methods for detecting adversarial images, 2017a. ",
+        "bbox": [
+            176,
+            214,
+            772,
+            231
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks and Kevin Gimpel. A baseline for detecting misclassified and out-of-distribution examples in neural networks. In ICLR, 2017b. ",
+        "bbox": [
+            173,
+            238,
+            825,
+            267
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks, Mantas Mazeika, Duncan Wilson, and Kevin Gimpel. Using trusted data to train deep networks on labels corrupted by severe noise. NIPS, 2018. ",
+        "bbox": [
+            176,
+            275,
+            823,
+            305
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks, Mantas Mazeika, and Thomas Dietterich. Deep anomaly detection with outlier exposure. ICLR, 2019. ",
+        "bbox": [
+            174,
+            313,
+            823,
+            342
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hans-Günter Hirsch. Aurora-5 experimental framework for the performance evaluation of speech recognition in case of a hands-free speech input in noisy environments, 2007. ",
+        "bbox": [
+            174,
+            349,
+            821,
+            380
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hans-Günter Hirsch and David Pearce. The Aurora experimental framework for the performance evaluation of speech recognition systems under noisy conditions. ISCA ITRW ASR2000, 2000. ",
+        "bbox": [
+            174,
+            387,
+            821,
+            417
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hossein Hosseini, Baicen Xiao, and Radha Poovendran. Google’s cloud vision api is not robust to noise, 2017. ",
+        "bbox": [
+            176,
+            424,
+            823,
+            454
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Shichen Liu, Laurens van der Maaten, and Kilian Q Weinberger. Condensenet: An efficient DenseNet using learned group convolutions. arXiv preprint, 2017a. ",
+        "bbox": [
+            174,
+            462,
+            823,
+            492
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2017b. ",
+        "bbox": [
+            173,
+            498,
+            826,
+            541
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Danlu Chen, Tianhong Li, Felix Wu, Laurens van der Maaten, and Kilian Q. Weinberger. Multi-scale dense networks for resource efficient image classification. ICLR, 2018. ",
+        "bbox": [
+            173,
+            549,
+            823,
+            579
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. JMLR, 2015. ",
+        "bbox": [
+            174,
+            587,
+            823,
+            617
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Harini Kannan, Alexey Kurakin, and Ian Goodfellow. Adversarial logit pairing. NIPS, 2018. ",
+        "bbox": [
+            173,
+            625,
+            779,
+            640
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Wei Ke, Michael Maire, and Stella X. Yu. Multigrid neural architectures, 2017. ",
+        "bbox": [
+            169,
+            647,
+            741,
+            664
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chanwoo Kim and Richard M. Stern. Power-normalized cepstral coefficients (PNCC) for robust speech recognition. IEEE/ACM Trans. Audio, Speech and Lang. Proc., 24(7):1315–1329, July 2016. ISSN 2329-9290. ",
+        "bbox": [
+            173,
+            671,
+            826,
+            713
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. NIPS, 2012. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            752
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ravi Kumar and Sergei Vassilvitskii. Generalized distances between rankings, 2010. ",
+        "bbox": [
+            174,
+            760,
+            730,
+            776
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. ICLR, 2017. ",
+        "bbox": [
+            173,
+            782,
+            821,
+            813
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jinyu Li, Li Deng, Yifan Gong, and Reinhold Haeb-Umbach. An overview of noise-robust automatic speech recognition. 2014. ",
+        "bbox": [
+            173,
+            820,
+            823,
+            849
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Fu-Hua Liu, Richard M. Stern, Xuedong Huang, and Alex Acero. Efficient cepstral normalization for robust speech recognition. In Proc. of DARPA Speech and Natural Language Workshop, 1993. ",
+        "bbox": [
+            173,
+            858,
+            823,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Si Liu, Risheek Garrepalli, Thomas Dietterich, Alan Fern, and Dan Hendrycks. Open category detection with PAC guarantees. In ICML, 2018. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jiajun Lu, Hussein Sibai, Evan Fabry, and David Forsyth. Standard detectors aren’t (currently) fooled by physical adversarial stop signs, 2017. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            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. ICLR, 2018. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jan Hendrik Metzen, Tim Genewein, Volker Fischer, and Bastian Bischoff. On detecting adversarial perturbations, 2017. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vikramjit Mitra, Horacio Franco, Richard Stern, Julien Van Hout, Luciana Ferrer, Martin Graciarena, Wen Wang, Dimitra Vergyri, Abeer Alwan, and John H.L. Hansen. Robust features in deep learning based speech recognition, 2017. ",
+        "bbox": [
+            176,
+            215,
+            823,
+            258
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chris Olah, Alexander Mordvintsev, and Ludwig Schubert. Feature visualization. Distill, 2017. ",
+        "bbox": [
+            174,
+            267,
+            799,
+            284
+        ],
+        "page_idx": 10
+    },
+    {
+        "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, 2017. ",
+        "bbox": [
+            173,
+            291,
+            823,
+            321
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephen M. Pizer, E. Philip Amburn, John D. Austin, Robert Cromartie, Ari Geselowitz, Trey Greer, Bart Ter Haar Romeny, and John B. Zimmerman. Adaptive histogram equalization and its variations. Computer Vision, Graphics, and Image Processing, 1987. ",
+        "bbox": [
+            178,
+            329,
+            823,
+            372
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jonas Rauber, Wieland Brendel, and Matthias Bethge. Foolbox v0.8.0: A python toolbox to benchmark the robustness of machine learning models, 2017. ",
+        "bbox": [
+            174,
+            381,
+            823,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do cifar-10 classifiers generalize to cifar-10? arXiv preprint, 2018. ",
+        "bbox": [
+            176,
+            419,
+            821,
+            448
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ludwig Schmidt, Shibani Santurkar, Dimitris Tsipras, Kunal Talwar, and Aleksander Madry. Adversarially robust generalization requires more data. arXiv preprint, 2018. ",
+        "bbox": [
+            176,
+            457,
+            823,
+            486
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lukas Schott, Jonas Rauber, Matthias Bethge, and Wieland Brendel. Towards deep learning models resistant to adversarial attacks. arXiv preprint, 2018. ",
+        "bbox": [
+            174,
+            494,
+            823,
+            523
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jacob Steinhardt, Pang Wei Koh, and Percy Liang. Certified defenses for data poisoning attacks. NIPS, 2017. ",
+        "bbox": [
+            176,
+            531,
+            823,
+            560
+        ],
+        "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, 2014. ",
+        "bbox": [
+            173,
+            569,
+            823,
+            599
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dogancan Temel and Ghassan AlRegib. Traffic signs in the wild: Highlights from the ieee video and image processing cup 2017 student competition. IEEE Signal Processing Magazine, 2018. ",
+        "bbox": [
+            173,
+            607,
+            823,
+            637
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dogancan Temel, Gukyeong Kwon, Mohit Prabhushankar, and Ghassan AlRegib. Cure-tsr: Challenging unreal and real environments for traffic sign recognition. NIPS Workshop, 2017. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            675
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dogancan Temel, Jinsol Lee, and Ghassan AlRegib. Cure-or: Challenging unreal and real environments for object recognition. ICMLA, 2018. ",
+        "bbox": [
+            176,
+            683,
+            821,
+            712
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ángel de la Torre, Antonio Peinado, José Segura, José Pérez-Córdoba, Ma Carmen Benítez, and Antonio Rubio. Histogram equalization of speech representation for robust speech recognition. IEEE Signal Processing Society, 2005. ",
+        "bbox": [
+            173,
+            722,
+            826,
+            765
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Igor Vasiljevic, Ayan Chakrabarti, and Gregory Shakhnarovich. Examining the impact of blur on recognition by convolutional networks, 2016. ",
+        "bbox": [
+            173,
+            773,
+            823,
+            803
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Saining Xie, Ross Girshick, Piotr Dollár, Zhuowen Tu, and Kaiming He. Aggregated residual transformations for deep neural networks. CVPR, 2016. ",
+        "bbox": [
+            173,
+            811,
+            823,
+            840
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephan Zheng, Yang Song, Thomas Leung, and Ian Goodfellow. Improving the robustness of deep neural networks via stability training, 2016. ",
+        "bbox": [
+            173,
+            849,
+            823,
+            878
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A EXAMPLE OF IMAGENET-C SEVERITIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            542,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/4ebc2a59533ab7e5503288d47241397745080192eebfbfb68bc4fc56579b421a.jpg",
+        "image_caption": [
+            "Figure 7: Impulse noise modestly to markedly corrupts a frog, showing our benchmark’s varying severities. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            137,
+            821,
+            233
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In Figure 7, we show the Impulse noise corruption type in five different severities. Clearly, IMAGENETC corruptions can range from negligible to pulverizing. Because of this range, the benchmark comprehensively assesses each corruption type. ",
+        "bbox": [
+            173,
+            292,
+            826,
+            335
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B EXTRA IMAGENET-C CORRUPTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            351,
+            513,
+            367
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/271a75e209df01146ee8e90621b94a2c4bb79515c99306cb6f82ca36d8e8c93d.jpg",
+        "image_caption": [
+            "Figure 8: Extra IMAGENET-C corruption examples are available for model validation and sounder experimentation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            385,
+            820,
+            515
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Directly fitting the types of IMAGENET-C corruptions should be avoided, as it would cause researchers to overestimate a model’s robustness. Therefore, it is incumbent on us to simplify model validation. This is why we provide an additional form of corruption for each of the four general types. These are available for download at https://github.com/hendrycks/robustness. There is one corruption type for each noise, blur, weather, and digital category in the validation set. The first corruption type is speckle noise, an additive noise where the noise added to a pixel tends to be larger if the original pixel intensity is larger. Gaussian blur is a low-pass filter where a blurred pixel is a result of a weighted average of its neighbors, and farther pixels have decreasing weight in this average. Spatter can occlude a lens in the form of rain or mud. Finally, saturate is common in edited images where images are made more or less colorful. See Figure 8 for instances of each corruption type. ",
+        "bbox": [
+            173,
+            577,
+            826,
+            717
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C MORE ON THE IMAGENET-P METRICS AND SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            731,
+            629,
+            747
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For some readers, the following function may be opaque, ",
+        "bbox": [
+            174,
+            758,
+            549,
+            775
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aba13855b2bcd2fbe099e74fa630e0c248f8167713b4b3e838ae082b546d365f.jpg",
+        "text": "$$\nd ( \\tau ( x ) , \\tau ( x ^ { \\prime } ) ) = \\sum _ { i = 1 } ^ { 5 } \\sum _ { j = \\operatorname* { m i n } \\{ i , \\sigma ( i ) \\} + 1 } ^ { \\operatorname* { m a x } \\{ i , \\sigma ( i ) \\} } \\mathbb { 1 } ( 1 \\leq j - 1 \\leq 5 )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            776,
+            681,
+            824
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma = ( \\tau ( x ) ) ^ { - 1 } \\tau ( x ^ { \\prime } )$ and the empty sum is understood to be zero. A high-level view of $d$ is that it computes the deviation between the top-5 predictions of two prediction lists. For simplicity we find the deviation between the identity and $\\sigma$ rather than $\\tau ( x )$ and $\\tau ( x ^ { \\prime } )$ . In consequence we can consider $d ^ { \\prime } ( \\sigma ) : = d ( 1 , \\sigma )$ where 1 the identity permutation. To give some intuition, we provide concrete examples of $d ^ { \\prime }$ on permutations. ",
+        "bbox": [
+            173,
+            825,
+            826,
+            896
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "If $\\sigma$ is the identity, then $d ^ { \\prime } ( \\bar { \\sigma } ) = 0$ .   \nIf $\\sigma = ( 1 , 2 , 3 , 4 , 6 , 5 , 7 , 8 , \\dot { . } . . )$ , $d ^ { \\prime } ( \\sigma ) = 1$ . If $\\sigma = ( 1 , 2 , 3 , 4 , 6 , 7 , 5 , 8 , . . . )$ , $d ^ { \\prime } ( \\sigma ) = 1$ . Once 5 fell out of the top-5, its displacement did not accumulate any further; this may happen when only the top-5 predictions are shown to the user.   \nIf $\\sigma = ( 2 , 1 , 3 , 4 , 5 , 6 , \\dots )$ , $d ^ { \\prime } ( \\sigma ) = \\mathrm { \\bar { 2 } }$ .   \nIf $\\sigma = ( 3 , 1 , 2 , 4 , 5 , 6 , \\dots ) ,$ $d ^ { \\prime } ( \\sigma ) = 4$ .   \nAlso, $d ^ { \\prime } ( ( 2 , 3 , 4 , 5 , 6 , \\dots , 1 ) ) = 5$ .   \nDistinctly, $d ^ { \\prime } ( ( 1 , 2 , 3 , 5 , 6 , 4 , 7 , 8 , . . . ) ) = 2$ .   \nAs a final example, $d ^ { \\prime } ( ( 5 , 4 , 3 , 2 , 1 , 6 , 7 , 8 , 9 , . . . ) ) = 1 2 .$ . ",
+        "bbox": [
+            173,
+            896,
+            455,
+            925
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            826,
+            203
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "It may be that we want perturbation robustness for all predictions, including classes with lesser relevance. In such cases, it is still common that the displacement of the top prediction matters more than themeasure $\\begin{array} { r } { d ^ { \\prime } \\hat { ( \\sigma ) } = \\sum _ { i = 1 } ^ { 1 0 0 0 } w _ { i } \\hat { | } w _ { i } - w _ { \\sigma ( i ) } | } \\end{array}$ ranked cl such that $w _ { i } = 1 / i$ is there are many possibilities, such as the. This uses a Zipfian assumption about the rankings of the classes: the first class is $n$ times as relevant as the nth class. Other possibilities involve using logarithms rather than hyperbolic functions as in the discounted cumulative gain (Kumar & Vassilvitskii, 2010). One could also use the class probabilities provided by the model (should they exist). However such a measure could make it difficult to compare models since some models tend to be more uncalibrated than others (Guo et al., 2017). ",
+        "bbox": [
+            173,
+            208,
+            825,
+            335
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "As progress is made on this task, researchers may be interested in perturbations which are more likely to cause unstable predictions. To accomplish that, researchers can simply compare a frame with the frame two frames ahead rather than just one frame ahead. We provide concrete code of this slight change in the metric at https://github.com/hendrycks/robustness. For nontemporal perturbation sequences, i.e., noise sequences, we provide sequences where the noise perturbation is larger. ",
+        "bbox": [
+            173,
+            342,
+            825,
+            426
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D FULL CORRUPTION ROBUSTNESS RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            441,
+            570,
+            458
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "IMAGENET-C corruption relative robustness results are in Tnormalize Corruption Error values, we now specify the value $\\begin{array} { r } { { \\frac { 1 } { 5 } } \\sum _ { s = 1 } ^ { 5 } E _ { s , \\mathrm { C o r r u p t i o n } } ^ { \\mathrm { A l e x N e t } } } \\end{array}$ e AlexNet errors tofor each corruption type. Gaussian Noise: , Shot Noise: , Impulse Noise: $9 2 . 3 \\%$ , Defocus Blur: $8 2 . 0 \\%$ , Glass Blur: $8 2 . 6 \\%$ , Motion Blur: $7 8 . 6 \\%$ , Zoom Blur: $7 9 . 8 \\%$ , Snow: $8 6 . 7 \\%$ , Frost: $8 2 . 7 \\%$ , Fog: $8 1 . 9 \\%$ , Brightness: $5 6 . 5 \\%$ , Contrast: $8 5 . 3 \\%$ , Elastic Transformation: $6 4 . 6 \\%$ , Pixelate: $7 1 . 8 \\%$ , JPEG: $6 0 . 7 \\%$ , Speckle Noise: $8 4 . 5 \\%$ , Gaussian Blur: $7 8 . 7 \\%$ , Spatter: $7 1 . 8 \\%$ , Saturate: $6 5 . 8 \\%$ . ",
+        "bbox": [
+            173,
+            469,
+            826,
+            571
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/47b1855c83232f878080f2270bb138a1bdd0f6ffcb118f7bccbd02211878f1e6.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td></td><td></td><td>Noise</td><td></td><td></td><td>Blur</td><td></td><td></td><td></td><td>Weather</td><td></td><td></td><td>Digital</td><td></td><td></td></tr><tr><td>Network</td><td>Error</td><td>Rel.mCEGauss.Shot Impulse</td><td></td><td></td><td></td><td>Defocus Glass Motion Zoom</td><td></td><td></td><td></td><td>SnowFrost FogBright</td><td></td><td></td><td></td><td></td><td>Contrast Elastic Pixel JPEG</td><td></td></tr><tr><td>AlexNet</td><td>43.5</td><td>100.0</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100100100</td><td></td><td></td><td>100</td><td>100</td><td>100</td><td>100100</td></tr><tr><td>SqueezeNet</td><td>41.8</td><td>117.9</td><td>118</td><td>116</td><td>114</td><td>104</td><td>110</td><td>106</td><td>105</td><td>106 110 98</td><td></td><td></td><td>101</td><td>100</td><td>126</td><td>129 229</td></tr><tr><td>VGG-11</td><td>31.0</td><td>123.3</td><td>122</td><td>121</td><td>125</td><td>116</td><td>129</td><td>121</td><td>115</td><td>114</td><td>113</td><td>99</td><td>86</td><td>102</td><td>151 161</td><td>174</td></tr><tr><td>VGG-19</td><td>27.6</td><td>122.9</td><td>114</td><td>117</td><td>122</td><td>118</td><td>136</td><td>123</td><td>122</td><td>114</td><td>111</td><td>88</td><td>82</td><td>98</td><td>165 161</td><td>172</td></tr><tr><td>VGG-19+BN1</td><td>25.8</td><td>111.1</td><td>104</td><td>105</td><td>114</td><td>108</td><td>132</td><td>114</td><td>119</td><td>102</td><td>100</td><td>79</td><td>68</td><td>89</td><td>165 125</td><td>144</td></tr><tr><td>ResNet-18</td><td>30.2</td><td>103.9</td><td>104</td><td>106</td><td>111</td><td>100</td><td>116</td><td>108</td><td>112</td><td>103101</td><td></td><td>89</td><td>67</td><td>87</td><td>133 97</td><td>126</td></tr><tr><td>ResNet-50</td><td>23.9</td><td>105.0</td><td>104</td><td>107</td><td>107</td><td>97</td><td>126</td><td>107</td><td>110</td><td>101</td><td>97</td><td>79</td><td>62</td><td>89</td><td>146 111</td><td>132</td></tr></table>",
+        "bbox": [
+            173,
+            583,
+            848,
+            702
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Clean Error, Relative mCE, and Relative Corruption Errors values of different corruptions and architectures on IMAGENET-C. All models are trained on clean ImageNet images, not IMAGENET-C images. Here “BN” abbreviates Batch Normalization (Ioffe & Szegedy, 2015). ",
+        "bbox": [
+            173,
+            718,
+            828,
+            761
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "E FULL PERTURBATION ROBUSTNESS RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            787,
+            584,
+            805
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "IMAGENET-P mFerrors to normali $2 3 . 6 5 \\%$ s are in Table 3,easures, we now $3 0 . 0 6 \\%$ 5D values are in  the value FPAlexPertu $9 . 3 0 \\%$ . Since we use Aor each corrupti $5 . 9 4 \\%$ t. Snow: $1 1 . 9 3 \\%$ , Brightness: $4 . 8 9 \\%$ , Translate: $1 1 . 0 1 \\%$ , Rotate: $1 3 . 1 0 \\%$ , Tilt: $7 . 0 5 \\%$ , Scale: $2 3 . 5 3 \\%$ , Speckle Noise: $1 8 . 6 5 \\%$ , Gaussian Blur: $2 . 7 8 \\%$ , Spatter: $5 . 0 5 \\%$ , Shear: $1 0 . 6 6 \\%$ . Also, the uT5DAlexNetPerturbati on values are as follows. Gaussian Noise: 4.77, Shot Noise: 5.76, Motion Blur: 1.93, Zoom Blur: 1.34, Snow: 2.42, Brightness: 1.19, Translate: 2.63, Rotate: 2.95, ",
+        "bbox": [
+            173,
+            815,
+            828,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/9003c50617d4fb9929e794a5e832519ab4e8fff80e244e827fc16d2244aa1e09.jpg",
+        "table_caption": [
+            "Tilt: 1.75, Scale: 4.48, Speckle Noise: 3.89, Gaussian Blur: 0.70, Spatter: 1.26, Shear: 2.48. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Noise</td><td></td><td colspan=\"3\"></td><td colspan=\"2\">Blur</td><td colspan=\"2\">Weather</td><td colspan=\"3\">Digital</td></tr><tr><td>Network</td><td>Error</td><td>mFR</td><td>Gaussian</td><td>Shot</td><td>Motion</td><td>Zoom</td><td>Snow Bright</td><td>Translate</td><td>Rotate</td><td>Tilt</td><td>Scale</td></tr><tr><td>AlexNet</td><td>43.5</td><td>100.0</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100 100</td><td>100</td><td>100</td><td>100</td><td>100</td></tr><tr><td>SqueezeNet</td><td>41.8</td><td>112.6</td><td>147</td><td>140</td><td>109</td><td>109</td><td>105 110</td><td>101</td><td>103</td><td>109</td><td>93</td></tr><tr><td>VGG-11</td><td>31.0</td><td>74.9</td><td>89</td><td>90</td><td>85</td><td>84</td><td>80 76</td><td>52</td><td>64</td><td>69</td><td>59</td></tr><tr><td>VGG-19</td><td>27.6</td><td>66.9</td><td>75</td><td>76</td><td>82</td><td>84</td><td>73 74</td><td>41</td><td>54</td><td>60</td><td>49</td></tr><tr><td>VGG-19+BN</td><td>25.8</td><td>65.1</td><td>67</td><td>66</td><td>75</td><td>86</td><td>70 72</td><td>45</td><td>56</td><td>56</td><td>51</td></tr><tr><td>ResNet-18</td><td>30.2</td><td>72.8</td><td>74</td><td>73</td><td>75</td><td>85</td><td>75 78</td><td>63</td><td>66</td><td>73</td><td>66</td></tr><tr><td>ResNet-50</td><td>23.9</td><td>58.0</td><td>59</td><td>58</td><td>64</td><td>72</td><td>63 62</td><td>44</td><td>52</td><td>57</td><td>48</td></tr></table>",
+        "bbox": [
+            184,
+            142,
+            813,
+            271
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/ed4692ddeb4ea08788d35ea45629afb30f6486126e8c3dec3d47721537b08802.jpg",
+        "table_caption": [
+            "Table 3: Flip Rates and the mFR values of different perturbations and architectures on IMAGENET-P. All models are trained on clean ImageNet images, not IMAGENET-P images. Here “BN” abbreviates Batch Normalization. ",
+            "Table 4: Top-5 Distances and the mT5D values of different perturbations and architectures on IMAGENET-P. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td></td><td colspan=\"2\">Noise</td><td colspan=\"2\">Blur</td><td colspan=\"2\">Weather</td><td colspan=\"4\">Digital</td></tr><tr><td>Network</td><td>Error</td><td>mT5D</td><td>Gaussian</td><td>Shot</td><td>Motion</td><td>Zoom</td><td>Snow</td><td>Bright</td><td>Translate</td><td>Rotate</td><td>Tilt</td><td>Scale</td></tr><tr><td>AlexNet</td><td>43.5</td><td>100.0</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td></tr><tr><td>SqueezeNet</td><td>41.8</td><td>112.9</td><td>139</td><td>133</td><td>109</td><td>111</td><td>107</td><td>112</td><td>104</td><td>106</td><td>111</td><td>98</td></tr><tr><td>VGG-11</td><td>31.0</td><td>83.9</td><td>98</td><td>97</td><td>93</td><td>90</td><td>87</td><td>85</td><td>63</td><td>75</td><td>79</td><td>71</td></tr><tr><td>VGG-19</td><td>27.6</td><td>78.6</td><td>89</td><td>88</td><td>92</td><td>93</td><td>82</td><td>86</td><td>53</td><td>67</td><td>74</td><td>62</td></tr><tr><td>VGG-19+BN</td><td>25.8</td><td>80.5</td><td>85</td><td>82</td><td>90</td><td>97</td><td>84</td><td>88</td><td>61</td><td>72</td><td>80</td><td>66</td></tr><tr><td>ResNet-18</td><td>30.2</td><td>87.0</td><td>89</td><td>87</td><td>89</td><td>95</td><td>88</td><td>92</td><td>78</td><td>82</td><td>89</td><td>80</td></tr><tr><td>ResNet-50</td><td>23.9</td><td>78.3</td><td>82</td><td>79</td><td>84</td><td>89</td><td>80</td><td>84</td><td>64</td><td>73</td><td>80</td><td>67</td></tr></table>",
+        "bbox": [
+            181,
+            352,
+            818,
+            482
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "F INFORMATIVE ROBUSTNESS ENHANCEMENT ATTEMPTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            553,
+            671,
+            570
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Stability Training. Stability training is a technique to improve the robustness of deep networks (Zheng et al., 2016). The method’s creators found that training on images corrupted with noise can lead to underfitting, so they instead propose minimizing the cross-entropy from the noisy image’s softmax distribution to the softmax of the clean image. The authors evaluated performance on images with subtle differences and suggested that the method provides additional robustness to JPEG corruptions. We fine-tune a ResNet-50 with stability training for five epochs. For training with noisy images, we corrupt images with uniform noise, where the maximum and minimum of the uniform noise is tuned over $\\{ 0 . 0 1 , 0 . 0 5 , 0 . 1 \\}$ , and the stability weight is tuned over $\\{ 0 . 0 1 , 0 . 0 5 , 0 . 1 \\}$ . Across all noise strengths and stability weight combinations, the models with stability training tested on IMAGENET-C have a larger mCEs than the baseline ResNet-50’s mCE. Even on unseen noise corruptions, stability training does not increase robustness. However, the perturbation robustness slightly improves. The best model according to the IMAGENET-P validation set has an mFR of $5 7 \\%$ , while the original ResNet’s mFR is $5 8 \\%$ . An upshot of this failure is that benchmarking robustness-enhancing techniques requires a diverse test set. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            777
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Image Denoising. An approach orthogonal to modifying model representations is to improve the inputs using image restoration techniques. Although general image restoration techniques are not yet mature, denoising restoration techniques are not. We thus attempt restore an image with the denoising technique called non-local means (Buades & Coll, 2005). The amount of denoising applied is determined by the noise estimation technique of Donoho & Johnstone (1993). Therefore clean images receive should nearly no modifications from the restoration method, while noisy images should undergo considerable restoration. We found that denoising increased the mCE from $7 6 . 7 \\%$ to $8 2 . 1 \\%$ . A plausible account is that the non-local means algorithm striped the images of their subtle details even when images lacked noise, despite having the non-local means algorithm governed by the noise estimate. Therefore, the gains in noise robustness were wiped away by subtle blurs to images with other types of corruptions, showing that targeted image restoration can prove harmful for robustness. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "10-Crop Classification. Viewing an object at several different locations may give way to a more stable prediction. Having this intuition in mind, we perform 10-crop classification. 10-crop classification is executed by cropping all four corners and cropping the center of an image. These crops and their horizontal mirrors are processed through a network to produce 10 predicted class probability distributions. We average these distributions to compute the final prediction. Of course, a prediction informed by 10-crops rather than a single central crop is more accurate. Ideally, this revised prediction should be more robust too. However, the gains in mCE do not outpace the gains in accuracy on a ResNet-50. In all, 10-crop classification is a computationally expensive option which contributes to classification accuracy but not noticeably to robustness. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            263
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Smaller Models. All else equal, “simpler” models often generalize better, and “simplicity” frequently translates to model size. Accordingly, smaller models may be more robust. We test this hypothesis with CondenseNets (Huang et al., 2017a). A CondenseNet attains its small size via sparse convolutions and pruned filter weights. An off-the-shelf CondenseNet $C = G = 4 ,$ ) obtains a $2 6 . 3 \\%$ error rate and a $8 0 . 8 \\%$ mCE. On the whole, this CondenseNet is slightly less robust than larger models of similar accuracy. Even more pruning and sparsification yields a CondenseNet ( $C = G = 8$ ) with both deteriorated performance $2 8 . 9 \\%$ error rate) and robustness $8 4 . 6 \\%$ mCE). Here again robustness is worse than larger model robustness. Though models fashioned for mobile devices are smaller and in some sense simpler, this does not improve robustness. ",
+        "bbox": [
+            173,
+            270,
+            825,
+            396
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "G A SEPARATE TYPE OF ROBUSTNESS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            435,
+            509,
+            452
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Another goal for machine learning is to learn the fundamental structure of categories. Broad categories, such as “bird,” have many subtypes, such as “cardinal” or “bluejay.” Humans can observe previously unseen bird species yet still know that they are birds. A test of learned fundamental structure beyond superficial features is subtype robustness. In subtype robustness we test generalization to unseen subtypes which share share essential characteristics of a broader type. We repurpose the ImageNet-22K dataset for a closer investigation into subtype robustness. ",
+        "bbox": [
+            174,
+            472,
+            825,
+            556
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Subtype Robustness. A natural image dataset with a hierarchical taxonomy and numerous types and subtypes is ImageNet-22K, an ImageNet-1K superset. In this subtype robustness experiment, we manually select 25 broad types from ImageNet-22K, listed in the next paragraph. Each broad type has many subtypes. We call a subtype “seen” if and only if it is in ImageNet-1K and a subtype of one of the 25 broad types. The subtype is “unseen” if and only if it is a subtype of the 25 broad types and is from ImageNet-22K but not ImageNet-1K. In this experiment, the correct classification decision for an image of a subtype is the broad type label. We take pre-trained ImageNet-1K classifiers which have not trained on unseen subtypes. Next we fine-tune the last layer of these pre-trained ImageNet-1K classifiers on seen subtypes so that they predict one of 25 broad types. Then, we test the accuracy on images of seen ",
+        "bbox": [
+            174,
+            563,
+            485,
+            840
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/5f0410e3592e5c217096ea491035539be3dd9b5b9f2d67895b26ec23ec61f28f.jpg",
+        "image_caption": [
+            "Figure 9: ImageNet classifiers and their robustness to unseen subtypes. Unseen subtypes of known broad types are noticeably harder for classifiers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            501,
+            566,
+            815,
+            767
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "subtypes and on images of unseen subtypes. Accuracy on unseen subtypes is our measure of subtype robustness. Seen and unseen accuracies are shown in Figure 9, while the ImageNet-1K classification accuracy before fine-tuning is on the horizontal axis. Despite only having 25 classes and having trained on millions of images, these classifiers demonstrate a subtype robustness performance gap that should be far less pronounced. We also observe that the architectures proposed so far hardly deviate from the trendline. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The 25 broad types which we selected from ImageNet are as follows. Amphibian (n01627424), Appliance (n02729837), Aquatic Mammal (n02062017), Bird (n01503061), Bear (n02131653), Beverage (n07881800), Big cat (n02127808), Building (n02913152), Cat (n02121620), Clothing (n03051540), Dog (n02084071), Electronic Equipment (n03278248), Fish (n02512053), Footwear (n03380867), Fruit (n13134947), Fungus (n12992868), Geological Formation (n09287968), Hoofed Animal (n02370806), Insect (n02159955), Musical Instrument (n03800933), Primate (n02469914), Reptile (n01661091), Utensil (n04516672), Vegetable (n07707451), Vehicle (n04576211). ",
+        "bbox": [
+            173,
+            103,
+            826,
+            215
+        ],
+        "page_idx": 15
+    }
+]

parse/train/OP4ePyQXNu-da/OP4ePyQXNu-da.md

@@ -0,0 +1,300 @@
+# On Fast Dropout and its Applicability to Recurrent Networks
+
+# Justin Bayer, Christian Osendorfer, Daniela Korhammer, Nutan Chen, Sebastian Urban and Patrick van der Smagt
+
+Lehrstuhl fur Robotik und Echtzeitsysteme ¨ Fakultat f¨ ur Informatik¨ Technische Universitat M¨ unchen ¨ bayer.justin@googlemail.com, osendorf@in.tum.de, korhammd@in.tum.de, ntchen86@gmail.com, surban@tum.de, smagt@brml.org
+
+# Abstract
+
+Recurrent Neural Networks (RNNs) are rich models for the processing of sequential data. Recent work on advancing the state of the art has been focused on the optimization or modelling of RNNs, mostly motivated by adressing the problems of the vanishing and exploding gradients. The control of overfitting has seen considerably less attention. This paper contributes to that by analyzing fast dropout, a recent regularization method for generalized linear models and neural networks from a back-propagation inspired perspective. We show that fast dropout implements a quadratic form of an adaptive, per-parameter regularizer, which rewards large weights in the light of underfitting, penalizes them for overconfident predictions and vanishes at minima of an unregularized training loss. The derivatives of that regularizer are exclusively based on the training error signal. One consequence of this is the absence of a global weight attractor, which is particularly appealing for RNNs, since the dynamics are not biased towards a certain regime. We positively test the hypothesis that this improves the performance of RNNs on four musical data sets.
+
+# 1 Introduction
+
+Recurrent Neural Networks are among the most powerful models for sequential data. The capabilty of representing any measurable sequence to sequence mapping to arbitrary accuracy (Hammer, 2000) makes them universal approximators. Nevertheless they were given only little attention in the last two decades due to the problems of vanishing and exploding gradients (Hochreiter, 1991; Bengio et al., 1994; Pascanu et al., 2012). Error signals either blowing up or decaying exponentially for events many time steps apart rendered them largely impractical for the exact problems they were supposed to solve. This made successful training impossible on many tasks up until recently without resorting to special architectures or abandoning gradient-based optimization. Successful application on tasks with long-range dependencies has thus relied on one of those two paradigms. The former ist to make use of long short-term memory (LSTM) (Hochreiter and Schmidhuber, 1997). These approaches are among the best methods for the modelling of speech and handwriting (Graves et al., 2013, 2008; Graves, 2013). The latter is to to rely on sensible initializations leading to echo-state networks (Jager et al., 2003). ¨
+
+The publication of (Martens and Sutskever, 2011) can nowadays be considered a landmark, since it was shown that even standard RNNs can be trained with the right optimization method. While a sophisticated Hessian-free optimizer was employed initially, further research (Sutskever et al., 2013; Bengio et al., 2012) has shown that carefully designed first-order methods can find optima of similar quality.
+
+After all, the problem of underfitting standard RNNs can be dealt with to the extent that RNNs are practical in many areas, e.g., language modelling (Sutskever et al., 2011; Mikolov et al., 2010). In contrast, the problem of overfitting in standard RNNs has (due to the lack of necessity) been tackled only by few. As noted in (Pascanu et al., 2012), using priors with a single optima on the parameters may have detrimental effects on the representation capability of RNNs: a global attractor is constructed in parameter space. In the case of a prior with a mode at zero (e.g. an $L 2$ regularizer) this biases the network towards solutions which lets information die out exponentially fast in time, making it impossible to memorize events for an indefinite amount of time.
+
+Graves (2011) proposes to stochastically and adaptively distort the weights of LSTM-based RNNs, which is justified from the perspective of variational Bayes and the minimum description length principle. Overfitting is practically non-existent in the experiments conducted. It is untested whether this approach works well for standard RNNs–along the lines of the observations of Pachitariu and Sahani (2013) one might hypothesize that the injected noise disturbs the dynamics of RNNs too much and leads to divergence during training.
+
+The deep neural network community has recently embraced a regularization method called dropout (Hinton et al., 2012). The gist is to randomly discard units from the network during training, leading to less interdependent feature detectors in the intermediary layers. Here, dropping out merely means to set the output of that unit to zero. An equivalent view is to set the complete outgoing weight vector to zero of which it is questionable whether a straight transfer of dropout to RNNs is possible. The resulting changes to the dynamics of an RNN during every forward pass are quite dramatic. This is the reason why Pachitariu and Sahani (2013) only use dropout on those parts of the RNN which are not dynamic., i.e. the connections feeding from the hidden into the output layer.
+
+Our contribution is to show that using a recent smooth approximation to dropout (Wang and Manning, 2013) regularizes RNNs effectively. Since the approximation is deterministic, we may assert that all dynamic parts of the network operate in reasonable regimes. We show that fast dropout does not keep RNNs from reaching rich dynamics during training, which is not obvious due to the relation of classic dropout to L2 regularization (Wager et al., 2013).
+
+The structure of the paper is as follows. We will first review RNNs and fast dropout (FD) (Wang and Manning, 2013). A novel analysis of the derivatives of fast dropout leads to an interpretation where we can perform a decomposition into a loss based on the average output of a network’s units and a regularizer based on its variance. We will discuss why this is a form that is well suited to RNNs and consequently conduct experiments that confirm our hypothesis.
+
+# 2 Methods
+
+In this section we will first review RNNs and fast dropout. We will then introduce a novel interpretation of what the fast dropout loss constitutes in section 2.2.2 and show relationships to two other regularizers.
+
+# 2.1 Recurrent Neural Networks
+
+We will define RNNs in terms of two components. For one, we are ultimately interested in an output $\mathbf { y }$ , which we can calculate given the parameters $\theta$ of a network and some input $\mathbf { x }$ . Secondly, we want to learn the parameters, which is done by the design and optimization of a function of the parameters $\mathcal { L } ( \boldsymbol { \theta } )$ , commonly dubbed loss, cost, or error function.
+
+Calculating the Output of an RNN Given an input sequence $\mathbf { x } = ( x _ { 1 } , \ldots , x _ { T } ) , x _ { t } \in \mathbb { R } ^ { \kappa }$ we produce an output $\mathbf { y } = ( y _ { 1 } , \dots , y _ { T } ) , y _ { t } \in \mathbb { R } ^ { \omega }$ which is done via an intermediary representation called the hidden state layer ${ \mathbf h } = ( h _ { 1 } , \ldots , h _ { T } ) , h _ { t } \in \mathbb { R } ^ { \gamma } . \ \kappa , \iota$ $\kappa , \omega$ , and $\gamma$ are the dimensionalities of the inputs, outputs, and hidden state at each time step. Each component of the layers is sometimes referred to as a unit or a “neuron”. Depending on the associated layer, these are then input, hidden, or output units. We will also denote the set of units which feed into some unit $i$ as the incoming units of $i$ . The units into which a unit $i$ feeds are called the outgoing units of $i$ . For a recurrent network with a single hidden layer, this is done via iteration of the following equations from $t = 1$ to $T$ :
+
+$$
+\begin{array} { r c l } { { h _ { t } } } & { { = } } & { { f _ { h } ( x _ { t } W _ { \mathrm { i n } } + h _ { t - 1 } W _ { \mathrm { r e c } } + b _ { h } ) , } } \\ { { y _ { t } } } & { { = } } & { { f _ { y } ( h _ { t } W _ { \mathrm { o u t } } + b _ { y } ) , } } \end{array}
+$$
+
+where $\{ W _ { \mathrm { i n } } , W _ { \mathrm { o u t } } , W _ { \mathrm { r e c } } \}$ are weight matrices and $\{ b _ { h } , b _ { y } \}$ bias vectors. These form the set of parameters $\theta$ together with initial hidden state $h _ { 0 }$ . The dimensionalities of all weight matrices, bias vectors, and initial hidden states are determined by the dimensionalities of the input sequences as well as desired hidden layer and output layer sizes. The functions $f _ { h }$ and $f _ { y }$ are so-called transfer functions and mostly coordinate-wise applied nonlinearities. We will call the activations of units pre-synaptic before the application of $f$ and post-synaptic afterwards. Typical choices include the logistic sigmoid $\begin{array} { r } { f ( \xi ) = \frac { 1 } { 1 + \exp ( - \xi ) } } \end{array}$ , tangent hyperbolicus and, more recently, the rectified linear $f ( \xi ) = \operatorname* { m a x } ( \xi , 0 )$ (Zeiler et al., 2013). If we set the recurrent weight matrix $W _ { \mathrm { r e c } }$ to zero, we recover a standard neural network Bishop (1995) applied independently to each time step.
+
+Loss Function and Adaption of Parameters We will restrict ourselves to RNNs for the supervised case, where we are given a data set $\boldsymbol { \mathcal { D } } ~ = ~ \{ ( \mathbf { x } _ { i } , \mathbf { z } _ { i } ) \} _ { i = 1 } ^ { N }$ consisting of $N$ pairs with $\mathbf { \bar { x } } _ { i } ~ \in ~ \mathbb { R } ^ { T \times \kappa }$ and $\mathbf { z } _ { i } ~ \in ~ \mathbb { R } ^ { T \times \omega }$ . Here $T$ refers to the sequence length, which we assume to be constant over the data set. We are interested to adapt the parameters of the network $\theta$ in a way to let each of its outputs $\mathbf { y } _ { i } \in \mathbb { R } ^ { T \times O }$ be close to $\mathbf { z } _ { i }$ . Closeness is typically formulated as a loss function, e.g. the mean squared error $\begin{array} { r } { \mathcal { L } _ { \mathrm { m s e } } ( \boldsymbol { \theta } ) = \sum _ { i } | | \mathbf { z } ^ { ( i ) } - \mathbf { y } ^ { ( i ) } | | _ { 2 } ^ { 2 } } \end{array}$ or the binary cross entropy $\begin{array} { r } { \textstyle \mathcal { L } _ { \mathrm { b c e } } ( \theta ) = \sum _ { i } z ^ { ( i ) } \log y ^ { ( i ) } + ( 1 - z ^ { ( i ) } ) \log ( 1 - y ^ { ( i ) } ) . } \end{array}$ . If a loss $\mathcal { L }$ is locally differentiable, finding good parameters can be performed by gradient-based optimization, such as nonlinear conjugate gradients or stochastic gradient descent. The gradients can be calculated efficiently via back-propagation through time (BPTT) (Rumelhart et al., 1986).
+
+# 2.2 Fast Dropout
+
+In fast dropout (Wang and Manning, 2013), each unit in the network is assumed to be a random variable. To assure tractability, only the first and second moments of those random variables are kept, which suffices for a very good approximation. Since the pre-synaptic activation of each unit is a weighted sum of its incoming units (of which each is dropped out with a certain probability) we can safely assume Gaussianity for those inputs due to the central limit theorem. As we will see, this is sufficient to find efficient ways to propagate the mean and variance through the non-linearity $f$ .
+
+# 2.2.1 Forward propagation
+
+We will now inspect the forward propagation for a layer into a single unit, that is
+
+$$
+\begin{array} { r l } { a = } & { { } ( \mathbf { d } \circ \mathbf { x } ) ^ { T } \mathbf { w } } \\ { y = } & { { } f ( a ) , } \end{array}
+$$
+
+where $\circ$ denotes the element-wise product and $f$ is a non-linear transfer function as before. Let the input layer $\mathbf { x }$ to the unit be Gaussian distributed with diagonal covariance by assumption: $\mathbf { x } \sim$ $\mathcal { N } ( \mu _ { \mathbf { x } } , \sigma _ { \mathbf { x } } ^ { 2 } )$ . Furthermore, we have Bernoulli distributed variables indicating whether an incoming unit is not being dropped out organized in a vector $\mathbf { d }$ with $d _ { i } \sim B ( p )$ , $p$ being the complementary drop out rate. The weight vector w is assumed to be constant.
+
+A neural network will in practice consist of many such nodes, with some of them, the output units, directly contributing to the loss function $\mathcal { L }$ . Others, the input units, will not stem from calculation but come from the data set. Each component of $\mathbf { x }$ represents an incoming unit, which might be an external input to the network or a hidden unit. In general, $y$ will have a complex distribution depending highly on the nature of $f$ . Given that the input to a function $f$ is Gaussian distributed, we obtain the mean and variance of the output as follows:
+
+$$
+\begin{array} { r c l } { \displaystyle \mathbf { E } [ y ] = f _ { \mu } ( a ) } & { = } & { \displaystyle \int f ( x ) \mathcal { N } ( x | \mathbf { E } [ a ] , \mathbf { V } [ a ] ) d x , } \\ { \displaystyle \mathbf { V } [ y ] = f _ { \sigma } ( a ) } & { = } & { \displaystyle \int ( f ( x ) - f _ { \mu } ( a ) ) ^ { 2 } \mathcal { N } ( x | \mathbf { E } [ a ] , \mathbf { V } [ a ] ) d x . } \end{array}
+$$
+
+Forward propagation through the non-linearity $f$ for calculation of the post-synaptic activation can be approximated very well in the case of the logistic sigmoid and the tangent hyperbolicus and done exactly in case of the rectifier (for details, see Wang and Manning (2013)). While the rectifier has been previously reported to be a useful ingredient in RNNs (Bengio et al., 2012) we found that it leads to unstable learning behaviour in preliminary experiments and thus neglected it in this study, solely focusing on the tangent hyperbolicus. Other popular transfer functions, such as the softmax, need to be approximated either via sampling or an unscented transform (Julier and Uhlmann, 1997).
+
+To obtain a Gaussian approximation for $\boldsymbol { a } = ( \mathbf { d } \circ \mathbf { x } ) ^ { T } \mathbf { w }$ , we will use $\hat { a } \sim \mathcal N ( \mathrm { E } [ a ] , \mathrm { V } [ a ] )$ . The mean and variance of $a$ can be obtained as follows. Since $\mathbf { d }$ and $\mathbf { x }$ are independent it follows that
+
+$$
+\mathbf { E } [ a ] = \mathbf { E } [ ( \mathbf { x } \circ \mathbf { d } ) ^ { T } \mathbf { w } ] = ( \mathbf { E } [ \mathbf { x } ] \circ \mathbf { E } [ \mathbf { d } ] ) ^ { T } \mathbf { w } .
+$$
+
+For independent random variables $A$ and $B$ , $\mathbf { V } [ A B ] = \mathbf { V } [ A ] \mathrm { E } [ B ] ^ { 2 } + \mathrm { E } [ A ] ^ { 2 } \mathbf { V } [ B ] + \mathbf { V } [ A ] \mathbf { V } [ B ]$ . If we assume the components of $\mathbf { x }$ to be independent, we can write
+
+$$
+\mathbf { V } [ a ] = ( p ( 1 - p ) \mu _ { \mathbf { x } } ^ { 2 } + p \sigma _ { \mathbf { x } } ^ { 2 } ) ^ { T } \mathbf { w } ^ { 2 } .
+$$
+
+Furthermore the independency assumption is necessary such that the Lyapunov condition is satisfied (Lehmann, 1999) for the the central limit theorem to hold, ensuring that $a$ is approximately Gaussian.
+
+Propagating the mean and the variance through $f$ via $f _ { \mu }$ and $f _ { \sigma }$ suffices for determining the presynaptic moments of the outgoing units. At the output $\mathbf { y }$ of the whole model, we will simplify matters and ignore the variance. Some loss functions take the variance into account (e.g., a Gaussian log-likelihood as done in (Bayer et al., 2013)). Sampling can be a viable alternative as well.
+
+Fast Dropout for RNNs The extension of fast dropout to recurrent networks is straightforward from a technical perspective. First, we note that we can concatenate the input vector at time step $t$ , $x _ { t }$ and the hidden state at the previous layer $h _ { t - 1 }$ into a single vector: $c _ { t } = [ h _ { t - 1 } , x _ { t } ]$ . We obtain a corresponding weight matrix by concatenation of the input to hidden and recurrent weight matrices $W _ { \mathrm { i n } }$ and $W _ { \mathrm { r e c } }$ : $W _ { c } = [ W _ { \mathrm { r e c } } , W _ { \mathrm { i n } } ]$ . We can thus reduce the computation to the step from above.
+
+# 2.2.2 Beyond the Backward Pass: A Regularization Term
+
+Given the forward pass, we used automatic differentiation with Theano (Bergstra et al., 2010) to calculate the gradients. Nevertheless, we will contribute a close inspection of the derivatives. This will prove useful since it makes it possible to interpret fast dropout as an additional regularization term independent of the exact choice of loss function.
+
+Consider a loss $\mathcal { L } ( \mathcal { D } ; \theta )$ which is a function of the data $\mathcal { D }$ and parameters $\theta ^ { 2 }$ . In machine learning, we wish this loss to be minimal under unseen data $\mathcal { D }$ although we only have access to a training set $\mathcal { D } _ { \mathrm { t r a i n } }$ . A typical approach is to optimize another loss $\mathcal { I } ( \mathcal { D } _ { \mathrm { t r a i n } } ; \theta )$ as a proxy in the hope that a good minimum of it will correspond to a good minimum of $\mathcal { L }$ for unseen data. Learning is often done by the optimization of $\mathcal { I } = \mathcal { L } + \mathcal { R }$ , where $\mathcal { R }$ is called a regularizer. A common example of a regularizer is to place a prior on the parameters, in which case it is a function of $\theta$ and corresponds to the log-likelihood of the parameters. For weight decay, this is a spherical Gaussian with inverse scale $\lambda$ , i.e. $\mathcal { R } _ { \mathrm { w d } } ( \theta ) = \lambda | | \dot { \theta | } | _ { 2 } ^ { 2 }$ . Regularizers can be more sophisticated, e.g. Rifai et al. (2011) determine directions in input space to which a model’s outputs should be invariant. More recently, dropout (i.e. non-fast dropout) for generalized linear models has been intepreted as a semi-supervised regularization term encouraging confident predictions by Wager et al. (2013).
+
+While it seems difficult to bring the objective function $\mathcal { I } _ { \mathrm { f d } } ( \mathcal { D } ; \theta )$ of fast dropout into the form of $\mathcal { L } + \mathcal { R }$ , it is possible with the derivatives of each node. For this, we perform back-propagation like calculations.
+
+Let $\boldsymbol { a } = ( \mathbf { d } \circ \mathbf { x } ) ^ { T } \mathbf { w }$ and $y = f ( a )$ be the pre- and post-synaptic activations of a component of a layer in the network. First note that $\partial \mathcal { I } / \partial w _ { i } = \partial \mathcal { I } / \partial a \cdot \partial a / \partial w _ { i }$ according to the chain rule. Since $a$ is a random variable, it will be described in one of two forms. In the case of a Gaussian approximation, we will summarize it in terms of its mean and variance; this approach is used if propagation through $f$ is possible in closed form. In the case of sampling, we will have a single instantiation $\hat { a }$ of the random variable, which we can propagate through $f$ . An analysis of both cases is as follows.
+
+Gaussian approximation We find the derivative of $\mathcal { I }$ with respect to one of its incoming weights $w _ { i }$ to be
+
+$$
+\frac { \partial \mathcal { I } } { \partial w _ { i } } = \frac { \partial \mathcal { I } } { \partial \mathrm { E } [ a ] } \frac { \partial \mathrm { E } [ a ] } { \partial w _ { i } } + \frac { \partial \mathcal { I } } { \partial \mathrm { V } [ a ] } \frac { \partial \mathrm { V } [ a ] } { \partial w _ { i } } .
+$$
+
+We know that $\mathbf { E } [ a ] = ( \mathbf { x } \circ \mathbf { d } ) ^ { T } \mathbf { w }$ and thus $\partial \mathrm { E } [ a ] / \partial w _ { i } = x _ { i } d _ { i }$ . This can be recognized as the standard back-propagation term if we consider the dropout variable $d _ { i }$ as fixed. We will thus define
+
+$$
+\frac { \partial \mathcal { L } ^ { a } } { \partial w _ { i } } : = \frac { \partial \mathcal { T } } { \partial \mathrm { E } [ a ] } \frac { \partial \mathrm { E } [ a ] } { \partial w _ { i } } ,
+$$
+
+and subsequently refer to it as the local derivative of the training loss. The second term can be analysed similarly. We apply the chain-rule once more which yields
+
+$$
+{ \frac { \partial { \mathcal { T } } } { \partial \mathbf { V } [ a ] } } { \frac { \partial \mathbf { V } [ a ] } { \partial w _ { i } } } = \underbrace { { \frac { \partial { \mathcal { T } } } { \partial \mathbf { V } [ a ] } } } _ { : = \delta ^ { a } } { \frac { \partial \mathbf { V } [ a ] } { \partial w _ { i } ^ { 2 } } } { \frac { \partial w _ { i } ^ { 2 } } { \partial w _ { i } } } .
+$$
+
+for which any further simplification of $\delta ^ { a }$ depends on the exact form of $\mathcal { I }$ . The remaining two factors can be written down explicitly, i.e.
+
+$$
+\begin{array} { r c l } { { \displaystyle \frac { \partial { \bf V } [ a ] } { \partial w _ { i } ^ { 2 } } } } & { { = } } & { { p ( 1 - p ) { \bf E } [ x _ { i } ] ^ { 2 } + p { \bf V } [ x _ { i } ] , } } \\ { { \displaystyle \frac { \partial w _ { i } ^ { 2 } } { \partial w _ { i } } } } & { { = } } & { { 2 w _ { i } . } } \end{array}
+$$
+
+Setting
+
+$$
+\begin{array} { r l } { \eta _ { i } ^ { a } : = } & { { } | \delta ^ { a } | \frac { \partial \mathsf { V } [ a ] } { \partial w _ { i } ^ { 2 } } } \\ { = } & { { } | \delta ^ { a } | p \big [ ( 1 - p ) \mathsf { E } [ x _ { i } ] ^ { 2 } + \mathsf { V } [ x _ { i } ] \big ] } \\ { > } & { { } 0 } \end{array}
+$$
+
+we conclude that
+
+$$
+\begin{array} { r c l } { \displaystyle \frac { \partial \mathcal { I } } { \partial \mathbf { V } [ a ] } \frac { \partial \mathbf { V } [ a ] } { \partial w _ { i } } } & { = } & { 2 \operatorname { s g n } ( \delta ^ { a } ) \eta ^ { a } w _ { i } } \\ & & { = : \mathbf { \nabla } \frac { \partial \mathcal { R } _ { \mathrm { a p p r o x } } ^ { a } } { \partial w _ { i } } . } \end{array}
+$$
+
+In alignment with Equation (3) this lets us arrive at
+
+$$
+\frac { \partial \mathcal { I } } { \partial w _ { i } } = \frac { \partial \mathcal { L } ^ { a } } { \partial w _ { i } } + \frac { \partial \mathcal { R } _ { \mathrm { a p p r o x } } ^ { a } } { \partial w _ { i } } ,
+$$
+
+and offers an interpretation of fast dropout as an additive regularization term. An important and limiting aspect of this decomposition is that it only holds locally at $a$ .
+
+We note that depending on the sign of the error signal $\delta ^ { a }$ , fast dropout can take on three different behaviours:
+
+· $\delta ^ { a } = 0$ The error signal is zero and thus the variance of the unit considered to be optimal for the loss. The fast dropout term vanishes; this is especially true at optima of the overall loss.   
+· $\delta ^ { a } < 0$ The unit should increase its variance. The exact interpretation of this depends on the loss, but in many cases this is related to the expectation of the unit being quite erroneous and leads to an increase of scatter of the output. The fast dropout term encourages a quadratic growth of the weights.   
+• $\delta ^ { a } > 0$ The unit should decrease its variance. As before, this depends on the exact loss function but will mostly be related to the expectation of the unit being quite right which makes a reduction of scatter desirable. The fast dropout term encourages a quadratic shrinkage of the weights.
+
+![](images/0abc382d8649749ae7febf295253f49836345dcae0dba65b7e03bce57919314e.jpg)  
+Figure 1: Visualizations of the behaviour of $\delta ^ { a }$ for a single unit. The axes correspond to the presynaptic mean $\operatorname { E } [ a ]$ and variance $\mathrm { v } [ a ]$ feeding into a unit $y = f ( a )$ . A loss measuring the divergence from the target value 0.2 is then applied and indices the color on a logarithmic scale. The gradients of the loss are shown as a vector field plot. Squared error is shown on the left, Gaussian log-likelihood in the middle and Bernoulli log-likelihood on the right. For the first two plots, the optimium is in the middle, for the last it is a little to the left.
+
+This behaviour can be illustrated for output units by numerically inspecting the values and gradients of the pre-synaptic moments given a loss. For that we consider a single unit $y = f ( a )$ and a loss $d ( y , z )$ measuring the divergence of its output to a target value $z$ . The pre-synaptic variance $\mathrm { v } [ a ]$ can enter the loss not at all or in one of two ways, respected by either the loss (see (Bayer et al., 2013)) or the transfer function. Three examples for this are
+
+1. Squared loss on the mean, i.e. $d ( y , z ) = ( \operatorname { E } [ y ] - t ) ^ { 2 }$ with $y = a$ ,   
+2. Gaussian log-likelihood on the moments, i.e. $\begin{array} { r } { d ( y , z ) \propto \frac { \left( \mathrm { E } [ y ] - t \right) ^ { 2 } } { 2 \mathrm { V } [ y ] } + \log \sqrt { 2 \pi \mathrm { V } [ y ] } } \end{array}$ with $y = a ,$   
+3. Negative Bernoulli cross entropy, i.e. $d ( y , z ) = z \log \mathrm { E } [ y ] + ( 1 - z ) \log ( 1 - \mathrm { E } [ y ] )$ with $\begin{array} { r } { y = \frac { 1 } { 1 + \exp ( - a ) } } \end{array}$ .
+
+We visualize the pre-synaptic mean and variance, their gradients and their respective loss values in Figure 1. For the two latter cases, erroneous units first increase the variance, then move towards the correct mean and subsequently reduce the variance.
+
+Sampling An already mentioned alternative to the forward propagation of $\operatorname { E } [ a ]$ and $\mathrm { v } [ a ]$ through $f$ is to incarnate $\hat { a }$ via sampling and calculate $f ( \hat { a } )$ . Let $s \sim \mathcal { N } ( 0 , 1 )$ and $\hat { a } = \mathrm { E } [ a ] + s \sqrt { \mathrm { V } [ a ] }$ . We can then use $\hat { a }$ explicitly and it follows that
+
+$$
+\frac { \partial \mathcal { I } } { \partial \hat { a } } \frac { \partial \hat { a } } { \partial w _ { i } } = \frac { \partial \mathcal { I } } { \partial \hat { a } } \left[ \frac { \partial \hat { a } } { \partial \mathrm { E } [ a ] } \frac { \partial \mathrm { E } [ a ] } { \partial w _ { i } } + \frac { \partial \hat { a } } { \partial \mathrm { V } [ a ] } \frac { \partial \mathrm { V } [ a ] } { \partial w _ { i } } \right] .
+$$
+
+Again, we recognize ${ \partial { \mathcal J } } / { \partial { \hat { a } } } \cdot { \partial { \hat { a } } } / { \partial \mathrm { E } } [ a ] \cdot { \partial \mathrm { E } } [ a ] / { \partial w _ { i } } \ = \ { \partial { \mathcal J } } / { \partial { \hat { a } } } \ x _ { i } d _ { i }$ as the standard backpropagation formula with dropout variables.
+
+The variance term can be written as
+
+$$
+{ \frac { \partial { \mathcal { I } } } { \partial { \hat { a } } } } { \frac { \partial { \mathcal { I } } } { \partial \mathbf { V } [ a ] } } { \frac { \partial \mathbf { V } [ a ] } { \partial w _ { i } } } = { \frac { \partial { \mathcal { I } } } { \partial { \hat { a } } } } { \frac { \partial { \hat { a } } } { \partial { \sqrt { \mathbf { V } [ a ] } } } } { \frac { \partial { \sqrt { \mathbf { V } [ a ] } } } { \partial \mathbf { V } [ a ] } } { \frac { \partial \mathbf { V } [ a ] } { \partial w _ { i } ^ { 2 } } } { \frac { \partial w _ { i } ^ { 2 } } { \partial w _ { i } } }
+$$
+
+which, making use of results from earlier in the section is equivalent to
+
+$$
+\begin{array} { r l r } { \displaystyle \frac { \partial { \mathcal I } } { \partial \hat { a } } \frac { \partial { \mathcal J } } { \partial { \bf V } [ a ] } \frac { \partial { \bf V } [ a ] } { \partial w _ { i } } } & { = } & { \displaystyle \frac { \partial { \mathcal J } } { \partial \hat { a } } \sqrt { p ( 1 - p ) { \bf E } [ x _ { i } ] ^ { 2 } + p { \bf V } [ x _ { i } ] } s . } \end{array}
+$$
+
+The value of this is a zero-centred Gaussian random variable, since $s$ is Gaussian. The scale is independent of the current weight value and only determined by the post-synaptic moments of the incoming unit, the dropout rate and the error signal. We conclude, that also in this case, we can write
+
+$$
+\begin{array} { r c l } { \displaystyle \frac { \partial \mathcal { T } } { \partial w _ { i } } } & { = } & { \displaystyle \frac { \partial \mathcal { L } ^ { a } } { \partial w _ { i } } + \frac { \partial \mathcal { R } _ { \mathrm { d r a w } } ^ { a } } { \partial w _ { i } } , } \end{array}
+$$
+
+where ${ \partial \mathcal { R } _ { \mathrm { d r a w } } ^ { a } } / { \partial \boldsymbol { w } _ { i } }$ is defined as in Equation (4) and essentially an adaptive noise term.
+
+We want to stress the fact that in the approximation as well as in the sampling case the regularization term vanishes at any optima of the training loss. A consequence of this is that no global attractor is formed, which makes the method theoretically useful for RNNs. One might argue that fast dropout should not have a regularizing effect all. Yet, regularization is not only influencing the final solution but also the optimization, leading to different optima.
+
+Relationship to Weight Decay As already mentioned, imposing a Gaussian distribution centred at the origin with precision $\lambda$ as a prior on the weights leads to a method called weight decay. It is not only probabilistically sound but also works well empirically, see e.g. (Bishop et al., 2006). Recalling that the derivative of weight decay is of the form $\partial \mathcal { R } _ { \mathrm { w d } } / \partial w _ { i } = 2 \lambda w _ { i }$ we can reinterpret $\mathcal { R } _ { \mathrm { a p p r o x } }$ as a weight decay term where the coefficient $\lambda$ is weight-wise, dependent on the current activations and possibly negative. Weight decay will always be slightly wrong on the training set, since the derivative of the weight decay term has to match the one of the unregularized loss. In order for $\partial \mathcal { L } / \partial \theta + \partial \mathcal { R } _ { \mathrm { w d } } / \partial \theta$ to be minimal, $\mathcal { L }$ cannot be minimal unless so is $\mathcal { R }$ .
+
+Relationship to Adaptive Weight Noise In this method (Graves, 2011) not the units but the weights are stochastic, which is in pratice implemented by performing Monte Carlo sampling. We can use a similar technique to FD to find a closed form approximation. In this case, a layer is $y = f ( \mathbf { x } ^ { T } \mathbf { w } )$ , where we have no dropout variables and the weights are Gaussian distributed with $\begin{array} { r } { \mathbf { \ d } \mathbf { \ b { v } } \sim \mathcal { N } ( \mu _ { \mathbf { w } } , \sigma _ { \mathbf { w } } ^ { 2 } ) . } \end{array}$ , with covariance diagonal and organized into a vector. We assume Gaussian density for $a = \mathbf { x } ^ { T } \mathbf { w }$ . Using similar algebra as above, we find that
+
+$$
+\begin{array} { r c l } { \mathbf { E } [ a ] } & { = } & { \boldsymbol { \mu } _ { \mathbf { x } } ^ { T } \boldsymbol { \mu } _ { \mathbf { w } } , } \\ { \mathbf { V } [ a ] } & { = } & { \boldsymbol { \sigma } _ { \mathbf { x } } ^ { 2 T } \boldsymbol { \mu } _ { \mathbf { w } } ^ { 2 } + \boldsymbol { \sigma } _ { \mathbf { x } } ^ { 2 T } \boldsymbol { \sigma } _ { \mathbf { w } } ^ { 2 } + \boldsymbol { \mu } _ { \mathbf { x } } ^ { 2 T } \boldsymbol { \sigma } _ { \mathbf { w } } ^ { 2 } . } \end{array}
+$$
+
+It is desirable to determine whether fast dropout and “fast adaptive weight noise” are special cases of each other. Showing that the aproaches are different can be done by equating equations (1) and (5) and solving for $\mu _ { \mathbf { w } }$ . This shows that rescaling by $1 - p$ suffices in the case of the expectation. It is however not as simple as that for the variance, i.e. for equations (2) and (6), where the solution depends on $\mu _ { \mathbf { x } }$ and $\sigma _ { \mathbf { x } } ^ { \hat { 2 } }$ and thus is not independent of the input to the network. Yet, both methods share the property that no global attractor is present in the loss: the “prior” is part of the optimization and not fixed.
+
+# 2.3 Bag of Tricks
+
+Throughout the experiments we will resort to several “tricks” that have been introduced recently for more stable and efficient optimization of neural networks and RNNs especially. First, we make use of rmsprop (Tieleman and Hinton, 2012), an optimizer which divides the gradient by an exponential moving average of its squares. This approach is similar to Adagrad (Duchi et al., 2011), which uses a window based average. We found that enhancing rmsprop with Nesterov’s accelerated gradient (Sutskever, 2013) greatly reduces the training time in preliminary experiments.
+
+To initialize the RNNs to stable dynamics we followed the initialization protocol of (Sutskever et al., 2013) of setting the spectral radius $\rho$ to a specific value and the maximum amount of incoming connections of a unit to $\nu$ ; we did not find it necessary to centre the inputs and outputs. The effect of not only using the recurrent weight matrix for propagating the states through time but also its element-wise square for advancing the variances can be quantified. The stability of a network is coupled to the spectral radius of the recurrent weight matrix $\rho ( W _ { \mathrm { r e c } } )$ ; thus, the stability of forward propagating the variance is related to the spectral radius of its element-wise square $\rho ( W _ { \mathrm { r e c } } ^ { 2 } )$ . Since $\rho ( A B ) \le \rho ( A ) \rho ( B )$ for non-negative matrices and non-singular matrices $A$ and $B$ (Horn and Johnson, 2012), setting $W _ { \mathrm { r e c } }$ to full rank and its spectral radius to $\rho ( W _ { \mathrm { r e c } } )$ assures $\rho ( W _ { \mathrm { r e c } } ^ { 2 } ) = \rho ( | W _ { \mathrm { r e c } } | ^ { 2 } ) \leq \rho ( W _ { \mathrm { r e c } } ) ^ { 2 }$ , where $| \cdot |$ denotes taking the absolute value element-wise. We also use the gradient clipping method introduced in (Pascanu et al., 2012), with a fixed threshold of 225.
+
+Since the hidden-to-hidden connections and the hidden-to-output connections in an RNN can make use of hidden units in quite distinct ways, we found it beneficial to separate the dropout rates. Specifically, a hidden unit may have a different probability to be dropped out when feeding into
+
+Table 1: Results on the midi data sets. All numbers are average negative log-likelihoods on the test set, where “FD” represents our work; “plain” and “RNN-NADE” results are from (Bengio et al., 2012) while “Deep RNN“ shows the best results from (Pascanu et al., 2013). Note that “RNN-NADE” and “Deep RNN“ employ various extensions of the model structure of this work, i.e. structured outputs and various forms of depths. Our results are the best for the shallow RNN model considered in this work.
+
+<table><tr><td>Data set</td><td>FD</td><td>plain</td><td>RNN-NADE</td><td>Deep RNN</td></tr><tr><td>Piano-midi.de</td><td>7.39</td><td>7.58</td><td>7.05</td><td>1</td></tr><tr><td>Nottingham</td><td>3.09</td><td>3.43</td><td>2.31</td><td>2.95</td></tr><tr><td>MuseData</td><td>6.75</td><td>6.99</td><td>5.60</td><td>6.59</td></tr><tr><td>JSBChorales</td><td>8.01</td><td>8.58</td><td>5.19</td><td>7.92</td></tr></table>
+
+the hidden layer at the next time step than when feeding into the output layer. Taking this one step further, we also consider networks in which we completely neglect fast dropout for the hidden-tooutput connections; an ordinary forward pass is used instead. Note that this is not the same as setting the dropout rate to zero, since the variance of the incoming units is completely neglected. Whether this is done is treated as another hyperparameter for the experiment.
+
+# 3 Experiments and Results
+
+# 3.1 Musical Data
+
+All experiments were done by performing a random search (Bergstra and Bengio, 2012) over the hyper parameters (see Table 2 in the Appendix for an overview), where 32 runs were performed for each data set. We report the test loss of the model with the lowest validation error over all training runs, using the same split as in (Bengio et al., 2012). To improve speed, we organize sequences into minibatches by first splitting all sequences of the training and validation set into chunks of length of 100. Zeros are prepended to those sequences which have less than 100 time steps. The test error is reported on the unsplitted sequences.
+
+Training RNNs to generatively model polyphonic music is a valuable benchmark for RNNs due to its high dimensionality and the presense of long as well as short term dependencies. This data set has been evaluated previously by Bengio et al. (2012) where the model achieving the best results, RNN-NADE (Boulanger-Lewandowski et al., 2013), makes specific assumptions about the data (i.e. binary observables). RNNs do not attach any assumptions to the inputs.
+
+# 3.1.1 Setup
+
+The data consists of four distinct data sets, namely Piano-midi.de (classical piano music), Nottingham (folk music), MuseData (orchestral) and JSBChorales (chorales by Johann Sebastian Bach). Each has a dimensionality of 88 per time step organized into different piano rolls which are sequences of binary vectors; each component of these vectors indicates whether a note is occuring at the given time step. We use the RNN’s output to model the sufficient statistics of a Bernoulli random variable, i.e.
+
+$$
+p ( x _ { t , i } | \mathbf { x } _ { 1 : t - 1 } ) = y _ { t , i } ,
+$$
+
+which describes the probability that note $i$ is present at time step $t$ . The output non-linearity $f _ { y }$ of the network is a sigmoid which projects the points to the interval $( 0 , 1 )$ . We perform learning by the minimization of the average negative log-likelihood (NLL); in this case, this is the average binary cross-entropy
+
+$$
+\mathcal { L } ( \boldsymbol { \theta } ) = \frac { 1 } { T - 1 } \frac { 1 } { N } \sum _ { i , t , k } x _ { t , i } ^ { ( k ) } \log y _ { t - 1 , i } ^ { ( k ) } + ( 1 - x _ { t , i } ^ { ( k ) } ) \log ( 1 - y _ { t - 1 , i } ^ { ( k ) } ) ,
+$$
+
+where $k$ indices the training sample, $i$ the component of the target and $t$ the time step.
+
+![](images/a4d9408295c1be22bcd0692eb5fe92b702156f3032f2e875a43922a0f773c817.jpg)  
+Figure 2: Spectral radius over the training process. It increases first and then slowly decreases until a certain value is reached. We did not observe this behaviour when training plain RNNs.
+
+# 3.1.2 Results
+
+Although a common metric for evaluating the performance of such benchmarks is that of accuracy (Bay et al., 2009) we restrict ourselves to that of the NLL–the measure of accuracy is not what is optimized and to which the NLL is merely a proxy. We present the results of FD-RNNs compared with the various other methods in Table 1. Our method is only surpassed by methods which either incorporate more specific assumptions of the data or employ various forms of depth (BoulangerLewandowski et al., 2013; Pascanu et al., 2013). We want to stress that we performed only 32 runs for each data set once more. This shows the relative ease to obtain good results despite of the huge space of potential hyper parameters.
+
+One additional observation is the range of the Eigenvalues of the recurrent weight matrix $W _ { \mathrm { r e c } }$ during training. We performed an additional experiment on JSBChorales where we inspected the Eigenvalues and and the test loss. We found that the spectral radius first increases sharply to a rather high value and then decreases slowly to settle to a specific value. We tried to replicate this behaviour in plain RNNs, but found that RNNs never exceeded a certain spectral radius at which they stuck. This stands in line with the observation from Section 2.2.2 that weights are encouraged to grow when the error is high and shrink during convergence to the optimum. See Figure 2 for a plot of the spectral radius $\rho ( W _ { \mathrm { r e c } } )$ over the training process stages.
+
+# 4 Conclusion
+
+We have contributed to the field of neural networks in two ways. First, we have analysed a fast approximation of the dropout regularization method by bringing its derivative into the same form as that of a loss regularized with an additive term. We have used this form to gain further insights upon the behaviour of fast dropout for neural networks in general and shown that this objective function does not bias the solutions to those which perform suboptimal on the unreguarized loss. Second, we have hypothesized that this is beneficial especially for RNNs We confirmed this hypothesis by conducting quantitative experiments on an already established benchmark used in the context of learning recurrent networks.
+
+# References
+
+Bay, M., Ehmann, A. F., and Downie, J. S. (2009). Evaluation of multiple-f0 estimation and tracking systems. In ISMIR, pages 315–320.   
+Bayer, J., Osendorfer, C., Urban, S., et al. (2013). Training neural networks with implicit variance. In Proceedings of the 20th International Conference on Neural Information Processing , ICONIP2013.   
+Bengio, Y., Boulanger-Lewandowski, N., and Pascanu, R. (2012). Advances in optimizing recurrent networks. arXiv preprint arXiv:1212.0901.   
+Bengio, Y., Simard, P., and Frasconi, P. (1994). Learning long-term dependencies with gradient descent is difficult. Neural Networks, IEEE Transactions on, 5(2):157–166.   
+Bergstra, J. and Bengio, Y. (2012). Random search for hyper-parameter optimization. The Journal of Machine Learning Research, 13:281–305.   
+Bergstra, J., Breuleux, O., Bastien, F., Lamblin, P., Pascanu, R., Desjardins, G., Turian, J., WardeFarley, D., and Bengio, Y. (2010). Theano: a CPU and GPU math expression compiler. In Proceedings of the Python for Scientific Computing Conference (SciPy). Oral Presentation.   
+Bishop, C. M. (1995). Neural networks for pattern recognition. Oxford university press.   
+Bishop, C. M. et al. (2006). Pattern recognition and machine learning, volume 1. springer New York.   
+Boulanger-Lewandowski, N., Bengio, Y., and Vincent, P. (2013). High-dimensional sequence transduction. In ICASSP.   
+Duchi, J., Hazan, E., and Singer, Y. (2011). Adaptive subgradient methods for online learning and stochastic optimization. The Journal of Machine Learning Research, 999999:2121–2159.   
+Graves, A. (2011). Practical variational inference for neural networks. In Advances in Neural Information Processing Systems, pages 2348–2356.   
+Graves, A. (2013). Generating sequences with recurrent neural networks. arXiv preprint arXiv:1308.0850.   
+Graves, A., Fernandez, S., Liwicki, M., Bunke, H., and Schmidhuber, J. (2008). Unconstrained ´ online handwriting recognition with recurrent neural networks. Advances in Neural Information Processing Systems, 20:1–8.   
+Graves, A., Mohamed, A.-r., and Hinton, G. (2013). Speech recognition with deep recurrent neural networks. arXiv preprint arXiv:1303.5778.   
+Hammer, B. (2000). On the approximation capability of recurrent neural networks. Neurocomputing, 31(1):107–123.   
+Hinton, G. E., Srivastava, N., Krizhevsky, A., Sutskever, I., and Salakhutdinov, R. R. (2012). Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580.   
+Hochreiter, S. (1991). Untersuchungen zu dynamischen neuronalen netzen. Master’s thesis, Institut fur Informatik, Technische Universit ¨ at, M ¨ unchen ¨ .   
+Hochreiter, S. and Schmidhuber, J. (1997). Long short-term memory. Neural computation, 9(8):1735–1780.   
+Horn, R. A. and Johnson, C. R. (2012). Matrix analysis. Cambridge university press.   
+Jager, H. et al. (2003). Adaptive nonlinear system identification with echo state networks. ¨ networks, 8:9.   
+Julier, S. J. and Uhlmann, J. K. (1997). New extension of the kalman filter to nonlinear systems. In AeroSense’97, pages 182–193. International Society for Optics and Photonics.   
+Lehmann, E. L. (1999). Elements of large-sample theory. Springer Verlag.   
+Martens, J. and Sutskever, I. (2011). Learning recurrent neural networks with hessian-free optimization. Proc. 28th Int. Conf. on Machine Learning.   
+Mikolov, T., Karafiat, M., Burget, L., Cernocky, J., and Khudanpur, S. (2010). Recurrent neural ´ network based language model. Proceedings of Interspeech.   
+Pachitariu, M. and Sahani, M. (2013). Regularization and nonlinearities for neural language models: when are they needed? arXiv preprint arXiv:1301.5650.   
+Pascanu, R., Gulcehre, C., Cho, K., and Bengio, Y. (2013). How to construct deep recurrent neural networks. arXiv preprint arXiv:1312.6026.   
+Pascanu, R., Mikolov, T., and Bengio, Y. (2012). On the difficulty of training recurrent neural networks. Technical report, Technical Report.   
+Rifai, S., Dauphin, Y. N., Vincent, P., Bengio, Y., and Muller, X. (2011). The manifold tangent classifier. In Advances in Neural Information Processing Systems, pages 2294–2302.   
+Rumelhart, D. E., Hinton, G. E., and Williams, R. J. (1986). Learning representations by backpropagating errors. Nature, 323(6088):533–536.
+
+Table 2: Hyper parameter ranges and parameter distributions for the musical data sets.   
+
+<table><tr><td>Hyper parameter #hidden layers</td><td>Choices 1</td></tr><tr><td>#hidden units Transfer function p(&quot;dropout input&quot;) p(&quot;dropout hidden to hidden&quot;) p(&quot;dropout hidden to output&quot;) Use fast dropout for final layer Step rate Momentum Decay W Win bh</td><td>200,400,600 tanh 0.0, 0.1, 0.2 0.0, 0.1, 0.2, 0.3,0.4, 0.5 0.0, 0.2,0.5 yes,no 0.01,0.005,0.001,0.0005,0.0001,0.00001 0.0,0.9,0.95,0.99,0.995 0.8,0.9 N(0,σ²),0² ∈ {0.1,0.01,0.001,0.0001} N(0,σ²),g² ∈ {0.1,0.01,0.001,0.0001}</td></tr></table>
+
+Sutskever, I. (2013). Training Recurrent Neural Networks. PhD thesis, University of Toronto.
+
+Sutskever, I., Martens, J., Dahl, G., and Hinton, G. (2013). On the importance of initialization and momentum in deep learning.   
+Sutskever, I., Martens, J., and Hinton, G. (2011). Generating text with recurrent neural networks. Proceedings of the 2011 International Conference on Machine Learning (ICML-2011).   
+Tieleman, T. and Hinton, G. (2012). Lecture 6.5 - rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning.   
+Wager, S., Wang, S., and Liang, P. (2013). Dropout training as adaptive regularization. arXiv preprint arXiv:1307.1493.   
+Wang, S. and Manning, C. (2013). Fast dropout training. In Proceedings of the 30th International Conference on Machine Learning (ICML-13), pages 118–126.   
+Zeiler, M., Ranzato, M., Monga, R., Mao, M., Yang, K., Le, Q., Nguyen, P., Senior, A., Vanhoucke, V., Dean, J., et al. (2013). On rectified linear units for speech processing. ICASSP.
+
+# 5 Appendix
+
+# 5.1 Hyper Parameters for Musical Data Experiments
+
+We show the hyper parameters ranges for the musical data in Table 2. The ones from which the numbers in Table 1 resulted are given in Table 3.
+
+Table 3: Hyper parameters used for the musical data experiments.   
+
+<table><tr><td>Hyper parameter</td><td>Piano-midi.de</td><td>Nottingham</td><td>MuseData</td><td>JSBChorales</td></tr><tr><td>#hidden units</td><td>600</td><td>400</td><td>600</td><td>400</td></tr><tr><td>p(&quot;dropout input&quot;)</td><td>0.1</td><td>0.1</td><td>0.2</td><td>0.1</td></tr><tr><td>p(&quot;dropout hidden to hidden&quot;)</td><td>0.3</td><td>0.4</td><td>0.3</td><td>0.2</td></tr><tr><td>p(&quot;dropout hidden to output&quot;)</td><td>1</td><td>0.0</td><td>0.0</td><td>0.5</td></tr><tr><td>Use fast dropout for final layer</td><td>no</td><td>yes</td><td>yes</td><td>yes</td></tr><tr><td>Step rate</td><td>0.005</td><td>0.001</td><td>0.0005</td><td>0.001</td></tr><tr><td>Momentum</td><td>0.995</td><td>0.99</td><td>0.995</td><td>0.99</td></tr><tr><td>Decay</td><td>0.8</td><td>0.9</td><td>0.9</td><td>0.8</td></tr><tr><td>g² for Wrec, Wout</td><td>0.1</td><td>0.001</td><td>0.1</td><td>0.0001</td></tr><tr><td>g² for Win</td><td>0.0001</td><td>0.1</td><td>0.0001</td><td>0.01</td></tr><tr><td>p(Wrec)</td><td>1.2</td><td>1.2</td><td>1.2</td><td>1.2</td></tr><tr><td>V</td><td>25</td><td>no</td><td>no</td><td>15</td></tr></table>

parse/train/OP4ePyQXNu-da/OP4ePyQXNu-da_content_list.json

@@ -0,0 +1,1311 @@
+[
+    {
+        "type": "text",
+        "text": "On Fast Dropout and its Applicability to Recurrent Networks ",
+        "text_level": 1,
+        "bbox": [
+            189,
+            133,
+            810,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Justin Bayer, Christian Osendorfer, Daniela Korhammer, Nutan Chen, Sebastian Urban and Patrick van der Smagt ",
+        "text_level": 1,
+        "bbox": [
+            316,
+            234,
+            718,
+            262
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Lehrstuhl fur Robotik und Echtzeitsysteme ¨ Fakultat f¨ ur Informatik¨ Technische Universitat M¨ unchen ¨ bayer.justin@googlemail.com, osendorf@in.tum.de, korhammd@in.tum.de, ntchen86@gmail.com, surban@tum.de, smagt@brml.org ",
+        "bbox": [
+            183,
+            263,
+            849,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            367,
+            535,
+            383
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recurrent Neural Networks (RNNs) are rich models for the processing of sequential data. Recent work on advancing the state of the art has been focused on the optimization or modelling of RNNs, mostly motivated by adressing the problems of the vanishing and exploding gradients. The control of overfitting has seen considerably less attention. This paper contributes to that by analyzing fast dropout, a recent regularization method for generalized linear models and neural networks from a back-propagation inspired perspective. We show that fast dropout implements a quadratic form of an adaptive, per-parameter regularizer, which rewards large weights in the light of underfitting, penalizes them for overconfident predictions and vanishes at minima of an unregularized training loss. The derivatives of that regularizer are exclusively based on the training error signal. One consequence of this is the absence of a global weight attractor, which is particularly appealing for RNNs, since the dynamics are not biased towards a certain regime. We positively test the hypothesis that this improves the performance of RNNs on four musical data sets. ",
+        "bbox": [
+            233,
+            400,
+            764,
+            608
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            635,
+            310,
+            651
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recurrent Neural Networks are among the most powerful models for sequential data. The capabilty of representing any measurable sequence to sequence mapping to arbitrary accuracy (Hammer, 2000) makes them universal approximators. Nevertheless they were given only little attention in the last two decades due to the problems of vanishing and exploding gradients (Hochreiter, 1991; Bengio et al., 1994; Pascanu et al., 2012). Error signals either blowing up or decaying exponentially for events many time steps apart rendered them largely impractical for the exact problems they were supposed to solve. This made successful training impossible on many tasks up until recently without resorting to special architectures or abandoning gradient-based optimization. Successful application on tasks with long-range dependencies has thus relied on one of those two paradigms. The former ist to make use of long short-term memory (LSTM) (Hochreiter and Schmidhuber, 1997). These approaches are among the best methods for the modelling of speech and handwriting (Graves et al., 2013, 2008; Graves, 2013). The latter is to to rely on sensible initializations leading to echo-state networks (Jager et al., 2003). ¨ ",
+        "bbox": [
+            174,
+            666,
+            825,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The publication of (Martens and Sutskever, 2011) can nowadays be considered a landmark, since it was shown that even standard RNNs can be trained with the right optimization method. While a sophisticated Hessian-free optimizer was employed initially, further research (Sutskever et al., 2013; Bengio et al., 2012) has shown that carefully designed first-order methods can find optima of similar quality. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "After all, the problem of underfitting standard RNNs can be dealt with to the extent that RNNs are practical in many areas, e.g., language modelling (Sutskever et al., 2011; Mikolov et al., 2010). In contrast, the problem of overfitting in standard RNNs has (due to the lack of necessity) been tackled only by few. As noted in (Pascanu et al., 2012), using priors with a single optima on the parameters may have detrimental effects on the representation capability of RNNs: a global attractor is constructed in parameter space. In the case of a prior with a mode at zero (e.g. an $L 2$ regularizer) this biases the network towards solutions which lets information die out exponentially fast in time, making it impossible to memorize events for an indefinite amount of time. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Graves (2011) proposes to stochastically and adaptively distort the weights of LSTM-based RNNs, which is justified from the perspective of variational Bayes and the minimum description length principle. Overfitting is practically non-existent in the experiments conducted. It is untested whether this approach works well for standard RNNs–along the lines of the observations of Pachitariu and Sahani (2013) one might hypothesize that the injected noise disturbs the dynamics of RNNs too much and leads to divergence during training. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The deep neural network community has recently embraced a regularization method called dropout (Hinton et al., 2012). The gist is to randomly discard units from the network during training, leading to less interdependent feature detectors in the intermediary layers. Here, dropping out merely means to set the output of that unit to zero. An equivalent view is to set the complete outgoing weight vector to zero of which it is questionable whether a straight transfer of dropout to RNNs is possible. The resulting changes to the dynamics of an RNN during every forward pass are quite dramatic. This is the reason why Pachitariu and Sahani (2013) only use dropout on those parts of the RNN which are not dynamic., i.e. the connections feeding from the hidden into the output layer. ",
+        "bbox": [
+            174,
+            313,
+            825,
+            424
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contribution is to show that using a recent smooth approximation to dropout (Wang and Manning, 2013) regularizes RNNs effectively. Since the approximation is deterministic, we may assert that all dynamic parts of the network operate in reasonable regimes. We show that fast dropout does not keep RNNs from reaching rich dynamics during training, which is not obvious due to the relation of classic dropout to L2 regularization (Wager et al., 2013). ",
+        "bbox": [
+            174,
+            431,
+            823,
+            501
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The structure of the paper is as follows. We will first review RNNs and fast dropout (FD) (Wang and Manning, 2013). A novel analysis of the derivatives of fast dropout leads to an interpretation where we can perform a decomposition into a loss based on the average output of a network’s units and a regularizer based on its variance. We will discuss why this is a form that is well suited to RNNs and consequently conduct experiments that confirm our hypothesis. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            577
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Methods ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            607,
+            277,
+            625
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section we will first review RNNs and fast dropout. We will then introduce a novel interpretation of what the fast dropout loss constitutes in section 2.2.2 and show relationships to two other regularizers. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            688
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Recurrent Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            714,
+            406,
+            729
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We will define RNNs in terms of two components. For one, we are ultimately interested in an output $\\mathbf { y }$ , which we can calculate given the parameters $\\theta$ of a network and some input $\\mathbf { x }$ . Secondly, we want to learn the parameters, which is done by the design and optimization of a function of the parameters $\\mathcal { L } ( \\boldsymbol { \\theta } )$ , commonly dubbed loss, cost, or error function. ",
+        "bbox": [
+            174,
+            744,
+            825,
+            800
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Calculating the Output of an RNN Given an input sequence $\\mathbf { x } = ( x _ { 1 } , \\ldots , x _ { T } ) , x _ { t } \\in \\mathbb { R } ^ { \\kappa }$ we produce an output $\\mathbf { y } = ( y _ { 1 } , \\dots , y _ { T } ) , y _ { t } \\in \\mathbb { R } ^ { \\omega }$ which is done via an intermediary representation called the hidden state layer ${ \\mathbf h } = ( h _ { 1 } , \\ldots , h _ { T } ) , h _ { t } \\in \\mathbb { R } ^ { \\gamma } . \\ \\kappa , \\iota$ $\\kappa , \\omega$ , and $\\gamma$ are the dimensionalities of the inputs, outputs, and hidden state at each time step. Each component of the layers is sometimes referred to as a unit or a “neuron”. Depending on the associated layer, these are then input, hidden, or output units. We will also denote the set of units which feed into some unit $i$ as the incoming units of $i$ . The units into which a unit $i$ feeds are called the outgoing units of $i$ . For a recurrent network with a single hidden layer, this is done via iteration of the following equations from $t = 1$ to $T$ : ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            103,
+            795,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7e8ff902d7b51bcaadf0f5f56804dd1611127c52e37824027fe37a12effb6262.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { h _ { t } } } & { { = } } & { { f _ { h } ( x _ { t } W _ { \\mathrm { i n } } + h _ { t - 1 } W _ { \\mathrm { r e c } } + b _ { h } ) , } } \\\\ { { y _ { t } } } & { { = } } & { { f _ { y } ( h _ { t } W _ { \\mathrm { o u t } } + b _ { y } ) , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            126,
+            624,
+            164
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\{ W _ { \\mathrm { i n } } , W _ { \\mathrm { o u t } } , W _ { \\mathrm { r e c } } \\}$ are weight matrices and $\\{ b _ { h } , b _ { y } \\}$ bias vectors. These form the set of parameters $\\theta$ together with initial hidden state $h _ { 0 }$ . The dimensionalities of all weight matrices, bias vectors, and initial hidden states are determined by the dimensionalities of the input sequences as well as desired hidden layer and output layer sizes. The functions $f _ { h }$ and $f _ { y }$ are so-called transfer functions and mostly coordinate-wise applied nonlinearities. We will call the activations of units pre-synaptic before the application of $f$ and post-synaptic afterwards. Typical choices include the logistic sigmoid $\\begin{array} { r } { f ( \\xi ) = \\frac { 1 } { 1 + \\exp ( - \\xi ) } } \\end{array}$ , tangent hyperbolicus and, more recently, the rectified linear $f ( \\xi ) = \\operatorname* { m a x } ( \\xi , 0 )$ (Zeiler et al., 2013). If we set the recurrent weight matrix $W _ { \\mathrm { r e c } }$ to zero, we recover a standard neural network Bishop (1995) applied independently to each time step. ",
+        "bbox": [
+            173,
+            167,
+            825,
+            299
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Loss Function and Adaption of Parameters We will restrict ourselves to RNNs for the supervised case, where we are given a data set $\\boldsymbol { \\mathcal { D } } ~ = ~ \\{ ( \\mathbf { x } _ { i } , \\mathbf { z } _ { i } ) \\} _ { i = 1 } ^ { N }$ consisting of $N$ pairs with $\\mathbf { \\bar { x } } _ { i } ~ \\in ~ \\mathbb { R } ^ { T \\times \\kappa }$ and $\\mathbf { z } _ { i } ~ \\in ~ \\mathbb { R } ^ { T \\times \\omega }$ . Here $T$ refers to the sequence length, which we assume to be constant over the data set. We are interested to adapt the parameters of the network $\\theta$ in a way to let each of its outputs $\\mathbf { y } _ { i } \\in \\mathbb { R } ^ { T \\times O }$ be close to $\\mathbf { z } _ { i }$ . Closeness is typically formulated as a loss function, e.g. the mean squared error $\\begin{array} { r } { \\mathcal { L } _ { \\mathrm { m s e } } ( \\boldsymbol { \\theta } ) = \\sum _ { i } | | \\mathbf { z } ^ { ( i ) } - \\mathbf { y } ^ { ( i ) } | | _ { 2 } ^ { 2 } } \\end{array}$ or the binary cross entropy $\\begin{array} { r } { \\textstyle \\mathcal { L } _ { \\mathrm { b c e } } ( \\theta ) = \\sum _ { i } z ^ { ( i ) } \\log y ^ { ( i ) } + ( 1 - z ^ { ( i ) } ) \\log ( 1 - y ^ { ( i ) } ) . } \\end{array}$ . If a loss $\\mathcal { L }$ is locally differentiable, finding good parameters can be performed by gradient-based optimization, such as nonlinear conjugate gradients or stochastic gradient descent. The gradients can be calculated efficiently via back-propagation through time (BPTT) (Rumelhart et al., 1986). ",
+        "bbox": [
+            173,
+            313,
+            825,
+            459
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Fast Dropout ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            477,
+            305,
+            492
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In fast dropout (Wang and Manning, 2013), each unit in the network is assumed to be a random variable. To assure tractability, only the first and second moments of those random variables are kept, which suffices for a very good approximation. Since the pre-synaptic activation of each unit is a weighted sum of its incoming units (of which each is dropped out with a certain probability) we can safely assume Gaussianity for those inputs due to the central limit theorem. As we will see, this is sufficient to find efficient ways to propagate the mean and variance through the non-linearity $f$ . ",
+        "bbox": [
+            174,
+            502,
+            825,
+            588
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2.1 Forward propagation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            603,
+            375,
+            619
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We will now inspect the forward propagation for a layer into a single unit, that is ",
+        "bbox": [
+            174,
+            628,
+            700,
+            645
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fcd99272a6639492c9eb30e464eab04bf51749ae0f6de3a2bb74fba7a86279c0.jpg",
+        "text": "$$\n\\begin{array} { r l } { a = } & { { } ( \\mathbf { d } \\circ \\mathbf { x } ) ^ { T } \\mathbf { w } } \\\\ { y = } & { { } f ( a ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            650,
+            550,
+            688
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\circ$ denotes the element-wise product and $f$ is a non-linear transfer function as before. Let the input layer $\\mathbf { x }$ to the unit be Gaussian distributed with diagonal covariance by assumption: $\\mathbf { x } \\sim$ $\\mathcal { N } ( \\mu _ { \\mathbf { x } } , \\sigma _ { \\mathbf { x } } ^ { 2 } )$ . Furthermore, we have Bernoulli distributed variables indicating whether an incoming unit is not being dropped out organized in a vector $\\mathbf { d }$ with $d _ { i } \\sim B ( p )$ , $p$ being the complementary drop out rate. The weight vector w is assumed to be constant. ",
+        "bbox": [
+            173,
+            694,
+            825,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A neural network will in practice consist of many such nodes, with some of them, the output units, directly contributing to the loss function $\\mathcal { L }$ . Others, the input units, will not stem from calculation but come from the data set. Each component of $\\mathbf { x }$ represents an incoming unit, which might be an external input to the network or a hidden unit. In general, $y$ will have a complex distribution depending highly on the nature of $f$ . Given that the input to a function $f$ is Gaussian distributed, we obtain the mean and variance of the output as follows: ",
+        "bbox": [
+            173,
+            771,
+            826,
+            856
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/81470b3a4366658da2e4dd2a2def3df7f915643535a2aa806d0638c9bd405469.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\displaystyle \\mathbf { E } [ y ] = f _ { \\mu } ( a ) } & { = } & { \\displaystyle \\int f ( x ) \\mathcal { N } ( x | \\mathbf { E } [ a ] , \\mathbf { V } [ a ] ) d x , } \\\\ { \\displaystyle \\mathbf { V } [ y ] = f _ { \\sigma } ( a ) } & { = } & { \\displaystyle \\int ( f ( x ) - f _ { \\mu } ( a ) ) ^ { 2 } \\mathcal { N } ( x | \\mathbf { E } [ a ] , \\mathbf { V } [ a ] ) d x . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            862,
+            696,
+            930
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Forward propagation through the non-linearity $f$ for calculation of the post-synaptic activation can be approximated very well in the case of the logistic sigmoid and the tangent hyperbolicus and done exactly in case of the rectifier (for details, see Wang and Manning (2013)). While the rectifier has been previously reported to be a useful ingredient in RNNs (Bengio et al., 2012) we found that it leads to unstable learning behaviour in preliminary experiments and thus neglected it in this study, solely focusing on the tangent hyperbolicus. Other popular transfer functions, such as the softmax, need to be approximated either via sampling or an unscented transform (Julier and Uhlmann, 1997). ",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To obtain a Gaussian approximation for $\\boldsymbol { a } = ( \\mathbf { d } \\circ \\mathbf { x } ) ^ { T } \\mathbf { w }$ , we will use $\\hat { a } \\sim \\mathcal N ( \\mathrm { E } [ a ] , \\mathrm { V } [ a ] )$ . The mean and variance of $a$ can be obtained as follows. Since $\\mathbf { d }$ and $\\mathbf { x }$ are independent it follows that ",
+        "bbox": [
+            173,
+            207,
+            820,
+            236
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4f15b36c7bb762847b42e2ed52b612648d6d7ebff721e351f07d51c74f9e9a7b.jpg",
+        "text": "$$\n\\mathbf { E } [ a ] = \\mathbf { E } [ ( \\mathbf { x } \\circ \\mathbf { d } ) ^ { T } \\mathbf { w } ] = ( \\mathbf { E } [ \\mathbf { x } ] \\circ \\mathbf { E } [ \\mathbf { d } ] ) ^ { T } \\mathbf { w } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            238,
+            620,
+            256
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For independent random variables $A$ and $B$ , $\\mathbf { V } [ A B ] = \\mathbf { V } [ A ] \\mathrm { E } [ B ] ^ { 2 } + \\mathrm { E } [ A ] ^ { 2 } \\mathbf { V } [ B ] + \\mathbf { V } [ A ] \\mathbf { V } [ B ]$ . If we assume the components of $\\mathbf { x }$ to be independent, we can write ",
+        "bbox": [
+            171,
+            257,
+            821,
+            285
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a0aafa0949de0b102fa31bb55e4e56b34017097a342867ab30b01839ce605347.jpg",
+        "text": "$$\n\\mathbf { V } [ a ] = ( p ( 1 - p ) \\mu _ { \\mathbf { x } } ^ { 2 } + p \\sigma _ { \\mathbf { x } } ^ { 2 } ) ^ { T } \\mathbf { w } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            286,
+            593,
+            306
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Furthermore the independency assumption is necessary such that the Lyapunov condition is satisfied (Lehmann, 1999) for the the central limit theorem to hold, ensuring that $a$ is approximately Gaussian. ",
+        "bbox": [
+            171,
+            306,
+            821,
+            334
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Propagating the mean and the variance through $f$ via $f _ { \\mu }$ and $f _ { \\sigma }$ suffices for determining the presynaptic moments of the outgoing units. At the output $\\mathbf { y }$ of the whole model, we will simplify matters and ignore the variance. Some loss functions take the variance into account (e.g., a Gaussian log-likelihood as done in (Bayer et al., 2013)). Sampling can be a viable alternative as well. ",
+        "bbox": [
+            174,
+            340,
+            823,
+            397
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Fast Dropout for RNNs The extension of fast dropout to recurrent networks is straightforward from a technical perspective. First, we note that we can concatenate the input vector at time step $t$ , $x _ { t }$ and the hidden state at the previous layer $h _ { t - 1 }$ into a single vector: $c _ { t } = [ h _ { t - 1 } , x _ { t } ]$ . We obtain a corresponding weight matrix by concatenation of the input to hidden and recurrent weight matrices $W _ { \\mathrm { i n } }$ and $W _ { \\mathrm { r e c } }$ : $W _ { c } = [ W _ { \\mathrm { r e c } } , W _ { \\mathrm { i n } } ]$ . We can thus reduce the computation to the step from above. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            482
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2.2 Beyond the Backward Pass: A Regularization Term ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            496,
+            584,
+            511
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given the forward pass, we used automatic differentiation with Theano (Bergstra et al., 2010) to calculate the gradients. Nevertheless, we will contribute a close inspection of the derivatives. This will prove useful since it makes it possible to interpret fast dropout as an additional regularization term independent of the exact choice of loss function. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            577
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Consider a loss $\\mathcal { L } ( \\mathcal { D } ; \\theta )$ which is a function of the data $\\mathcal { D }$ and parameters $\\theta ^ { 2 }$ . In machine learning, we wish this loss to be minimal under unseen data $\\mathcal { D }$ although we only have access to a training set $\\mathcal { D } _ { \\mathrm { t r a i n } }$ . A typical approach is to optimize another loss $\\mathcal { I } ( \\mathcal { D } _ { \\mathrm { t r a i n } } ; \\theta )$ as a proxy in the hope that a good minimum of it will correspond to a good minimum of $\\mathcal { L }$ for unseen data. Learning is often done by the optimization of $\\mathcal { I } = \\mathcal { L } + \\mathcal { R }$ , where $\\mathcal { R }$ is called a regularizer. A common example of a regularizer is to place a prior on the parameters, in which case it is a function of $\\theta$ and corresponds to the log-likelihood of the parameters. For weight decay, this is a spherical Gaussian with inverse scale $\\lambda$ , i.e. $\\mathcal { R } _ { \\mathrm { w d } } ( \\theta ) = \\lambda | | \\dot { \\theta | } | _ { 2 } ^ { 2 }$ . Regularizers can be more sophisticated, e.g. Rifai et al. (2011) determine directions in input space to which a model’s outputs should be invariant. More recently, dropout (i.e. non-fast dropout) for generalized linear models has been intepreted as a semi-supervised regularization term encouraging confident predictions by Wager et al. (2013). ",
+        "bbox": [
+            173,
+            582,
+            825,
+            737
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "While it seems difficult to bring the objective function $\\mathcal { I } _ { \\mathrm { f d } } ( \\mathcal { D } ; \\theta )$ of fast dropout into the form of $\\mathcal { L } + \\mathcal { R }$ , it is possible with the derivatives of each node. For this, we perform back-propagation like calculations. ",
+        "bbox": [
+            174,
+            743,
+            823,
+            785
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let $\\boldsymbol { a } = ( \\mathbf { d } \\circ \\mathbf { x } ) ^ { T } \\mathbf { w }$ and $y = f ( a )$ be the pre- and post-synaptic activations of a component of a layer in the network. First note that $\\partial \\mathcal { I } / \\partial w _ { i } = \\partial \\mathcal { I } / \\partial a \\cdot \\partial a / \\partial w _ { i }$ according to the chain rule. Since $a$ is a random variable, it will be described in one of two forms. In the case of a Gaussian approximation, we will summarize it in terms of its mean and variance; this approach is used if propagation through $f$ is possible in closed form. In the case of sampling, we will have a single instantiation $\\hat { a }$ of the random variable, which we can propagate through $f$ . An analysis of both cases is as follows. ",
+        "bbox": [
+            173,
+            791,
+            825,
+            876
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Gaussian approximation We find the derivative of $\\mathcal { I }$ with respect to one of its incoming weights $w _ { i }$ to be ",
+        "bbox": [
+            174,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/04d81d47caffb82c9b99559c020adad34fa2fca3c2a39fcab8a9c0483bf379bd.jpg",
+        "text": "$$\n\\frac { \\partial \\mathcal { I } } { \\partial w _ { i } } = \\frac { \\partial \\mathcal { I } } { \\partial \\mathrm { E } [ a ] } \\frac { \\partial \\mathrm { E } [ a ] } { \\partial w _ { i } } + \\frac { \\partial \\mathcal { I } } { \\partial \\mathrm { V } [ a ] } \\frac { \\partial \\mathrm { V } [ a ] } { \\partial w _ { i } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            136,
+            607,
+            171
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We know that $\\mathbf { E } [ a ] = ( \\mathbf { x } \\circ \\mathbf { d } ) ^ { T } \\mathbf { w }$ and thus $\\partial \\mathrm { E } [ a ] / \\partial w _ { i } = x _ { i } d _ { i }$ . This can be recognized as the standard back-propagation term if we consider the dropout variable $d _ { i }$ as fixed. We will thus define ",
+        "bbox": [
+            171,
+            178,
+            823,
+            207
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/82d71df3a3fea96ec2dbeb1d72c0768090a0cb03db9b1e9712371bec2125b683.jpg",
+        "text": "$$\n\\frac { \\partial \\mathcal { L } ^ { a } } { \\partial w _ { i } } : = \\frac { \\partial \\mathcal { T } } { \\partial \\mathrm { E } [ a ] } \\frac { \\partial \\mathrm { E } [ a ] } { \\partial w _ { i } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            212,
+            555,
+            246
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and subsequently refer to it as the local derivative of the training loss. The second term can be analysed similarly. We apply the chain-rule once more which yields ",
+        "bbox": [
+            174,
+            250,
+            825,
+            279
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/67fec24c2b537b0dae63ef1d40a159a52b077fafc6bd2c84349adcb9f3dd3941.jpg",
+        "text": "$$\n{ \\frac { \\partial { \\mathcal { T } } } { \\partial \\mathbf { V } [ a ] } } { \\frac { \\partial \\mathbf { V } [ a ] } { \\partial w _ { i } } } = \\underbrace { { \\frac { \\partial { \\mathcal { T } } } { \\partial \\mathbf { V } [ a ] } } } _ { : = \\delta ^ { a } } { \\frac { \\partial \\mathbf { V } [ a ] } { \\partial w _ { i } ^ { 2 } } } { \\frac { \\partial w _ { i } ^ { 2 } } { \\partial w _ { i } } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            284,
+            601,
+            338
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "for which any further simplification of $\\delta ^ { a }$ depends on the exact form of $\\mathcal { I }$ . The remaining two factors can be written down explicitly, i.e. ",
+        "bbox": [
+            173,
+            342,
+            823,
+            372
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/785c05f00c375f863cf0bd6380dc6681a0bf9f0998aec37df2d7f11fb55e3858.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { \\displaystyle \\frac { \\partial { \\bf V } [ a ] } { \\partial w _ { i } ^ { 2 } } } } & { { = } } & { { p ( 1 - p ) { \\bf E } [ x _ { i } ] ^ { 2 } + p { \\bf V } [ x _ { i } ] , } } \\\\ { { \\displaystyle \\frac { \\partial w _ { i } ^ { 2 } } { \\partial w _ { i } } } } & { { = } } & { { 2 w _ { i } . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            376,
+            625,
+            446
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Setting ",
+        "bbox": [
+            173,
+            450,
+            223,
+            465
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1b2ec891cd3713235af137f8c6ca157f9bceac2785e3942cb8ad3ad0422e846c.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\eta _ { i } ^ { a } : = } & { { } | \\delta ^ { a } | \\frac { \\partial \\mathsf { V } [ a ] } { \\partial w _ { i } ^ { 2 } } } \\\\ { = } & { { } | \\delta ^ { a } | p \\big [ ( 1 - p ) \\mathsf { E } [ x _ { i } ] ^ { 2 } + \\mathsf { V } [ x _ { i } ] \\big ] } \\\\ { > } & { { } 0 } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            469,
+            616,
+            531
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "we conclude that ",
+        "bbox": [
+            174,
+            537,
+            287,
+            551
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ba286f69df741424ec3976294ebef8acab9f648519a577d77cf7caaf4bd2066f.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\displaystyle \\frac { \\partial \\mathcal { I } } { \\partial \\mathbf { V } [ a ] } \\frac { \\partial \\mathbf { V } [ a ] } { \\partial w _ { i } } } & { = } & { 2 \\operatorname { s g n } ( \\delta ^ { a } ) \\eta ^ { a } w _ { i } } \\\\ & & { = : \\mathbf { \\nabla } \\frac { \\partial \\mathcal { R } _ { \\mathrm { a p p r o x } } ^ { a } } { \\partial w _ { i } } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            554,
+            617,
+            625
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In alignment with Equation (3) this lets us arrive at ",
+        "bbox": [
+            173,
+            627,
+            509,
+            642
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0790040f0fa5dd8180a585214e97c0e356a43d9057be54612a720cd3cdf224ea.jpg",
+        "text": "$$\n\\frac { \\partial \\mathcal { I } } { \\partial w _ { i } } = \\frac { \\partial \\mathcal { L } ^ { a } } { \\partial w _ { i } } + \\frac { \\partial \\mathcal { R } _ { \\mathrm { a p p r o x } } ^ { a } } { \\partial w _ { i } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            647,
+            568,
+            681
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and offers an interpretation of fast dropout as an additive regularization term. An important and limiting aspect of this decomposition is that it only holds locally at $a$ . ",
+        "bbox": [
+            173,
+            686,
+            821,
+            715
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We note that depending on the sign of the error signal $\\delta ^ { a }$ , fast dropout can take on three different behaviours: ",
+        "bbox": [
+            174,
+            720,
+            821,
+            750
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "· $\\delta ^ { a } = 0$ The error signal is zero and thus the variance of the unit considered to be optimal for the loss. The fast dropout term vanishes; this is especially true at optima of the overall loss.   \n· $\\delta ^ { a } < 0$ The unit should increase its variance. The exact interpretation of this depends on the loss, but in many cases this is related to the expectation of the unit being quite erroneous and leads to an increase of scatter of the output. The fast dropout term encourages a quadratic growth of the weights.   \n• $\\delta ^ { a } > 0$ The unit should decrease its variance. As before, this depends on the exact loss function but will mostly be related to the expectation of the unit being quite right which makes a reduction of scatter desirable. The fast dropout term encourages a quadratic shrinkage of the weights. ",
+        "bbox": [
+            215,
+            761,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/0abc382d8649749ae7febf295253f49836345dcae0dba65b7e03bce57919314e.jpg",
+        "image_caption": [
+            "Figure 1: Visualizations of the behaviour of $\\delta ^ { a }$ for a single unit. The axes correspond to the presynaptic mean $\\operatorname { E } [ a ]$ and variance $\\mathrm { v } [ a ]$ feeding into a unit $y = f ( a )$ . A loss measuring the divergence from the target value 0.2 is then applied and indices the color on a logarithmic scale. The gradients of the loss are shown as a vector field plot. Squared error is shown on the left, Gaussian log-likelihood in the middle and Bernoulli log-likelihood on the right. For the first two plots, the optimium is in the middle, for the last it is a little to the left. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            102,
+            826,
+            270
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This behaviour can be illustrated for output units by numerically inspecting the values and gradients of the pre-synaptic moments given a loss. For that we consider a single unit $y = f ( a )$ and a loss $d ( y , z )$ measuring the divergence of its output to a target value $z$ . The pre-synaptic variance $\\mathrm { v } [ a ]$ can enter the loss not at all or in one of two ways, respected by either the loss (see (Bayer et al., 2013)) or the transfer function. Three examples for this are ",
+        "bbox": [
+            173,
+            390,
+            825,
+            462
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1. Squared loss on the mean, i.e. $d ( y , z ) = ( \\operatorname { E } [ y ] - t ) ^ { 2 }$ with $y = a$ ,   \n2. Gaussian log-likelihood on the moments, i.e. $\\begin{array} { r } { d ( y , z ) \\propto \\frac { \\left( \\mathrm { E } [ y ] - t \\right) ^ { 2 } } { 2 \\mathrm { V } [ y ] } + \\log \\sqrt { 2 \\pi \\mathrm { V } [ y ] } } \\end{array}$ with $y = a ,$   \n3. Negative Bernoulli cross entropy, i.e. $d ( y , z ) = z \\log \\mathrm { E } [ y ] + ( 1 - z ) \\log ( 1 - \\mathrm { E } [ y ] )$ with $\\begin{array} { r } { y = \\frac { 1 } { 1 + \\exp ( - a ) } } \\end{array}$ . ",
+        "bbox": [
+            210,
+            469,
+            825,
+            559
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We visualize the pre-synaptic mean and variance, their gradients and their respective loss values in Figure 1. For the two latter cases, erroneous units first increase the variance, then move towards the correct mean and subsequently reduce the variance. ",
+        "bbox": [
+            176,
+            568,
+            825,
+            611
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Sampling An already mentioned alternative to the forward propagation of $\\operatorname { E } [ a ]$ and $\\mathrm { v } [ a ]$ through $f$ is to incarnate $\\hat { a }$ via sampling and calculate $f ( \\hat { a } )$ . Let $s \\sim \\mathcal { N } ( 0 , 1 )$ and $\\hat { a } = \\mathrm { E } [ a ] + s \\sqrt { \\mathrm { V } [ a ] }$ . We can then use $\\hat { a }$ explicitly and it follows that ",
+        "bbox": [
+            173,
+            625,
+            826,
+            669
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cf261e3e0a0d5636720c35278911cb7354f4cd8903400a23f6cb3a973a884ed6.jpg",
+        "text": "$$\n\\frac { \\partial \\mathcal { I } } { \\partial \\hat { a } } \\frac { \\partial \\hat { a } } { \\partial w _ { i } } = \\frac { \\partial \\mathcal { I } } { \\partial \\hat { a } } \\left[ \\frac { \\partial \\hat { a } } { \\partial \\mathrm { E } [ a ] } \\frac { \\partial \\mathrm { E } [ a ] } { \\partial w _ { i } } + \\frac { \\partial \\hat { a } } { \\partial \\mathrm { V } [ a ] } \\frac { \\partial \\mathrm { V } [ a ] } { \\partial w _ { i } } \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            671,
+            642,
+            705
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Again, we recognize ${ \\partial { \\mathcal J } } / { \\partial { \\hat { a } } } \\cdot { \\partial { \\hat { a } } } / { \\partial \\mathrm { E } } [ a ] \\cdot { \\partial \\mathrm { E } } [ a ] / { \\partial w _ { i } } \\ = \\ { \\partial { \\mathcal J } } / { \\partial { \\hat { a } } } \\ x _ { i } d _ { i }$ as the standard backpropagation formula with dropout variables. ",
+        "bbox": [
+            174,
+            708,
+            823,
+            738
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The variance term can be written as ",
+        "bbox": [
+            176,
+            744,
+            408,
+            758
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7eebc1d9707088db04161118aaa81a5e660bd4c0564a7c41a724b00b8c4b4c1b.jpg",
+        "text": "$$\n{ \\frac { \\partial { \\mathcal { I } } } { \\partial { \\hat { a } } } } { \\frac { \\partial { \\mathcal { I } } } { \\partial \\mathbf { V } [ a ] } } { \\frac { \\partial \\mathbf { V } [ a ] } { \\partial w _ { i } } } = { \\frac { \\partial { \\mathcal { I } } } { \\partial { \\hat { a } } } } { \\frac { \\partial { \\hat { a } } } { \\partial { \\sqrt { \\mathbf { V } [ a ] } } } } { \\frac { \\partial { \\sqrt { \\mathbf { V } [ a ] } } } { \\partial \\mathbf { V } [ a ] } } { \\frac { \\partial \\mathbf { V } [ a ] } { \\partial w _ { i } ^ { 2 } } } { \\frac { \\partial w _ { i } ^ { 2 } } { \\partial w _ { i } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            758,
+            663,
+            797
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "which, making use of results from earlier in the section is equivalent to ",
+        "bbox": [
+            174,
+            799,
+            638,
+            814
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1429fe87ca9ae95890277339ae40faf10dcf843b5cb91e5af2de64e19fbf8002.jpg",
+        "text": "$$\n\\begin{array} { r l r } { \\displaystyle \\frac { \\partial { \\mathcal I } } { \\partial \\hat { a } } \\frac { \\partial { \\mathcal J } } { \\partial { \\bf V } [ a ] } \\frac { \\partial { \\bf V } [ a ] } { \\partial w _ { i } } } & { = } & { \\displaystyle \\frac { \\partial { \\mathcal J } } { \\partial \\hat { a } } \\sqrt { p ( 1 - p ) { \\bf E } [ x _ { i } ] ^ { 2 } + p { \\bf V } [ x _ { i } ] } s . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            815,
+            689,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The value of this is a zero-centred Gaussian random variable, since $s$ is Gaussian. The scale is independent of the current weight value and only determined by the post-synaptic moments of the incoming unit, the dropout rate and the error signal. We conclude, that also in this case, we can write ",
+        "bbox": [
+            173,
+            852,
+            825,
+            893
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3b7e62de5bf46fdcbb4b8294c35c08b65dbc0ac7c7f2e7d7f174682661867320.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\displaystyle \\frac { \\partial \\mathcal { T } } { \\partial w _ { i } } } & { = } & { \\displaystyle \\frac { \\partial \\mathcal { L } ^ { a } } { \\partial w _ { i } } + \\frac { \\partial \\mathcal { R } _ { \\mathrm { d r a w } } ^ { a } } { \\partial w _ { i } } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            895,
+            591,
+            929
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\partial \\mathcal { R } _ { \\mathrm { d r a w } } ^ { a } } / { \\partial \\boldsymbol { w } _ { i } }$ is defined as in Equation (4) and essentially an adaptive noise term. ",
+        "bbox": [
+            174,
+            103,
+            741,
+            118
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We want to stress the fact that in the approximation as well as in the sampling case the regularization term vanishes at any optima of the training loss. A consequence of this is that no global attractor is formed, which makes the method theoretically useful for RNNs. One might argue that fast dropout should not have a regularizing effect all. Yet, regularization is not only influencing the final solution but also the optimization, leading to different optima. ",
+        "bbox": [
+            174,
+            125,
+            825,
+            195
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Relationship to Weight Decay As already mentioned, imposing a Gaussian distribution centred at the origin with precision $\\lambda$ as a prior on the weights leads to a method called weight decay. It is not only probabilistically sound but also works well empirically, see e.g. (Bishop et al., 2006). Recalling that the derivative of weight decay is of the form $\\partial \\mathcal { R } _ { \\mathrm { w d } } / \\partial w _ { i } = 2 \\lambda w _ { i }$ we can reinterpret $\\mathcal { R } _ { \\mathrm { a p p r o x } }$ as a weight decay term where the coefficient $\\lambda$ is weight-wise, dependent on the current activations and possibly negative. Weight decay will always be slightly wrong on the training set, since the derivative of the weight decay term has to match the one of the unregularized loss. In order for $\\partial \\mathcal { L } / \\partial \\theta + \\partial \\mathcal { R } _ { \\mathrm { w d } } / \\partial \\theta$ to be minimal, $\\mathcal { L }$ cannot be minimal unless so is $\\mathcal { R }$ . ",
+        "bbox": [
+            173,
+            210,
+            825,
+            323
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Relationship to Adaptive Weight Noise In this method (Graves, 2011) not the units but the weights are stochastic, which is in pratice implemented by performing Monte Carlo sampling. We can use a similar technique to FD to find a closed form approximation. In this case, a layer is $y = f ( \\mathbf { x } ^ { T } \\mathbf { w } )$ , where we have no dropout variables and the weights are Gaussian distributed with $\\begin{array} { r } { \\mathbf { \\ d } \\mathbf { \\ b { v } } \\sim \\mathcal { N } ( \\mu _ { \\mathbf { w } } , \\sigma _ { \\mathbf { w } } ^ { 2 } ) . } \\end{array}$ , with covariance diagonal and organized into a vector. We assume Gaussian density for $a = \\mathbf { x } ^ { T } \\mathbf { w }$ . Using similar algebra as above, we find that ",
+        "bbox": [
+            173,
+            338,
+            825,
+            422
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/db912e719e1423d07199f3324973203cbd57dbb208957b9f15b657b1fc49598f.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\mathbf { E } [ a ] } & { = } & { \\boldsymbol { \\mu } _ { \\mathbf { x } } ^ { T } \\boldsymbol { \\mu } _ { \\mathbf { w } } , } \\\\ { \\mathbf { V } [ a ] } & { = } & { \\boldsymbol { \\sigma } _ { \\mathbf { x } } ^ { 2 T } \\boldsymbol { \\mu } _ { \\mathbf { w } } ^ { 2 } + \\boldsymbol { \\sigma } _ { \\mathbf { x } } ^ { 2 T } \\boldsymbol { \\sigma } _ { \\mathbf { w } } ^ { 2 } + \\boldsymbol { \\mu } _ { \\mathbf { x } } ^ { 2 T } \\boldsymbol { \\sigma } _ { \\mathbf { w } } ^ { 2 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            429,
+            632,
+            472
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "It is desirable to determine whether fast dropout and “fast adaptive weight noise” are special cases of each other. Showing that the aproaches are different can be done by equating equations (1) and (5) and solving for $\\mu _ { \\mathbf { w } }$ . This shows that rescaling by $1 - p$ suffices in the case of the expectation. It is however not as simple as that for the variance, i.e. for equations (2) and (6), where the solution depends on $\\mu _ { \\mathbf { x } }$ and $\\sigma _ { \\mathbf { x } } ^ { \\hat { 2 } }$ and thus is not independent of the input to the network. Yet, both methods share the property that no global attractor is present in the loss: the “prior” is part of the optimization and not fixed. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            573
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "2.3 Bag of Tricks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            590,
+            305,
+            606
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Throughout the experiments we will resort to several “tricks” that have been introduced recently for more stable and efficient optimization of neural networks and RNNs especially. First, we make use of rmsprop (Tieleman and Hinton, 2012), an optimizer which divides the gradient by an exponential moving average of its squares. This approach is similar to Adagrad (Duchi et al., 2011), which uses a window based average. We found that enhancing rmsprop with Nesterov’s accelerated gradient (Sutskever, 2013) greatly reduces the training time in preliminary experiments. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            702
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To initialize the RNNs to stable dynamics we followed the initialization protocol of (Sutskever et al., 2013) of setting the spectral radius $\\rho$ to a specific value and the maximum amount of incoming connections of a unit to $\\nu$ ; we did not find it necessary to centre the inputs and outputs. The effect of not only using the recurrent weight matrix for propagating the states through time but also its element-wise square for advancing the variances can be quantified. The stability of a network is coupled to the spectral radius of the recurrent weight matrix $\\rho ( W _ { \\mathrm { r e c } } )$ ; thus, the stability of forward propagating the variance is related to the spectral radius of its element-wise square $\\rho ( W _ { \\mathrm { r e c } } ^ { 2 } )$ . Since $\\rho ( A B ) \\le \\rho ( A ) \\rho ( B )$ for non-negative matrices and non-singular matrices $A$ and $B$ (Horn and Johnson, 2012), setting $W _ { \\mathrm { r e c } }$ to full rank and its spectral radius to $\\rho ( W _ { \\mathrm { r e c } } )$ assures $\\rho ( W _ { \\mathrm { r e c } } ^ { 2 } ) = \\rho ( | W _ { \\mathrm { r e c } } | ^ { 2 } ) \\leq \\rho ( W _ { \\mathrm { r e c } } ) ^ { 2 }$ , where $| \\cdot |$ denotes taking the absolute value element-wise. We also use the gradient clipping method introduced in (Pascanu et al., 2012), with a fixed threshold of 225. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Since the hidden-to-hidden connections and the hidden-to-output connections in an RNN can make use of hidden units in quite distinct ways, we found it beneficial to separate the dropout rates. Specifically, a hidden unit may have a different probability to be dropped out when feeding into ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Results on the midi data sets. All numbers are average negative log-likelihoods on the test set, where “FD” represents our work; “plain” and “RNN-NADE” results are from (Bengio et al., 2012) while “Deep RNN“ shows the best results from (Pascanu et al., 2013). Note that “RNN-NADE” and “Deep RNN“ employ various extensions of the model structure of this work, i.e. structured outputs and various forms of depths. Our results are the best for the shallow RNN model considered in this work. ",
+        "bbox": [
+            173,
+            111,
+            825,
+            195
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/0e2dde4f75682765f7507c8ab27f8932d52ebd61eba6bfead9907c9320d8d7ac.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Data set</td><td>FD</td><td>plain</td><td>RNN-NADE</td><td>Deep RNN</td></tr><tr><td>Piano-midi.de</td><td>7.39</td><td>7.58</td><td>7.05</td><td>1</td></tr><tr><td>Nottingham</td><td>3.09</td><td>3.43</td><td>2.31</td><td>2.95</td></tr><tr><td>MuseData</td><td>6.75</td><td>6.99</td><td>5.60</td><td>6.59</td></tr><tr><td>JSBChorales</td><td>8.01</td><td>8.58</td><td>5.19</td><td>7.92</td></tr></table>",
+        "bbox": [
+            305,
+            210,
+            691,
+            279
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "the hidden layer at the next time step than when feeding into the output layer. Taking this one step further, we also consider networks in which we completely neglect fast dropout for the hidden-tooutput connections; an ordinary forward pass is used instead. Note that this is not the same as setting the dropout rate to zero, since the variance of the incoming units is completely neglected. Whether this is done is treated as another hyperparameter for the experiment. ",
+        "bbox": [
+            174,
+            310,
+            825,
+            382
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments and Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            402,
+            415,
+            420
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.1 Musical Data ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            435,
+            305,
+            450
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "All experiments were done by performing a random search (Bergstra and Bengio, 2012) over the hyper parameters (see Table 2 in the Appendix for an overview), where 32 runs were performed for each data set. We report the test loss of the model with the lowest validation error over all training runs, using the same split as in (Bengio et al., 2012). To improve speed, we organize sequences into minibatches by first splitting all sequences of the training and validation set into chunks of length of 100. Zeros are prepended to those sequences which have less than 100 time steps. The test error is reported on the unsplitted sequences. ",
+        "bbox": [
+            173,
+            463,
+            825,
+            560
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Training RNNs to generatively model polyphonic music is a valuable benchmark for RNNs due to its high dimensionality and the presense of long as well as short term dependencies. This data set has been evaluated previously by Bengio et al. (2012) where the model achieving the best results, RNN-NADE (Boulanger-Lewandowski et al., 2013), makes specific assumptions about the data (i.e. binary observables). RNNs do not attach any assumptions to the inputs. ",
+        "bbox": [
+            174,
+            566,
+            825,
+            637
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 Setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            654,
+            266,
+            669
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The data consists of four distinct data sets, namely Piano-midi.de (classical piano music), Nottingham (folk music), MuseData (orchestral) and JSBChorales (chorales by Johann Sebastian Bach). Each has a dimensionality of 88 per time step organized into different piano rolls which are sequences of binary vectors; each component of these vectors indicates whether a note is occuring at the given time step. We use the RNN’s output to model the sufficient statistics of a Bernoulli random variable, i.e. ",
+        "bbox": [
+            173,
+            679,
+            825,
+            763
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1336ee06d16e14dfe411b0f57a54d30332ab5f153b11b341e4a4b322712bb389.jpg",
+        "text": "$$\np ( x _ { t , i } | \\mathbf { x } _ { 1 : t - 1 } ) = y _ { t , i } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            771,
+            553,
+            790
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "which describes the probability that note $i$ is present at time step $t$ . The output non-linearity $f _ { y }$ of the network is a sigmoid which projects the points to the interval $( 0 , 1 )$ . We perform learning by the minimization of the average negative log-likelihood (NLL); in this case, this is the average binary cross-entropy ",
+        "bbox": [
+            173,
+            797,
+            825,
+            854
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f2a80a99960d685c6649e2351043b3e9ae6912350c6c8841754acae076312a60.jpg",
+        "text": "$$\n\\mathcal { L } ( \\boldsymbol { \\theta } ) = \\frac { 1 } { T - 1 } \\frac { 1 } { N } \\sum _ { i , t , k } x _ { t , i } ^ { ( k ) } \\log y _ { t - 1 , i } ^ { ( k ) } + ( 1 - x _ { t , i } ^ { ( k ) } ) \\log ( 1 - y _ { t - 1 , i } ^ { ( k ) } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            861,
+            700,
+            901
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $k$ indices the training sample, $i$ the component of the target and $t$ the time step. ",
+        "bbox": [
+            173,
+            909,
+            732,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/a4d9408295c1be22bcd0692eb5fe92b702156f3032f2e875a43922a0f773c817.jpg",
+        "image_caption": [
+            "Figure 2: Spectral radius over the training process. It increases first and then slowly decreases until a certain value is reached. We did not observe this behaviour when training plain RNNs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            274,
+            103,
+            722,
+            236
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            314,
+            276,
+            329
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Although a common metric for evaluating the performance of such benchmarks is that of accuracy (Bay et al., 2009) we restrict ourselves to that of the NLL–the measure of accuracy is not what is optimized and to which the NLL is merely a proxy. We present the results of FD-RNNs compared with the various other methods in Table 1. Our method is only surpassed by methods which either incorporate more specific assumptions of the data or employ various forms of depth (BoulangerLewandowski et al., 2013; Pascanu et al., 2013). We want to stress that we performed only 32 runs for each data set once more. This shows the relative ease to obtain good results despite of the huge space of potential hyper parameters. ",
+        "bbox": [
+            174,
+            339,
+            825,
+            450
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "One additional observation is the range of the Eigenvalues of the recurrent weight matrix $W _ { \\mathrm { r e c } }$ during training. We performed an additional experiment on JSBChorales where we inspected the Eigenvalues and and the test loss. We found that the spectral radius first increases sharply to a rather high value and then decreases slowly to settle to a specific value. We tried to replicate this behaviour in plain RNNs, but found that RNNs never exceeded a certain spectral radius at which they stuck. This stands in line with the observation from Section 2.2.2 that weights are encouraged to grow when the error is high and shrink during convergence to the optimum. See Figure 2 for a plot of the spectral radius $\\rho ( W _ { \\mathrm { r e c } } )$ over the training process stages. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            569
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            589,
+            299,
+            607
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have contributed to the field of neural networks in two ways. First, we have analysed a fast approximation of the dropout regularization method by bringing its derivative into the same form as that of a loss regularized with an additive term. We have used this form to gain further insights upon the behaviour of fast dropout for neural networks in general and shown that this objective function does not bias the solutions to those which perform suboptimal on the unreguarized loss. Second, we have hypothesized that this is beneficial especially for RNNs We confirmed this hypothesis by conducting quantitative experiments on an already established benchmark used in the context of learning recurrent networks. ",
+        "bbox": [
+            174,
+            622,
+            825,
+            733
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            756,
+            266,
+            772
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bay, M., Ehmann, A. F., and Downie, J. S. (2009). Evaluation of multiple-f0 estimation and tracking systems. In ISMIR, pages 315–320.   \nBayer, J., Osendorfer, C., Urban, S., et al. (2013). Training neural networks with implicit variance. In Proceedings of the 20th International Conference on Neural Information Processing , ICONIP2013.   \nBengio, Y., Boulanger-Lewandowski, N., and Pascanu, R. (2012). Advances in optimizing recurrent networks. arXiv preprint arXiv:1212.0901.   \nBengio, Y., Simard, P., and Frasconi, P. (1994). Learning long-term dependencies with gradient descent is difficult. Neural Networks, IEEE Transactions on, 5(2):157–166.   \nBergstra, J. and Bengio, Y. (2012). Random search for hyper-parameter optimization. The Journal of Machine Learning Research, 13:281–305.   \nBergstra, J., Breuleux, O., Bastien, F., Lamblin, P., Pascanu, R., Desjardins, G., Turian, J., WardeFarley, D., and Bengio, Y. (2010). Theano: a CPU and GPU math expression compiler. In Proceedings of the Python for Scientific Computing Conference (SciPy). Oral Presentation.   \nBishop, C. M. (1995). Neural networks for pattern recognition. Oxford university press.   \nBishop, C. M. et al. (2006). Pattern recognition and machine learning, volume 1. springer New York.   \nBoulanger-Lewandowski, N., Bengio, Y., and Vincent, P. (2013). High-dimensional sequence transduction. In ICASSP.   \nDuchi, J., Hazan, E., and Singer, Y. (2011). Adaptive subgradient methods for online learning and stochastic optimization. The Journal of Machine Learning Research, 999999:2121–2159.   \nGraves, A. (2011). Practical variational inference for neural networks. In Advances in Neural Information Processing Systems, pages 2348–2356.   \nGraves, A. (2013). Generating sequences with recurrent neural networks. arXiv preprint arXiv:1308.0850.   \nGraves, A., Fernandez, S., Liwicki, M., Bunke, H., and Schmidhuber, J. (2008). Unconstrained ´ online handwriting recognition with recurrent neural networks. Advances in Neural Information Processing Systems, 20:1–8.   \nGraves, A., Mohamed, A.-r., and Hinton, G. (2013). Speech recognition with deep recurrent neural networks. arXiv preprint arXiv:1303.5778.   \nHammer, B. (2000). On the approximation capability of recurrent neural networks. Neurocomputing, 31(1):107–123.   \nHinton, G. E., Srivastava, N., Krizhevsky, A., Sutskever, I., and Salakhutdinov, R. R. (2012). Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580.   \nHochreiter, S. (1991). Untersuchungen zu dynamischen neuronalen netzen. Master’s thesis, Institut fur Informatik, Technische Universit ¨ at, M ¨ unchen ¨ .   \nHochreiter, S. and Schmidhuber, J. (1997). Long short-term memory. Neural computation, 9(8):1735–1780.   \nHorn, R. A. and Johnson, C. R. (2012). Matrix analysis. Cambridge university press.   \nJager, H. et al. (2003). Adaptive nonlinear system identification with echo state networks. ¨ networks, 8:9.   \nJulier, S. J. and Uhlmann, J. K. (1997). New extension of the kalman filter to nonlinear systems. In AeroSense’97, pages 182–193. International Society for Optics and Photonics.   \nLehmann, E. L. (1999). Elements of large-sample theory. Springer Verlag.   \nMartens, J. and Sutskever, I. (2011). Learning recurrent neural networks with hessian-free optimization. Proc. 28th Int. Conf. on Machine Learning.   \nMikolov, T., Karafiat, M., Burget, L., Cernocky, J., and Khudanpur, S. (2010). Recurrent neural ´ network based language model. Proceedings of Interspeech.   \nPachitariu, M. and Sahani, M. (2013). Regularization and nonlinearities for neural language models: when are they needed? arXiv preprint arXiv:1301.5650.   \nPascanu, R., Gulcehre, C., Cho, K., and Bengio, Y. (2013). How to construct deep recurrent neural networks. arXiv preprint arXiv:1312.6026.   \nPascanu, R., Mikolov, T., and Bengio, Y. (2012). On the difficulty of training recurrent neural networks. Technical report, Technical Report.   \nRifai, S., Dauphin, Y. N., Vincent, P., Bengio, Y., and Muller, X. (2011). The manifold tangent classifier. In Advances in Neural Information Processing Systems, pages 2294–2302.   \nRumelhart, D. E., Hinton, G. E., and Williams, R. J. (1986). Learning representations by backpropagating errors. Nature, 323(6088):533–536. ",
+        "bbox": [
+            171,
+            780,
+            826,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            102,
+            830,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/d5848049279d58f7a3196b7e0796a82c0af0a3f955cea8259f2be000e7f08006.jpg",
+        "table_caption": [
+            "Table 2: Hyper parameter ranges and parameter distributions for the musical data sets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyper parameter #hidden layers</td><td>Choices 1</td></tr><tr><td>#hidden units Transfer function p(&quot;dropout input&quot;) p(&quot;dropout hidden to hidden&quot;) p(&quot;dropout hidden to output&quot;) Use fast dropout for final layer Step rate Momentum Decay W Win bh</td><td>200,400,600 tanh 0.0, 0.1, 0.2 0.0, 0.1, 0.2, 0.3,0.4, 0.5 0.0, 0.2,0.5 yes,no 0.01,0.005,0.001,0.0005,0.0001,0.00001 0.0,0.9,0.95,0.99,0.995 0.8,0.9 N(0,σ²),0² ∈ {0.1,0.01,0.001,0.0001} N(0,σ²),g² ∈ {0.1,0.01,0.001,0.0001}</td></tr></table>",
+        "bbox": [
+            254,
+            148,
+            741,
+            368
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sutskever, I. (2013). Training Recurrent Neural Networks. PhD thesis, University of Toronto. ",
+        "bbox": [
+            174,
+            400,
+            787,
+            415
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sutskever, I., Martens, J., Dahl, G., and Hinton, G. (2013). On the importance of initialization and momentum in deep learning.   \nSutskever, I., Martens, J., and Hinton, G. (2011). Generating text with recurrent neural networks. Proceedings of the 2011 International Conference on Machine Learning (ICML-2011).   \nTieleman, T. and Hinton, G. (2012). Lecture 6.5 - rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning.   \nWager, S., Wang, S., and Liang, P. (2013). Dropout training as adaptive regularization. arXiv preprint arXiv:1307.1493.   \nWang, S. and Manning, C. (2013). Fast dropout training. In Proceedings of the 30th International Conference on Machine Learning (ICML-13), pages 118–126.   \nZeiler, M., Ranzato, M., Monga, R., Mao, M., Yang, K., Le, Q., Nguyen, P., Senior, A., Vanhoucke, V., Dean, J., et al. (2013). On rectified linear units for speech processing. ICASSP. ",
+        "bbox": [
+            171,
+            404,
+            828,
+            612
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5 Appendix ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            637,
+            287,
+            655
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5.1 Hyper Parameters for Musical Data Experiments ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            669,
+            555,
+            684
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We show the hyper parameters ranges for the musical data in Table 2. The ones from which the numbers in Table 1 resulted are given in Table 3. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            723
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/1845f20d162b417d57ca5e1c58d5fb3d66a80bbea900933a2e3c10cbfe01f5bb.jpg",
+        "table_caption": [
+            "Table 3: Hyper parameters used for the musical data experiments. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyper parameter</td><td>Piano-midi.de</td><td>Nottingham</td><td>MuseData</td><td>JSBChorales</td></tr><tr><td>#hidden units</td><td>600</td><td>400</td><td>600</td><td>400</td></tr><tr><td>p(&quot;dropout input&quot;)</td><td>0.1</td><td>0.1</td><td>0.2</td><td>0.1</td></tr><tr><td>p(&quot;dropout hidden to hidden&quot;)</td><td>0.3</td><td>0.4</td><td>0.3</td><td>0.2</td></tr><tr><td>p(&quot;dropout hidden to output&quot;)</td><td>1</td><td>0.0</td><td>0.0</td><td>0.5</td></tr><tr><td>Use fast dropout for final layer</td><td>no</td><td>yes</td><td>yes</td><td>yes</td></tr><tr><td>Step rate</td><td>0.005</td><td>0.001</td><td>0.0005</td><td>0.001</td></tr><tr><td>Momentum</td><td>0.995</td><td>0.99</td><td>0.995</td><td>0.99</td></tr><tr><td>Decay</td><td>0.8</td><td>0.9</td><td>0.9</td><td>0.8</td></tr><tr><td>g² for Wrec, Wout</td><td>0.1</td><td>0.001</td><td>0.1</td><td>0.0001</td></tr><tr><td>g² for Win</td><td>0.0001</td><td>0.1</td><td>0.0001</td><td>0.01</td></tr><tr><td>p(Wrec)</td><td>1.2</td><td>1.2</td><td>1.2</td><td>1.2</td></tr><tr><td>V</td><td>25</td><td>no</td><td>no</td><td>15</td></tr></table>",
+        "bbox": [
+            214,
+            443,
+            782,
+            612
+        ],
+        "page_idx": 11
+    }
+]

parse/train/SJtfOEn6-/SJtfOEn6-.md

@@ -0,0 +1,176 @@
+# RESBINNET: RESIDUAL BINARY NEURAL NETWORK
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Recent efforts on training light-weight binary neural networks offer promising execution/memory efficiency. This paper introduces ResBinNet, which is a composition of two interlinked methodologies aiming to address the slow convergence speed and limited accuracy of binary convolutional neural networks. The first method, called residual binarization, learns a multi-level binary representation for the features within a certain neural network layer. The second method, called temperature adjustment, gradually binarizes the weights of a particular layer. The two methods jointly learn a set of soft-binarized parameters that improve the convergence rate and accuracy of binary neural networks. We corroborate the applicability and scalability of ResBinNet by implementing a prototype hardware accelerator. The accelerator is reconfigurable in terms of the numerical precision of the binarized features, offering a trade-off between runtime and inference accuracy.
+
+# 1 INTRODUCTION
+
+Convolutional Neural Networks (CNNs) have shown promising inference accuracy for learning applications in various domains. These models are generally over-parameterized to facilitate the convergence during the training phase (Hinton et al. (2012); Denil et al. (2013)). A line of optimization methodologies such as tensor decomposition (Kim et al. (2015); Zhang et al. (2015)), parameter quantization (Hubara et al. (2016); Han et al. (2015)), sparse convolutions (Liu et al. (2015); Wen et al. (2016)), and binary networks (Courbariaux et al. (2016); Rastegari et al. (2016)) have been proposed to reduce the complexity of neural networks for efficient execution. Among these works, binary neural networks result in two particular benefits: (i) They reduce the memory footprint by a factor of 32 compared to the full-precision model; this is specifically important since memory access plays an essential role in the execution of CNNs on resource-constrained devices. (ii) Binary networks replace the costly multiplications with simple XNOR operations (Rastegari et al. (2016); Umuroglu et al. (2017)), reducing the execution time and energy consumption significantly.
+
+Considering the prior art, there exist two major challenges associated with binary neural networks. First, the convergence rate of the existing solutions for training binary CNNs is considerably slower than their full-precision counterparts. Second, in order to achieve comparable classification accuracy, binarized neural networks often compensate for the numerical precision loss by employing high dimensional feature maps in a wide CNN topology, which in turn reduces the effective compression rate. As a result, full-precision networks often surpass binary networks in terms of convergence rate and final achievable accuracy.
+
+In this paper, we propose ResBinNet, a novel solution for increasing the convergence rate and the final accuracy of binary networks. The global flow of ResBinNet is depicted in Figure 1. The first phase, which we call Soft Binarization, includes two methodologies that we propose to address the aforementioned challenges for training binary CNNs. First, we introduce a Residual Binarization scheme which allows the number of possible values for activation units to be reconfigurable at runtime. To this purpose, we learn a multi-level residual representation for the features within the CNN to adaptively increase the numerical precision of the activation units. Second, we introduce a novel weight binarization approach, called Tempreture Adjustment, which aims to gradually enforce binarization constraints over the weight parameters throughout the training phase. The two interlinked methods significantly improve both the convergence rate and the final accuracy of ResBinNet compared to prior art. Once the soft training phase is finished, we convert the weights to actual binary values (0,1). Fine-tuning of the model is then performed in Hard Binarization phase using existing training algorithms (e.g. BinaryNets (Courbariaux et al. (2016))) in few epochs (e.g. one epoch).
+
+![](images/f122029c957b6c584853f614e0a66dba706773859e507f7b86a0a52e05c9a144.jpg)  
+Figure 1: The global flow of ResBinNet binary training. Residual binarization learns a multi-level representation for feature maps. Temperature adjustment performs a change of variable over the trainable weights and gradually pushes them towards binary values during the training phase.
+
+ResBinNet is designed to fulfill certain goals: (i) It should enable reconfigurability for binary neural networks; in other words, the number of residual binary representatives should be adjustable to offer a trade-off between inference accuracy and computation time. (ii) The multi-level binarized features should be compatible with the XNOR multiplication approach proposed in the existing literature. (iii) ResBinNet should speed up the convergence rate of binarized CNNs. (iv) Current hardware accelerators for binary CNNs should be able to benefit from ResBinNet with minimum modification in their design. In summary, the contributions of this paper are as follows:
+
+• Proposing residual binarization, a methodology for learning multi-level residual representations for each feature map in binary CNNs. Introducing temperature adjustment as a practical approach for gradual (soft) binarization of CNN weights.   
+• Analyzing the trade-off between accuracy and execution time of ResBinNet on a real hardware design.   
+• Evaluating ResBinNet convergence rate and accuracy on three datasets: MNIST, SVHN, and CIFAR-10.   
+• Development of an open-source Application Program Interface (API) for ResBinNet1.
+
+The remainder of the paper is organized as follows: In Section 2, we describe the residual binarization method for binarizing activations. Section 3 explains the temperature adjustment technique for binarizing weights. In Section 4, we discuss how particular ResBinNet operations (e.g. multi-level XNOR-popcount) can be efficiently implemented on existing hardware accelerators. Experiments are discussed in Section 5. Finally, we discuss the related work and conclusion in Sections 6 and 7.
+
+# 2 RESIDUAL BINARIZATION
+
+A binarization scheme converts value $x$ to the binarized estimation $e _ { x }$ , which can take one of the possible values $\gamma$ or $- \gamma$ . This representation allows us to represent $e _ { x }$ with a single bit $b _ { x }$ . In particular, for a given layer within the CNN, we can store the single full-precision value of $\gamma$ as a representative for all features, and reduce the memory footprint by storing bits $b _ { x }$ instead of $x$ for each feature. Assuming that both the weights and input features of a CNN layer are binarized, each dot product between a feature vector $\vec { x }$ and weight vector $\vec { w }$ can be efficiently computed using XNOR-popcount operations as previously suggested in (Courbariaux et al. (2016); Rastegari et al. (2016)). Let $\vec { x } = \vec { \gamma } _ { x } \vec { s } _ { x }$ and $\bar { w } = \gamma _ { w } \ \bar { s } _ { w }$ where $\{ \gamma _ { x } , \gamma _ { w } \}$ are scalar values and $\{ \vec { s } _ { x } , \vec { s } _ { w } \}$ are the corresponding sign vectors. The binary representations of $\{ \vec { x } , \vec { y } \}$ , which we denote by $\{ \vec { b } _ { x } , \vec { b } _ { w } \}$ , are simply computed by encoding the sign vectors $\vec { s }$ to binary vectors. The dot product between $\vec { x }$ and $\vec { w }$ can be computed as:
+
+$$
+d o t ( \vec { w } , \vec { x } ) = \gamma _ { x } \gamma _ { w } d o t ( \vec { s } _ { x } , \vec { s } _ { w } ) = \gamma _ { x } \gamma _ { w } x n o r p o p c o u n t ( \vec { b _ { x } } , \vec { b _ { w } } ) ,
+$$
+
+where xnorpopcount $\cdot , . . )$ returns the number of set bits in the element-wise XNOR of the input binary vectors.
+
+![](images/04c65714483d338b9b9f96b58dd93d8c9a9cc027b6b879a2ef034e65a98aaacc.jpg)  
+Figure 2: Schematic flow for computing 3 levels of residual binary estimates $e$ . As we go deeper in levels, the estimation becomes more accurate.
+
+![](images/7d098dd5a2e03703fba719a437c4efaf8ac3f03b892863d66d38f34e4a551521.jpg)  
+Figure 3: Illustration of binarized activation function. (a) Conventional 1-level binarization. (b) Residual binarization with two levels.
+
+Multi-level Residual Binarization: Imposing binary constraints on weights and activations of a neural network inherently limits the model’s ability to provide the inference accuracy that a floatingpoint counterpart can achieve. To address this issue, we propose a multi-level binarization scheme where the residual errors are sequentially binarized to increase the numerical precision of the estimation. Figure 2 presents the procedure to compute an estimate $e$ from input $x$ . Each level of the graph (say the $i ^ { t h }$ level) computes the corresponding estimate $e _ { i }$ by taking the sign of its input (the residual error from the $( i - 1 ) ^ { t h }$ level), multiplying it by a parameter $\gamma _ { i }$ , and adding $\pm \gamma _ { i }$ to the estimate of the previous level. In addition, it computes the residual error $r _ { i }$ and feeds it to the input of the next level. The estimates of deeper levels are therefore more accurate representations for the input $x$ . Note that the estimate $e _ { i }$ in level $i$ can be represented using a stream of $i$ bits corresponding to the signs of inputs to the first $i$ levels.
+
+Residual Binary Activation Function: Similar to previous works which use the Sign function as the activation function, in this paper we use the residual binarization to account for the activation function. The difference between our approach and the single-bit approach is shown in Figure 3. Each level has a separate full-precision representative $\gamma _ { i }$ , which should be learned in the training phase. In this setting, the gradients in the backward propagation are computed the same way as in the conventional single-bit binarization (Courbariaux et al. (2016); Rastegari et al. (2016)), regardless of the number of residual levels. In the forward propagation, however, the computed results of our approach provide a more accurate approximation. For instance, if we employ 2 levels of residual binarization, the activation function can take $2 ^ { 2 } = 4$ different values. In general, the total number of possible values for the activation functions for an $l$ -level residual binarization scheme is $2 ^ { l }$ .
+
+Multi-level XNOR-popcount: In ResBinNet, the dot product of an $l$ -level residual-binarized feature   
+vector operati $\vec { e }$ ans. a Let weigand $\vec { w }$ e rende, where usinand $l$ suco equent XNOR-popcoespond to the sign of $\begin{array} { r } { \vec { e } = \sum _ { i = 1 } ^ { l } \gamma _ { e i } \vec { s } _ { e i } } \end{array}$ $\vec { w } = \gamma _ { w } \vec { s } _ { w }$ $\vec { s } _ { e i }$ $\vec { s } _ { w }$ $i ^ { t h }$ $\vec { e }$ $\vec { w }$ $\vec { e }$ $\vec { w }$
+
+$$
+l o t ( \vec { w } , \vec { e } ) = d o t ( \sum _ { i = 1 } ^ { l } \gamma _ { e i } \vec { s } _ { e i } , \gamma _ { w } \vec { s } _ { w } ) = \sum _ { i = 1 } ^ { l } \gamma _ { e i } \gamma _ { w } d o t ( \vec { s } _ { e i } , \vec { s } _ { w } ) = \sum _ { i = 1 } ^ { l } \gamma _ { e i } \gamma _ { w } x n o r p o p c o u n t ( \vec { b } _ { e i } , \vec { b } _ { w } ) ,
+$$
+
+where $\{ \vec { b } _ { e i } , \vec { b } _ { w } \}$ are the binary representations corresponding to $\left\{ \vec { s } _ { e i } , \vec { s } _ { w } \right\}$ , respectively. Note that the subsequent XNOR-popcount operations can be performed sequentially, thus, the same memory used for operating on $\bar { \vec { b } } _ { e i }$ can be reused for operating on $\vec { b } _ { e i + 1 }$ . As a result, the actual memory footprint for a multi-level residual binarization is the same as that of a single-level binarization, provided that the bit streams are processed sequentially.
+
+Residual Encoding: In order to convert matrix-vector multiplications into XNOR-popcount operations, we need to encode a feature $x$ into a stream of binary values $\{ b _ { e i } | i \in 1 , 2 , \ldots , l \}$ . The pseudo code for this operation, which we call Residual Encoding, is presented in Algorithm 1.
+
+# Algorithm 1 l-level residual encoding algorithm
+
+<table><tr><td>inputs: γ1,y2,., Yt,x outputs:be1i,be2,...,bel</td><td></td></tr><tr><td>1:r↑x</td><td></td></tr><tr><td>2:e↑0</td><td></td></tr><tr><td>3: fori=1... do</td><td></td></tr><tr><td>4: bei ←Binarize(Sign(r))</td><td></td></tr><tr><td>5:</td><td>e←e+Sign(r)Xγi</td></tr><tr><td>6: 7: end for</td><td>r←r-Sign(r)×γi</td></tr></table>
+
+# 3 TEMPERATURE ADJUSTMENT
+
+Approximating the weights of a neural network with binary values often results in loss of accuracy in the pertinent model. In this section, we explain our methodology to minimize the approximation error during the training, such that the trained weights exhibit lower binarization errors. Let $W$ denote the parameter set within a certain layer of the neural network. Instead of directly using $W$ to compute the layer’s output, we perform a change of variable $\theta = \gamma H ( \alpha W )$ and compute the output using $\theta$ . Here, $H ( . )$ is a bounded, monotonically-increasing function such as the Hyperbolic Tangent function that is applied on $W$ element-wise. Parameter $\gamma$ is a trainable parameter that adjusts the maximum and minimum values that $\theta$ can take. Parameter $\alpha$ , which we call the Temperature henceforth, controls the slope of function $H ( . )$ .
+
+Effect on Binarization: Figure 4a and 4b illustrate the effect of parameters $\alpha$ and $\gamma$ on the nonlinear change of variable $\theta = \gamma T a n h ( \alpha W )$ . Note that $\theta$ acts as a semi-binarized parameter set in the soft training phase. As we increase the temperature parameter, $H ( . )$ becomes closer to the binary sign function, meaning that the pertinent $\theta$ will exhibit less error when approximated with $\pm \gamma$ . Note that $W$ and $\gamma$ are the trainable parameters in this setting. Parameter $\theta$ is used in the forward propagation phase of the soft training, while in the backward propagation step $W$ is updated.
+
+Effect on Training: Let $g _ { \theta }$ and $g _ { W }$ be the gradients of the training loss function with respect to $\theta$ and $W$ , respectively, then we have $\begin{array} { r } { g _ { W } = \overset { \smile } { \boldsymbol { g } _ { \theta } } \times \frac { \partial \theta } { \partial W } } \end{array}$ . In other words, the magnitude of the gradient that actually flows through out; otherwise, the gradients will flow through $W$ is controlled by $\textstyle { \frac { \partial \theta } { \partial W } }$ ∂WW. . If $\theta$ is close to $\pm \gamma$ , the gradient will be filtered
+
+Efafof t of the Temperature on t the gradient filtering term that are closer to 0 receive $\textstyle { \frac { \partial \theta } { \partial W } }$ ients: Figure 4c illustrates how the temperature parameter canduring the training. As we increase the temperature, elementslified gradients, while the elements that are closer to the binary $W$ regime (i.e. $\theta \approx \pm \gamma )$ encounter damped gradients. This means that increasing the temperature parameter $\alpha$ will push most of the weights to the binary regime with a bigger force; therefore, a neural network trained with high temperature values exhibits a smaller binarization error.
+
+Temperature Adjustment: Setting a high temperature at the beginning of the training will eliminate most of the gradients, preventing the training loss from being optimized. To address this problem, we start the soft binarization phase with a low temperature (e.g. $\alpha = 1$ ) and slightly increase it at the end of each mini-batch. This approach gradually adapts the weights to binary values during the training. Figure 5 presents an example of the histogram of the semi-binarized weights $\theta$ in different training epochs. As can be seen, the distribution is gradually shifted towards binary values as the training proceeds. After soft binarization, the parameter set $\theta$ can be used as an initial point for existing hard binarization schemes such as the method proposed by (Courbariaux et al. (2016)). As We illustrate in Section 5, the soft binarization methodology significantly increases the convergence rate of binary CNNs.
+
+![](images/59289230acb51b9cc6b04e5097add9852a058bdb7cee1fcb861acc5a697b0d73.jpg)  
+Figure 4: An example change of variable with Tanh nonlinearity. (a) The effect of the temperature parameter: higher $\alpha$ values provide better soft-binary estimations. (b) The effect of the bounding parameter: $\gamma$ is a trainable value for each weight matrix $W$ . (c) The effect of the temperature parameter $\alpha$ on the gradient filtering term $\textstyle { \frac { \partial \theta } { \partial W } }$ .
+
+![](images/043165ba90b22216b30134232f0be8fbbd4efb1c3f51511227e63bb4a5b7250b.jpg)  
+Figure 5: Histogram of the elements of $\theta$ in a certain layer of the neural network during training.
+
+# 4 HARDWARE ACCELERATOR MODULES
+
+In this section, we show that the modifications required to incorporate residual binarization into existing hardware accelerators for binary CNNs are minimal. ResBinNet provides a trade-off between inference accuracy and the execution time, while keeping the implementation cost (e.g area cost) almost intact; as a result, ResBinNet readily offers users a decision on the latency of their learning application by compromising the inference accuracy.
+
+As an example, we consider the FPGA accelerator for binary CNNs proposed by (Umuroglu et al. (2017)). We refer the reader to the mentioned paper for details about the original design. Here, we describe the modifications that we integrated into the specific components of their design to accommodate residual binarization. The modified accelerator will be publicly available on Github 2. Figure 6 depicts a schematic view of the original hardware and our modified accelerator. Note that in the original implementation, each layer takes a single binary vector $\vec { b } _ { i n }$ and computes a single output vector $\vec { b } _ { o u t }$ while the modified version processes $l$ streams of binary vectors where $l$ is the desired number of residual levels.
+
+Matrix-Vector Multiplication: Both in the original and the modified accelerators, the matrix-vector multiplication unit is the most computationally intensive among all other operations. In the original design, this unit takes a binary vector $\vec { b } _ { i n }$ and outputs a full-precision vector $\vec { y }$ . To accommodate residual binarization, we modify this module as follows: the XNOR-popcount operation is sequentially performed on the stream of binary vectors $\vec { b } _ { i n , i }$ . Each XNOR-popcount results in a different vector $\vec { y _ { i } }$ . Then, the output is computed as $\begin{array} { r } { \vec { y } = \sum _ { i } \gamma _ { i } \vec { y } _ { i } } \end{array}$ . Note that the computation overhead of the summation is negligible compared to the XNOR-popcount operation, thus, the runtime of multilevel XNOR-popcount with $l$ -level residual representations is approximately $l$ times the runtime of the conventional XNOR-popcount in the original design.
+
+![](images/7169f81894e89b4bf334944074d0486064407ae35584dd8ef9b4159651206453.jpg)  
+Figure 6: Hardware architecture of the baseline (top) and our modified (bottom) binary CNN layer.
+
+Batch-Normalization and Activation Function: Batch-Normalization in the inference phase can be viewed as multiplying a vector $\vec { y }$ by constant vector $\vec { g }$ and subtracting vector $\vec { t }$ to obtain the normalized vector ${ \vec { y } } _ { n o r m }$ . The original design in (Umuroglu et al. (2017)) does not require the multiplication step since only the sign of ${ \vec { y } } _ { n o r m }$ matters to compute the output of the activation function (the Sign function). In our design, the multiplication step is necessary since the value of $\vec { y } _ { n o r m }$ affects the output of our activation function, which is encoded using Algorithm 1 and sent to the next layer to be used as an input.
+
+Max-Pooling: The original implementation simply computes the Boolean OR of the binary values to perform max pooling over the features within a window. In ResBinNet, however, features are represented with $l$ -bit residual representations. As a result, performing Boolean OR over the binary encodings is no longer equivalent to performing max-pooling over the features. Nevertheless, the pooling operation can be performed over the encoded values directly. Assume full-precision values $e _ { x }$ and $e _ { y }$ , with $l$ -level binary encodings $b _ { x }$ and $b _ { y }$ , respectively. Considering ordered positive $\gamma _ { i }$ values (i.e. $\gamma _ { 1 } > \gamma _ { 2 } > . . . > \gamma _ { l } > 0 \nonumber$ ), we can easily conclude that if $e _ { x } < e _ { y }$ then $b _ { x } < b _ { y }$ .
+
+# 5 EXPERIMENTS
+
+We implement our API using Keras (Chollet et al. (2015)) library with a Tensorflow backend. The synthesis reports (resource utilization and latency) for the FPGA accelerator are gathered using Vivado Design Suite (Xilinx (2017)). For temperature adjustment (Section 3), we use a “hard tanh” nonlinearity and gradually increase the temperature by incrementing $\alpha$ at the end of each epoch.
+
+We evaluate ResBinNet by comparing the accuracy, number of training epochs, size of the network, and execution time. Proof-of-concept evaluations are performed for three datasets: MNIST, CIFAR10, and SVHN. Table 1 presents the architecture of the trained neural networks. The architectures are picked from (Umuroglu et al. (2017)).
+
+Table 1: Network architectures for evaluation benchmarks. $C 6 4$ denotes a $3 \times 3$ convolution with 64 output channels, $M P$ stands for $2 \times 2$ max pooling, $B N$ represents batch normalization, and $D 5 1 2$ means a dense layer with 512 outputs. The residual binarizations are shown using $R B$ .   
+
+<table><tr><td rowspan=1 colspan=1>Benchmark</td><td rowspan=1 colspan=1>CNN Architecture</td></tr><tr><td rowspan=1 colspan=1>MNIST</td><td rowspan=1 colspan=1>784(input)-D256-BN-RB-D256-BN-RB-D256-BN-RB-Di0-BN-Softmax</td></tr><tr><td rowspan=1 colspan=1>CIFAR10&amp;SVHN</td><td rowspan=1 colspan=1>3×32×32(input)-C64-BN-RB-C64-BN-RB-MP-C128-BN-RB-C128-BN-RB-MP-C256-BN-RB-C256-BN-RB-D512-BN-RB-D512-BN-RB-D10-BN-Softmax</td></tr></table>
+
+Effect of the model size on accuracy: As discussed in (Umuroglu et al. (2017)), the final accuracy of the binary CNN for a particular application is correlated with the shape of the network. For instance, authors of the paper report that the accuracy of MNIST for the architecture in Table 2 varies in the range $( 9 5 . 8 3 \% . 9 8 . 4 \% )$ when the number of neurons in hidden layers is varied from 256 to 1024. Similarly, the architecture in (Umuroglu et al. (2017)) for CIFAR-10 is a smaller version of the architecture originally trained by (Courbariaux et al. (2016)). Using this smaller architecture drops the accuracy from $8 8 . 6 \%$ to $8 0 . 1 \%$ . In our evaluations, we show that ResBinNet can reduce the accuracy drop using more residual binary levels for the activations of the smaller model.
+
+Table 2: Comparison of model size, number of training epochs, and accuracy.   
+
+<table><tr><td rowspan="2">Benchmark</td><td colspan="3">Binarynet(Courbariaux et al. (2016))</td><td colspan="3">FINN (Umuroglu et al. (2017))</td><td colspan="5">ResBinNet</td></tr><tr><td>#Epochs</td><td>Accuracy</td><td>Size (Mbits)</td><td>#Epochs</td><td>Accuracy</td><td>Size (Mbits)</td><td>#Epochs</td><td>Size (Mbits)</td><td>Accuracy (1-level)</td><td>Accuracy (2-level)</td><td>Accuracy (3-level)</td></tr><tr><td>CIFAR-10</td><td>500</td><td>89.85%</td><td>5.24</td><td>NA</td><td>80.1%</td><td>1.5</td><td>50+1</td><td>1.5</td><td>76%</td><td>83.5%</td><td>84.6%</td></tr><tr><td>SVHN</td><td>200</td><td>97.47%</td><td>5.24</td><td>NA</td><td>94.9%</td><td>1.5</td><td>10+1</td><td>1.5</td><td>95.2%</td><td>96.9%</td><td>97.1%</td></tr><tr><td>MNIST</td><td>1000</td><td>99.04%</td><td>52.7</td><td>NA</td><td>95.83%</td><td>0.3</td><td>30+1</td><td>0.3</td><td>97.3%</td><td>97.9%</td><td>98.1%</td></tr></table>
+
+Effect of the number of epochs on accuracy: Compared to full-precision neural networks, binarized CNNs usually need more training epochs to achieve the same accuracy. For example, the CIFAR-10 architecture in (Courbariaux et al. (2016)) is trained for 500 epochs, while the fullprecision version of the same network can achieve comparable accuracy in roughly 50 iterations 3. Here, we argue that soft binarization in ResBinNet can significantly reduce the number of training epochs for binary CNNs.
+
+Table 2 compares ResBinNet with two prior arts, namely Binarynet and FINN. Both baselines use the same training methodology, but the network architectures in FINN are considerably smaller, which leads to lower accuracy rates for FINN. We evaluate ResBinNet using the small architectures of FINN. The training of ResBinNet consists of a soft binarization phase and a single fine-tuning epoch. Note that the fine-tuning phase uses the same algorithm as the two baselines. The higher accuracy of Binarynet compared to our approach is a direct result of employing a large architecture and training for many epochs. For each benchmark, the comparison between our approach and the same network architecture of FINN is followed:
+
+• CIFAR-10: Compared to FINN, ResBinNet achieves higher accuracy for more than 1 level of residual binarization. We argue that, even for 1-level binarization, the same accuracy is viable if we fine-tune the soft-binarized model (after 50 epochs) for more than 1 epochs (FINN and ResBinNet use the same algorithms in this phase). In addition, the convergence rate of ResBinNet is improved as the number of residual levels is increased. SVHN and MNIST: For these datasets, ResBinNet achieves a higher accuracy with even fewer epochs compared to CIFAR-10. The final accuracy and the convergence speed also exhibit improvement as the number of residual levels is increased from 1 to 3.
+
+We now evaluate the area overhead and execution time of ResBinNet for the modified hardware architecture, which we discussed previously in Section 4. We compare the implementation of the CNN architecture used for the CIFAR-10 and SVHN tasks (See Table 1). Figure 7 compares the hardware resource utilization, and execution time per input.
+
+The resource utilization of ResBinNet is evaluated in Figure 7a, which compares the utilization (in $\%$ ) for different resources of the FPGA (i.e. BRAM, DSP, LUT, and Registers). For each resource, we compare the baseline with different number of residual binarization levels in ResBinNet. Asides from the DSP utilization, which is required for full-precision multiplications in batch normalization, the other three resources show a modest increase in utilization, meaning that the residual binarization method offers a scalable design for real-world systems.
+
+Figure 7b compares the latency (runtime) of ResBinNet with the baseline accelerator. In particular, we consider multi-level residual binarization with 1, 2, and 3 residual levels which are denoted by RBN1, RBN2, and RBN3, respectively. The numbers on top of the bars show the accuracy of the corresponding binarized CNN for CIFAR-10 task. As can be seen, ResBinNet enables users to achieve higher accuracy by tolerating a higher latency, which is almost linear with respect to the number of residual levels.
+
+![](images/8c140af2efab2c931fe4d7311ae79d3d93d55c8f0f733932f444cb3a11534698.jpg)  
+Figure 7: (a) Resource utilization overhead of ResBinNet with different residual levels versus baseline design( Umuroglu et al. (2017)) implemented on Xilinx ZC706 Evaluation Kit. (b) Latencyaccuracy trade-off offered by ResBinNet with different residual levels.
+
+# 6 RELATED WORK
+
+Training CNNs with binary weights and/or activations has been the subject of very recent works (Courbariaux et al. (2015); Rastegari et al. (2016); Courbariaux et al. (2016); Umuroglu et al. (2017)). The authors of Binaryconnect (Courbariaux et al. (2015)) suggest a probabilistic methodology that leverages the full-precision weights to generate binary representatives during forward pass while in the back-propagation the full-precision weights are updated. (Courbariaux et al. (2016)) is the first work attempting to binarize both weight and activations of CNN. In this work, authors also suggest replacing the costly dot products by XNOR-popcount operations. XNOR-net (Rastegari et al. (2016)) proposes to use scale factors during training, which results in an improved accuracy. The aforementioned works propose optimization solutions that enable the use of binarized values in CNNs which, in turn, enable the design of simple and efficient hardware accelerators. The downside of these works is that, aside from changing the architecture of the CNN (Umuroglu et al. (2017)), they do not offer any other reconfigurability in their designs.
+
+On another track of research, the reconfigurability of CNN accelerators has been investigated. This line of research focuses on using adaptive low bit-width representations for compressing the parameters and/or simplifying the pertinent arithmetic operations (Zhou et al. (2016); Han et al. (2016); Wu et al. (2016); Cai et al. (2017)). The proposed solutions, however, do not enjoy the same simplified XNOR-popcount operations as in binarized CNNs.
+
+Among the aforementioned works, a unified solution which is both reconfigurable and binarized is missing. To the best of our knowledge, ResBinNet is the first to offer a solution which is reconfigurable and, at the same time, enjoys the benefits of binarized CNNs. Our goal in the design of ResBinNet was to remain consistent with the existing CNN optimization solutions. As shown in the paper, ResBinNet is compatible with the accelerators designed for binarized CNNs.
+
+# 7 CONCLUSION
+
+This paper introduces ResBinNet, a novel reconfigurable binarization scheme which aims to improve the convergence rate and the final accuracy of binary CNNs. The proposed training is twofold: (i) In the first phase, called soft binarization, we introduce two distinct methodologies designed for binarizing weights and feature within CNNs, namely residual binarization, and temperature adjustment. Residual binarization learns a multi-level representation for features of CNN to provide an arbitrary numerical precision during inference. Temperature adjustment gradually imposes binarization constraints on the weights. (ii) In the second phase, which we call hard binarization, the model is fine-tuned in few training epochs. Our experiments demonstrate that the joint use of residual binarization and temperature adjustment improves the convergence rate and the accuracy of the binarized CNN. We argue that ResBinNet methodology can be adopted by current CNN hardware accelerators as it requires minimal modification to existing binarized CNN solutions. Developers can integrate the approaches proposed in this paper into their deep learning systems to provide users with a trade-off between application latency and inference accuracy.
+
+# REFERENCES
+
+Zhaowei Cai, Xiaodong He, Jian Sun, and Nuno Vasconcelos. Deep learning with low precision by half-wave gaussian quantization. arXiv preprint arXiv:1702.00953, 2017.
+
+Franc¸ois Chollet et al. Keras. https://github.com/fchollet/keras, 2015.
+
+Matthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. Binaryconnect: Training deep neural networks with binary weights during propagations. In Advances in Neural Information Processing Systems, pp. 3123–3131, 2015.
+
+Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training deep neural networks with weights and activations constrained $\mathrm { t o } + 1$ or-1. arXiv preprint arXiv:1602.02830, 2016.
+
+Misha Denil, Babak Shakibi, Laurent Dinh, Nando de Freitas, et al. Predicting parameters in deep learning. In Advances in Neural Information Processing Systems, pp. 2148–2156, 2013.
+
+Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015.
+
+Song Han, Xingyu Liu, Huizi Mao, Jing Pu, Ardavan Pedram, Mark A Horowitz, and William J Dally. Eie: efficient inference engine on compressed deep neural network. In Proceedings of the 43rd International Symposium on Computer Architecture, pp. 243–254. IEEE Press, 2016.
+
+Geoffrey E Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan R Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012.
+
+Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Quantized neural networks: Training neural networks with low precision weights and activations. arXiv preprint arXiv:1609.07061, 2016.
+
+Yong-Deok Kim, Eunhyeok Park, Sungjoo Yoo, Taelim Choi, Lu Yang, and Dongjun Shin. Compression of deep convolutional neural networks for fast and low power mobile applications. arXiv preprint arXiv:1511.06530, 2015.
+
+Baoyuan Liu, Min Wang, Hassan Foroosh, Marshall Tappen, and Marianna Pensky. Sparse convolutional neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 806–814, 2015.
+
+Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In European Conference on Computer Vision, pp. 525–542. Springer, 2016.
+
+Yaman Umuroglu, Nicholas J Fraser, Giulio Gambardella, Michaela Blott, Philip Leong, Magnus Jahre, and Kees Vissers. Finn: A framework for fast, scalable binarized neural network inference. In Proceedings of the 2017 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays, pp. 65–74. ACM, 2017.
+
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Advances in Neural Information Processing Systems, pp. 2074–2082, 2016.
+
+Jiaxiang Wu, Cong Leng, Yuhang Wang, Qinghao Hu, and Jian Cheng. Quantized convolutional neural networks for mobile devices. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4820–4828, 2016.
+
+Xilinx. Vivado. https://www.xilinx.com/products/design-tools/vivado. html, 2017.
+
+Xiangyu Zhang, Jianhua Zou, Xiang Ming, Kaiming He, and Jian Sun. Efficient and accurate approximations of nonlinear convolutional networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1984–1992, 2015.
+
+Shuchang Zhou, Yuxin Wu, Zekun Ni, Xinyu Zhou, He Wen, and Yuheng Zou. Dorefa-net: Training low bitwidth convolutional neural networks with low bitwidth gradients. arXiv preprint arXiv:1606.06160, 2016.

parse/train/SJtfOEn6-/SJtfOEn6-_content_list.json

@@ -0,0 +1,949 @@
+[
+    {
+        "type": "text",
+        "text": "RESBINNET: RESIDUAL BINARY NEURAL NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            812,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            398,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            210,
+            544,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent efforts on training light-weight binary neural networks offer promising execution/memory efficiency. This paper introduces ResBinNet, which is a composition of two interlinked methodologies aiming to address the slow convergence speed and limited accuracy of binary convolutional neural networks. The first method, called residual binarization, learns a multi-level binary representation for the features within a certain neural network layer. The second method, called temperature adjustment, gradually binarizes the weights of a particular layer. The two methods jointly learn a set of soft-binarized parameters that improve the convergence rate and accuracy of binary neural networks. We corroborate the applicability and scalability of ResBinNet by implementing a prototype hardware accelerator. The accelerator is reconfigurable in terms of the numerical precision of the binarized features, offering a trade-off between runtime and inference accuracy. ",
+        "bbox": [
+            233,
+            241,
+            764,
+            407
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            434,
+            334,
+            449
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolutional Neural Networks (CNNs) have shown promising inference accuracy for learning applications in various domains. These models are generally over-parameterized to facilitate the convergence during the training phase (Hinton et al. (2012); Denil et al. (2013)). A line of optimization methodologies such as tensor decomposition (Kim et al. (2015); Zhang et al. (2015)), parameter quantization (Hubara et al. (2016); Han et al. (2015)), sparse convolutions (Liu et al. (2015); Wen et al. (2016)), and binary networks (Courbariaux et al. (2016); Rastegari et al. (2016)) have been proposed to reduce the complexity of neural networks for efficient execution. Among these works, binary neural networks result in two particular benefits: (i) They reduce the memory footprint by a factor of 32 compared to the full-precision model; this is specifically important since memory access plays an essential role in the execution of CNNs on resource-constrained devices. (ii) Binary networks replace the costly multiplications with simple XNOR operations (Rastegari et al. (2016); Umuroglu et al. (2017)), reducing the execution time and energy consumption significantly. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            632
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Considering the prior art, there exist two major challenges associated with binary neural networks. First, the convergence rate of the existing solutions for training binary CNNs is considerably slower than their full-precision counterparts. Second, in order to achieve comparable classification accuracy, binarized neural networks often compensate for the numerical precision loss by employing high dimensional feature maps in a wide CNN topology, which in turn reduces the effective compression rate. As a result, full-precision networks often surpass binary networks in terms of convergence rate and final achievable accuracy. ",
+        "bbox": [
+            174,
+            638,
+            823,
+            736
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose ResBinNet, a novel solution for increasing the convergence rate and the final accuracy of binary networks. The global flow of ResBinNet is depicted in Figure 1. The first phase, which we call Soft Binarization, includes two methodologies that we propose to address the aforementioned challenges for training binary CNNs. First, we introduce a Residual Binarization scheme which allows the number of possible values for activation units to be reconfigurable at runtime. To this purpose, we learn a multi-level residual representation for the features within the CNN to adaptively increase the numerical precision of the activation units. Second, we introduce a novel weight binarization approach, called Tempreture Adjustment, which aims to gradually enforce binarization constraints over the weight parameters throughout the training phase. The two interlinked methods significantly improve both the convergence rate and the final accuracy of ResBinNet compared to prior art. Once the soft training phase is finished, we convert the weights to actual binary values (0,1). Fine-tuning of the model is then performed in Hard Binarization phase using existing training algorithms (e.g. BinaryNets (Courbariaux et al. (2016))) in few epochs (e.g. one epoch). ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/f122029c957b6c584853f614e0a66dba706773859e507f7b86a0a52e05c9a144.jpg",
+        "image_caption": [
+            "Figure 1: The global flow of ResBinNet binary training. Residual binarization learns a multi-level representation for feature maps. Temperature adjustment performs a change of variable over the trainable weights and gradually pushes them towards binary values during the training phase. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            271,
+            99,
+            727,
+            219
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "ResBinNet is designed to fulfill certain goals: (i) It should enable reconfigurability for binary neural networks; in other words, the number of residual binary representatives should be adjustable to offer a trade-off between inference accuracy and computation time. (ii) The multi-level binarized features should be compatible with the XNOR multiplication approach proposed in the existing literature. (iii) ResBinNet should speed up the convergence rate of binarized CNNs. (iv) Current hardware accelerators for binary CNNs should be able to benefit from ResBinNet with minimum modification in their design. In summary, the contributions of this paper are as follows: ",
+        "bbox": [
+            174,
+            297,
+            825,
+            396
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Proposing residual binarization, a methodology for learning multi-level residual representations for each feature map in binary CNNs. Introducing temperature adjustment as a practical approach for gradual (soft) binarization of CNN weights.   \n• Analyzing the trade-off between accuracy and execution time of ResBinNet on a real hardware design.   \n• Evaluating ResBinNet convergence rate and accuracy on three datasets: MNIST, SVHN, and CIFAR-10.   \n• Development of an open-source Application Program Interface (API) for ResBinNet1. ",
+        "bbox": [
+            215,
+            402,
+            825,
+            551
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The remainder of the paper is organized as follows: In Section 2, we describe the residual binarization method for binarizing activations. Section 3 explains the temperature adjustment technique for binarizing weights. In Section 4, we discuss how particular ResBinNet operations (e.g. multi-level XNOR-popcount) can be efficiently implemented on existing hardware accelerators. Experiments are discussed in Section 5. Finally, we discuss the related work and conclusion in Sections 6 and 7. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            627
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RESIDUAL BINARIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            647,
+            421,
+            664
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A binarization scheme converts value $x$ to the binarized estimation $e _ { x }$ , which can take one of the possible values $\\gamma$ or $- \\gamma$ . This representation allows us to represent $e _ { x }$ with a single bit $b _ { x }$ . In particular, for a given layer within the CNN, we can store the single full-precision value of $\\gamma$ as a representative for all features, and reduce the memory footprint by storing bits $b _ { x }$ instead of $x$ for each feature. Assuming that both the weights and input features of a CNN layer are binarized, each dot product between a feature vector $\\vec { x }$ and weight vector $\\vec { w }$ can be efficiently computed using XNOR-popcount operations as previously suggested in (Courbariaux et al. (2016); Rastegari et al. (2016)). Let $\\vec { x } = \\vec { \\gamma } _ { x } \\vec { s } _ { x }$ and $\\bar { w } = \\gamma _ { w } \\ \\bar { s } _ { w }$ where $\\{ \\gamma _ { x } , \\gamma _ { w } \\}$ are scalar values and $\\{ \\vec { s } _ { x } , \\vec { s } _ { w } \\}$ are the corresponding sign vectors. The binary representations of $\\{ \\vec { x } , \\vec { y } \\}$ , which we denote by $\\{ \\vec { b } _ { x } , \\vec { b } _ { w } \\}$ , are simply computed by encoding the sign vectors $\\vec { s }$ to binary vectors. The dot product between $\\vec { x }$ and $\\vec { w }$ can be computed as: ",
+        "bbox": [
+            173,
+            680,
+            825,
+            835
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c1e4fc9d8ba5e7909dc59c42519319a0b0dcbc6e110e997fd653493a25f01053.jpg",
+        "text": "$$\nd o t ( \\vec { w } , \\vec { x } ) = \\gamma _ { x } \\gamma _ { w } d o t ( \\vec { s } _ { x } , \\vec { s } _ { w } ) = \\gamma _ { x } \\gamma _ { w } x n o r p o p c o u n t ( \\vec { b _ { x } } , \\vec { b _ { w } } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            843,
+            710,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where xnorpopcount $\\cdot , . . )$ returns the number of set bits in the element-wise XNOR of the input binary vectors. ",
+        "bbox": [
+            176,
+            869,
+            823,
+            898
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/04c65714483d338b9b9f96b58dd93d8c9a9cc027b6b879a2ef034e65a98aaacc.jpg",
+        "image_caption": [
+            "Figure 2: Schematic flow for computing 3 levels of residual binary estimates $e$ . As we go deeper in levels, the estimation becomes more accurate. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            823,
+            280
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/7d098dd5a2e03703fba719a437c4efaf8ac3f03b892863d66d38f34e4a551521.jpg",
+        "image_caption": [
+            "Figure 3: Illustration of binarized activation function. (a) Conventional 1-level binarization. (b) Residual binarization with two levels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            328,
+            333,
+            668,
+            448
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multi-level Residual Binarization: Imposing binary constraints on weights and activations of a neural network inherently limits the model’s ability to provide the inference accuracy that a floatingpoint counterpart can achieve. To address this issue, we propose a multi-level binarization scheme where the residual errors are sequentially binarized to increase the numerical precision of the estimation. Figure 2 presents the procedure to compute an estimate $e$ from input $x$ . Each level of the graph (say the $i ^ { t h }$ level) computes the corresponding estimate $e _ { i }$ by taking the sign of its input (the residual error from the $( i - 1 ) ^ { t h }$ level), multiplying it by a parameter $\\gamma _ { i }$ , and adding $\\pm \\gamma _ { i }$ to the estimate of the previous level. In addition, it computes the residual error $r _ { i }$ and feeds it to the input of the next level. The estimates of deeper levels are therefore more accurate representations for the input $x$ . Note that the estimate $e _ { i }$ in level $i$ can be represented using a stream of $i$ bits corresponding to the signs of inputs to the first $i$ levels. ",
+        "bbox": [
+            173,
+            513,
+            825,
+            666
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Residual Binary Activation Function: Similar to previous works which use the Sign function as the activation function, in this paper we use the residual binarization to account for the activation function. The difference between our approach and the single-bit approach is shown in Figure 3. Each level has a separate full-precision representative $\\gamma _ { i }$ , which should be learned in the training phase. In this setting, the gradients in the backward propagation are computed the same way as in the conventional single-bit binarization (Courbariaux et al. (2016); Rastegari et al. (2016)), regardless of the number of residual levels. In the forward propagation, however, the computed results of our approach provide a more accurate approximation. For instance, if we employ 2 levels of residual binarization, the activation function can take $2 ^ { 2 } = 4$ different values. In general, the total number of possible values for the activation functions for an $l$ -level residual binarization scheme is $2 ^ { l }$ . ",
+        "bbox": [
+            173,
+            674,
+            825,
+            813
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multi-level XNOR-popcount: In ResBinNet, the dot product of an $l$ -level residual-binarized feature   \nvector operati $\\vec { e }$ ans. a Let weigand $\\vec { w }$ e rende, where usinand $l$ suco equent XNOR-popcoespond to the sign of $\\begin{array} { r } { \\vec { e } = \\sum _ { i = 1 } ^ { l } \\gamma _ { e i } \\vec { s } _ { e i } } \\end{array}$ $\\vec { w } = \\gamma _ { w } \\vec { s } _ { w }$ $\\vec { s } _ { e i }$ $\\vec { s } _ { w }$ $i ^ { t h }$ $\\vec { e }$ $\\vec { w }$ $\\vec { e }$ $\\vec { w }$ ",
+        "bbox": [
+            173,
+            820,
+            826,
+            880
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/903df5648d4f81175b912097a96184d26c71a5d03255b6307d6add5bd95637d1.jpg",
+        "text": "$$\nl o t ( \\vec { w } , \\vec { e } ) = d o t ( \\sum _ { i = 1 } ^ { l } \\gamma _ { e i } \\vec { s } _ { e i } , \\gamma _ { w } \\vec { s } _ { w } ) = \\sum _ { i = 1 } ^ { l } \\gamma _ { e i } \\gamma _ { w } d o t ( \\vec { s } _ { e i } , \\vec { s } _ { w } ) = \\sum _ { i = 1 } ^ { l } \\gamma _ { e i } \\gamma _ { w } x n o r p o p c o u n t ( \\vec { b } _ { e i } , \\vec { b } _ { w } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            885,
+            833,
+            928
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\{ \\vec { b } _ { e i } , \\vec { b } _ { w } \\}$ are the binary representations corresponding to $\\left\\{ \\vec { s } _ { e i } , \\vec { s } _ { w } \\right\\}$ , respectively. Note that the subsequent XNOR-popcount operations can be performed sequentially, thus, the same memory used for operating on $\\bar { \\vec { b } } _ { e i }$ can be reused for operating on $\\vec { b } _ { e i + 1 }$ . As a result, the actual memory footprint for a multi-level residual binarization is the same as that of a single-level binarization, provided that the bit streams are processed sequentially. ",
+        "bbox": [
+            174,
+            102,
+            825,
+            176
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Residual Encoding: In order to convert matrix-vector multiplications into XNOR-popcount operations, we need to encode a feature $x$ into a stream of binary values $\\{ b _ { e i } | i \\in 1 , 2 , \\ldots , l \\}$ . The pseudo code for this operation, which we call Residual Encoding, is presented in Algorithm 1. ",
+        "bbox": [
+            174,
+            183,
+            825,
+            226
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 l-level residual encoding algorithm ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            241,
+            493,
+            256
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/fcae472a75b7333aa9dabfa026075547e0adabe29f59b9c52e06981635c7a9e9.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>inputs: γ1,y2,., Yt,x outputs:be1i,be2,...,bel</td><td></td></tr><tr><td>1:r↑x</td><td></td></tr><tr><td>2:e↑0</td><td></td></tr><tr><td>3: fori=1... do</td><td></td></tr><tr><td>4: bei ←Binarize(Sign(r))</td><td></td></tr><tr><td>5:</td><td>e←e+Sign(r)Xγi</td></tr><tr><td>6: 7: end for</td><td>r←r-Sign(r)×γi</td></tr></table>",
+        "bbox": [
+            174,
+            258,
+            825,
+            377
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 TEMPERATURE ADJUSTMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            415,
+            449,
+            431
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Approximating the weights of a neural network with binary values often results in loss of accuracy in the pertinent model. In this section, we explain our methodology to minimize the approximation error during the training, such that the trained weights exhibit lower binarization errors. Let $W$ denote the parameter set within a certain layer of the neural network. Instead of directly using $W$ to compute the layer’s output, we perform a change of variable $\\theta = \\gamma H ( \\alpha W )$ and compute the output using $\\theta$ . Here, $H ( . )$ is a bounded, monotonically-increasing function such as the Hyperbolic Tangent function that is applied on $W$ element-wise. Parameter $\\gamma$ is a trainable parameter that adjusts the maximum and minimum values that $\\theta$ can take. Parameter $\\alpha$ , which we call the Temperature henceforth, controls the slope of function $H ( . )$ . ",
+        "bbox": [
+            173,
+            446,
+            825,
+            573
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Effect on Binarization: Figure 4a and 4b illustrate the effect of parameters $\\alpha$ and $\\gamma$ on the nonlinear change of variable $\\theta = \\gamma T a n h ( \\alpha W )$ . Note that $\\theta$ acts as a semi-binarized parameter set in the soft training phase. As we increase the temperature parameter, $H ( . )$ becomes closer to the binary sign function, meaning that the pertinent $\\theta$ will exhibit less error when approximated with $\\pm \\gamma$ . Note that $W$ and $\\gamma$ are the trainable parameters in this setting. Parameter $\\theta$ is used in the forward propagation phase of the soft training, while in the backward propagation step $W$ is updated. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            664
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Effect on Training: Let $g _ { \\theta }$ and $g _ { W }$ be the gradients of the training loss function with respect to $\\theta$ and $W$ , respectively, then we have $\\begin{array} { r } { g _ { W } = \\overset { \\smile } { \\boldsymbol { g } _ { \\theta } } \\times \\frac { \\partial \\theta } { \\partial W } } \\end{array}$ . In other words, the magnitude of the gradient that actually flows through out; otherwise, the gradients will flow through $W$ is controlled by $\\textstyle { \\frac { \\partial \\theta } { \\partial W } }$ ∂WW. . If $\\theta$ is close to $\\pm \\gamma$ , the gradient will be filtered ",
+        "bbox": [
+            173,
+            670,
+            825,
+            729
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Efafof t of the Temperature on t the gradient filtering term that are closer to 0 receive $\\textstyle { \\frac { \\partial \\theta } { \\partial W } }$ ients: Figure 4c illustrates how the temperature parameter canduring the training. As we increase the temperature, elementslified gradients, while the elements that are closer to the binary $W$ regime (i.e. $\\theta \\approx \\pm \\gamma )$ encounter damped gradients. This means that increasing the temperature parameter $\\alpha$ will push most of the weights to the binary regime with a bigger force; therefore, a neural network trained with high temperature values exhibits a smaller binarization error. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Temperature Adjustment: Setting a high temperature at the beginning of the training will eliminate most of the gradients, preventing the training loss from being optimized. To address this problem, we start the soft binarization phase with a low temperature (e.g. $\\alpha = 1$ ) and slightly increase it at the end of each mini-batch. This approach gradually adapts the weights to binary values during the training. Figure 5 presents an example of the histogram of the semi-binarized weights $\\theta$ in different training epochs. As can be seen, the distribution is gradually shifted towards binary values as the training proceeds. After soft binarization, the parameter set $\\theta$ can be used as an initial point for existing hard binarization schemes such as the method proposed by (Courbariaux et al. (2016)). As We illustrate in Section 5, the soft binarization methodology significantly increases the convergence rate of binary CNNs. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/59289230acb51b9cc6b04e5097add9852a058bdb7cee1fcb861acc5a697b0d73.jpg",
+        "image_caption": [
+            "Figure 4: An example change of variable with Tanh nonlinearity. (a) The effect of the temperature parameter: higher $\\alpha$ values provide better soft-binary estimations. (b) The effect of the bounding parameter: $\\gamma$ is a trainable value for each weight matrix $W$ . (c) The effect of the temperature parameter $\\alpha$ on the gradient filtering term $\\textstyle { \\frac { \\partial \\theta } { \\partial W } }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            99,
+            754,
+            209
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/043165ba90b22216b30134232f0be8fbbd4efb1c3f51511227e63bb4a5b7250b.jpg",
+        "image_caption": [
+            "Figure 5: Histogram of the elements of $\\theta$ in a certain layer of the neural network during training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            248,
+            303,
+            741,
+            410
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            464,
+            823,
+            507
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 HARDWARE ACCELERATOR MODULES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            530,
+            524,
+            546
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we show that the modifications required to incorporate residual binarization into existing hardware accelerators for binary CNNs are minimal. ResBinNet provides a trade-off between inference accuracy and the execution time, while keeping the implementation cost (e.g area cost) almost intact; as a result, ResBinNet readily offers users a decision on the latency of their learning application by compromising the inference accuracy. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            633
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As an example, we consider the FPGA accelerator for binary CNNs proposed by (Umuroglu et al. (2017)). We refer the reader to the mentioned paper for details about the original design. Here, we describe the modifications that we integrated into the specific components of their design to accommodate residual binarization. The modified accelerator will be publicly available on Github 2. Figure 6 depicts a schematic view of the original hardware and our modified accelerator. Note that in the original implementation, each layer takes a single binary vector $\\vec { b } _ { i n }$ and computes a single output vector $\\vec { b } _ { o u t }$ while the modified version processes $l$ streams of binary vectors where $l$ is the desired number of residual levels. ",
+        "bbox": [
+            173,
+            641,
+            825,
+            757
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Matrix-Vector Multiplication: Both in the original and the modified accelerators, the matrix-vector multiplication unit is the most computationally intensive among all other operations. In the original design, this unit takes a binary vector $\\vec { b } _ { i n }$ and outputs a full-precision vector $\\vec { y }$ . To accommodate residual binarization, we modify this module as follows: the XNOR-popcount operation is sequentially performed on the stream of binary vectors $\\vec { b } _ { i n , i }$ . Each XNOR-popcount results in a different vector $\\vec { y _ { i } }$ . Then, the output is computed as $\\begin{array} { r } { \\vec { y } = \\sum _ { i } \\gamma _ { i } \\vec { y } _ { i } } \\end{array}$ . Note that the computation overhead of the summation is negligible compared to the XNOR-popcount operation, thus, the runtime of multilevel XNOR-popcount with $l$ -level residual representations is approximately $l$ times the runtime of the conventional XNOR-popcount in the original design. ",
+        "bbox": [
+            173,
+            763,
+            825,
+            893
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/7169f81894e89b4bf334944074d0486064407ae35584dd8ef9b4159651206453.jpg",
+        "image_caption": [
+            "Figure 6: Hardware architecture of the baseline (top) and our modified (bottom) binary CNN layer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            106,
+            766,
+            300
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Batch-Normalization and Activation Function: Batch-Normalization in the inference phase can be viewed as multiplying a vector $\\vec { y }$ by constant vector $\\vec { g }$ and subtracting vector $\\vec { t }$ to obtain the normalized vector ${ \\vec { y } } _ { n o r m }$ . The original design in (Umuroglu et al. (2017)) does not require the multiplication step since only the sign of ${ \\vec { y } } _ { n o r m }$ matters to compute the output of the activation function (the Sign function). In our design, the multiplication step is necessary since the value of $\\vec { y } _ { n o r m }$ affects the output of our activation function, which is encoded using Algorithm 1 and sent to the next layer to be used as an input. ",
+        "bbox": [
+            173,
+            352,
+            825,
+            452
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Max-Pooling: The original implementation simply computes the Boolean OR of the binary values to perform max pooling over the features within a window. In ResBinNet, however, features are represented with $l$ -bit residual representations. As a result, performing Boolean OR over the binary encodings is no longer equivalent to performing max-pooling over the features. Nevertheless, the pooling operation can be performed over the encoded values directly. Assume full-precision values $e _ { x }$ and $e _ { y }$ , with $l$ -level binary encodings $b _ { x }$ and $b _ { y }$ , respectively. Considering ordered positive $\\gamma _ { i }$ values (i.e. $\\gamma _ { 1 } > \\gamma _ { 2 } > . . . > \\gamma _ { l } > 0 \\nonumber$ ), we can easily conclude that if $e _ { x } < e _ { y }$ then $b _ { x } < b _ { y }$ . ",
+        "bbox": [
+            173,
+            458,
+            825,
+            556
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            575,
+            326,
+            592
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We implement our API using Keras (Chollet et al. (2015)) library with a Tensorflow backend. The synthesis reports (resource utilization and latency) for the FPGA accelerator are gathered using Vivado Design Suite (Xilinx (2017)). For temperature adjustment (Section 3), we use a “hard tanh” nonlinearity and gradually increase the temperature by incrementing $\\alpha$ at the end of each epoch. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            664
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate ResBinNet by comparing the accuracy, number of training epochs, size of the network, and execution time. Proof-of-concept evaluations are performed for three datasets: MNIST, CIFAR10, and SVHN. Table 1 presents the architecture of the trained neural networks. The architectures are picked from (Umuroglu et al. (2017)). ",
+        "bbox": [
+            173,
+            670,
+            825,
+            727
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/96044c8baaf276580e60435e09b2dae6800a57b8418d7485388897db7cbc497f.jpg",
+        "table_caption": [
+            "Table 1: Network architectures for evaluation benchmarks. $C 6 4$ denotes a $3 \\times 3$ convolution with 64 output channels, $M P$ stands for $2 \\times 2$ max pooling, $B N$ represents batch normalization, and $D 5 1 2$ means a dense layer with 512 outputs. The residual binarizations are shown using $R B$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Benchmark</td><td rowspan=1 colspan=1>CNN Architecture</td></tr><tr><td rowspan=1 colspan=1>MNIST</td><td rowspan=1 colspan=1>784(input)-D256-BN-RB-D256-BN-RB-D256-BN-RB-Di0-BN-Softmax</td></tr><tr><td rowspan=1 colspan=1>CIFAR10&amp;SVHN</td><td rowspan=1 colspan=1>3×32×32(input)-C64-BN-RB-C64-BN-RB-MP-C128-BN-RB-C128-BN-RB-MP-C256-BN-RB-C256-BN-RB-D512-BN-RB-D512-BN-RB-D10-BN-Softmax</td></tr></table>",
+        "bbox": [
+            302,
+            791,
+            691,
+            881
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Effect of the model size on accuracy: As discussed in (Umuroglu et al. (2017)), the final accuracy of the binary CNN for a particular application is correlated with the shape of the network. For instance, authors of the paper report that the accuracy of MNIST for the architecture in Table 2 varies in the range $( 9 5 . 8 3 \\% . 9 8 . 4 \\% )$ when the number of neurons in hidden layers is varied from 256 to 1024. Similarly, the architecture in (Umuroglu et al. (2017)) for CIFAR-10 is a smaller version of the architecture originally trained by (Courbariaux et al. (2016)). Using this smaller architecture drops the accuracy from $8 8 . 6 \\%$ to $8 0 . 1 \\%$ . In our evaluations, we show that ResBinNet can reduce the accuracy drop using more residual binary levels for the activations of the smaller model. ",
+        "bbox": [
+            171,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/6db40d084f02e97ff2052e067b1e367f395c982fbb024a1660c61a8f8f3f5437.jpg",
+        "table_caption": [
+            "Table 2: Comparison of model size, number of training epochs, and accuracy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Benchmark</td><td colspan=\"3\">Binarynet(Courbariaux et al. (2016))</td><td colspan=\"3\">FINN (Umuroglu et al. (2017))</td><td colspan=\"5\">ResBinNet</td></tr><tr><td>#Epochs</td><td>Accuracy</td><td>Size (Mbits)</td><td>#Epochs</td><td>Accuracy</td><td>Size (Mbits)</td><td>#Epochs</td><td>Size (Mbits)</td><td>Accuracy (1-level)</td><td>Accuracy (2-level)</td><td>Accuracy (3-level)</td></tr><tr><td>CIFAR-10</td><td>500</td><td>89.85%</td><td>5.24</td><td>NA</td><td>80.1%</td><td>1.5</td><td>50+1</td><td>1.5</td><td>76%</td><td>83.5%</td><td>84.6%</td></tr><tr><td>SVHN</td><td>200</td><td>97.47%</td><td>5.24</td><td>NA</td><td>94.9%</td><td>1.5</td><td>10+1</td><td>1.5</td><td>95.2%</td><td>96.9%</td><td>97.1%</td></tr><tr><td>MNIST</td><td>1000</td><td>99.04%</td><td>52.7</td><td>NA</td><td>95.83%</td><td>0.3</td><td>30+1</td><td>0.3</td><td>97.3%</td><td>97.9%</td><td>98.1%</td></tr></table>",
+        "bbox": [
+            179,
+            127,
+            818,
+            181
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            212,
+            825,
+            295
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Effect of the number of epochs on accuracy: Compared to full-precision neural networks, binarized CNNs usually need more training epochs to achieve the same accuracy. For example, the CIFAR-10 architecture in (Courbariaux et al. (2016)) is trained for 500 epochs, while the fullprecision version of the same network can achieve comparable accuracy in roughly 50 iterations 3. Here, we argue that soft binarization in ResBinNet can significantly reduce the number of training epochs for binary CNNs. ",
+        "bbox": [
+            174,
+            303,
+            825,
+            386
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2 compares ResBinNet with two prior arts, namely Binarynet and FINN. Both baselines use the same training methodology, but the network architectures in FINN are considerably smaller, which leads to lower accuracy rates for FINN. We evaluate ResBinNet using the small architectures of FINN. The training of ResBinNet consists of a soft binarization phase and a single fine-tuning epoch. Note that the fine-tuning phase uses the same algorithm as the two baselines. The higher accuracy of Binarynet compared to our approach is a direct result of employing a large architecture and training for many epochs. For each benchmark, the comparison between our approach and the same network architecture of FINN is followed: ",
+        "bbox": [
+            174,
+            393,
+            825,
+            503
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• CIFAR-10: Compared to FINN, ResBinNet achieves higher accuracy for more than 1 level of residual binarization. We argue that, even for 1-level binarization, the same accuracy is viable if we fine-tune the soft-binarized model (after 50 epochs) for more than 1 epochs (FINN and ResBinNet use the same algorithms in this phase). In addition, the convergence rate of ResBinNet is improved as the number of residual levels is increased. SVHN and MNIST: For these datasets, ResBinNet achieves a higher accuracy with even fewer epochs compared to CIFAR-10. The final accuracy and the convergence speed also exhibit improvement as the number of residual levels is increased from 1 to 3. ",
+        "bbox": [
+            215,
+            518,
+            825,
+            640
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now evaluate the area overhead and execution time of ResBinNet for the modified hardware architecture, which we discussed previously in Section 4. We compare the implementation of the CNN architecture used for the CIFAR-10 and SVHN tasks (See Table 1). Figure 7 compares the hardware resource utilization, and execution time per input. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            710
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The resource utilization of ResBinNet is evaluated in Figure 7a, which compares the utilization (in $\\%$ ) for different resources of the FPGA (i.e. BRAM, DSP, LUT, and Registers). For each resource, we compare the baseline with different number of residual binarization levels in ResBinNet. Asides from the DSP utilization, which is required for full-precision multiplications in batch normalization, the other three resources show a modest increase in utilization, meaning that the residual binarization method offers a scalable design for real-world systems. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            801
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 7b compares the latency (runtime) of ResBinNet with the baseline accelerator. In particular, we consider multi-level residual binarization with 1, 2, and 3 residual levels which are denoted by RBN1, RBN2, and RBN3, respectively. The numbers on top of the bars show the accuracy of the corresponding binarized CNN for CIFAR-10 task. As can be seen, ResBinNet enables users to achieve higher accuracy by tolerating a higher latency, which is almost linear with respect to the number of residual levels. ",
+        "bbox": [
+            174,
+            808,
+            825,
+            892
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/8c140af2efab2c931fe4d7311ae79d3d93d55c8f0f733932f444cb3a11534698.jpg",
+        "image_caption": [
+            "Figure 7: (a) Resource utilization overhead of ResBinNet with different residual levels versus baseline design( Umuroglu et al. (2017)) implemented on Xilinx ZC706 Evaluation Kit. (b) Latencyaccuracy trade-off offered by ResBinNet with different residual levels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            108,
+            743,
+            250
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            333,
+            343,
+            348
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Training CNNs with binary weights and/or activations has been the subject of very recent works (Courbariaux et al. (2015); Rastegari et al. (2016); Courbariaux et al. (2016); Umuroglu et al. (2017)). The authors of Binaryconnect (Courbariaux et al. (2015)) suggest a probabilistic methodology that leverages the full-precision weights to generate binary representatives during forward pass while in the back-propagation the full-precision weights are updated. (Courbariaux et al. (2016)) is the first work attempting to binarize both weight and activations of CNN. In this work, authors also suggest replacing the costly dot products by XNOR-popcount operations. XNOR-net (Rastegari et al. (2016)) proposes to use scale factors during training, which results in an improved accuracy. The aforementioned works propose optimization solutions that enable the use of binarized values in CNNs which, in turn, enable the design of simple and efficient hardware accelerators. The downside of these works is that, aside from changing the architecture of the CNN (Umuroglu et al. (2017)), they do not offer any other reconfigurability in their designs. ",
+        "bbox": [
+            174,
+            366,
+            825,
+            532
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On another track of research, the reconfigurability of CNN accelerators has been investigated. This line of research focuses on using adaptive low bit-width representations for compressing the parameters and/or simplifying the pertinent arithmetic operations (Zhou et al. (2016); Han et al. (2016); Wu et al. (2016); Cai et al. (2017)). The proposed solutions, however, do not enjoy the same simplified XNOR-popcount operations as in binarized CNNs. ",
+        "bbox": [
+            174,
+            540,
+            823,
+            609
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Among the aforementioned works, a unified solution which is both reconfigurable and binarized is missing. To the best of our knowledge, ResBinNet is the first to offer a solution which is reconfigurable and, at the same time, enjoys the benefits of binarized CNNs. Our goal in the design of ResBinNet was to remain consistent with the existing CNN optimization solutions. As shown in the paper, ResBinNet is compatible with the accelerators designed for binarized CNNs. ",
+        "bbox": [
+            174,
+            616,
+            825,
+            686
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            709,
+            318,
+            726
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces ResBinNet, a novel reconfigurable binarization scheme which aims to improve the convergence rate and the final accuracy of binary CNNs. The proposed training is twofold: (i) In the first phase, called soft binarization, we introduce two distinct methodologies designed for binarizing weights and feature within CNNs, namely residual binarization, and temperature adjustment. Residual binarization learns a multi-level representation for features of CNN to provide an arbitrary numerical precision during inference. Temperature adjustment gradually imposes binarization constraints on the weights. (ii) In the second phase, which we call hard binarization, the model is fine-tuned in few training epochs. Our experiments demonstrate that the joint use of residual binarization and temperature adjustment improves the convergence rate and the accuracy of the binarized CNN. We argue that ResBinNet methodology can be adopted by current CNN hardware accelerators as it requires minimal modification to existing binarized CNN solutions. Developers can integrate the approaches proposed in this paper into their deep learning systems to provide users with a trade-off between application latency and inference accuracy. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhaowei Cai, Xiaodong He, Jian Sun, and Nuno Vasconcelos. Deep learning with low precision by half-wave gaussian quantization. arXiv preprint arXiv:1702.00953, 2017. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Franc¸ois Chollet et al. Keras. https://github.com/fchollet/keras, 2015. ",
+        "bbox": [
+            173,
+            162,
+            740,
+            179
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. Binaryconnect: Training deep neural networks with binary weights during propagations. In Advances in Neural Information Processing Systems, pp. 3123–3131, 2015. ",
+        "bbox": [
+            173,
+            188,
+            825,
+            229
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training deep neural networks with weights and activations constrained $\\mathrm { t o } + 1$ or-1. arXiv preprint arXiv:1602.02830, 2016. ",
+        "bbox": [
+            173,
+            238,
+            823,
+            281
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Misha Denil, Babak Shakibi, Laurent Dinh, Nando de Freitas, et al. Predicting parameters in deep learning. In Advances in Neural Information Processing Systems, pp. 2148–2156, 2013. ",
+        "bbox": [
+            171,
+            290,
+            823,
+            320
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015. ",
+        "bbox": [
+            171,
+            327,
+            823,
+            358
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Xingyu Liu, Huizi Mao, Jing Pu, Ardavan Pedram, Mark A Horowitz, and William J Dally. Eie: efficient inference engine on compressed deep neural network. In Proceedings of the 43rd International Symposium on Computer Architecture, pp. 243–254. IEEE Press, 2016. ",
+        "bbox": [
+            176,
+            364,
+            825,
+            409
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan R Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012. ",
+        "bbox": [
+            171,
+            416,
+            823,
+            460
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Quantized neural networks: Training neural networks with low precision weights and activations. arXiv preprint arXiv:1609.07061, 2016. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            511
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yong-Deok Kim, Eunhyeok Park, Sungjoo Yoo, Taelim Choi, Lu Yang, and Dongjun Shin. Compression of deep convolutional neural networks for fast and low power mobile applications. arXiv preprint arXiv:1511.06530, 2015. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            563
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Baoyuan Liu, Min Wang, Hassan Foroosh, Marshall Tappen, and Marianna Pensky. Sparse convolutional neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 806–814, 2015. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            614
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In European Conference on Computer Vision, pp. 525–542. Springer, 2016. ",
+        "bbox": [
+            173,
+            622,
+            825,
+            666
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yaman Umuroglu, Nicholas J Fraser, Giulio Gambardella, Michaela Blott, Philip Leong, Magnus Jahre, and Kees Vissers. Finn: A framework for fast, scalable binarized neural network inference. In Proceedings of the 2017 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays, pp. 65–74. ACM, 2017. ",
+        "bbox": [
+            173,
+            674,
+            825,
+            732
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Advances in Neural Information Processing Systems, pp. 2074–2082, 2016. ",
+        "bbox": [
+            174,
+            739,
+            825,
+            782
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jiaxiang Wu, Cong Leng, Yuhang Wang, Qinghao Hu, and Jian Cheng. Quantized convolutional neural networks for mobile devices. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4820–4828, 2016. ",
+        "bbox": [
+            173,
+            791,
+            823,
+            835
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xilinx. Vivado. https://www.xilinx.com/products/design-tools/vivado. html, 2017. ",
+        "bbox": [
+            169,
+            844,
+            820,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xiangyu Zhang, Jianhua Zou, Xiang Ming, Kaiming He, and Jian Sun. Efficient and accurate approximations of nonlinear convolutional networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1984–1992, 2015. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shuchang Zhou, Yuxin Wu, Zekun Ni, Xinyu Zhou, He Wen, and Yuheng Zou. Dorefa-net: Training low bitwidth convolutional neural networks with low bitwidth gradients. arXiv preprint arXiv:1606.06160, 2016. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 9
+    }
+]

parse/train/eQe8DEWNN2W/eQe8DEWNN2W.md

@@ -0,0 +1,419 @@
+# CALIBRATION OF NEURAL NETWORKS USING SPLINES
+
+Kartik Gupta1,2, Amir Rahimi1, Thalaiyasingam Ajanthan1, Thomas Mensink3, Cristian Sminchisescu3, Richard Hartley1,3 1Australian National University, 2Data61, CSIRO, 3Google Research {kartik.gupta,amir.rahimi,thalaiyasingam.ajanthan}@anu.edu.au {mensink,sminchisescu,richardhartley}@google.com
+
+# ABSTRACT
+
+Calibrating neural networks is of utmost importance when employing them in safety-critical applications where the downstream decision making depends on the predicted probabilities. Measuring calibration error amounts to comparing two empirical distributions. In this work, we introduce a binning-free calibration measure inspired by the classical Kolmogorov-Smirnov (KS) statistical test in which the main idea is to compare the respective cumulative probability distributions. From this, by approximating the empirical cumulative distribution using a differentiable function via splines, we obtain a recalibration function, which maps the network outputs to actual (calibrated) class assignment probabilities. The spline-fitting is performed using a held-out calibration set and the obtained recalibration function is evaluated on an unseen test set. We tested our method against existing calibration approaches on various image classification datasets and our spline-based recalibration approach consistently outperforms existing methods on KS error as well as other commonly used calibration measures.
+
+# 1 INTRODUCTION
+
+Despite the success of modern neural networks they are shown to be poorly calibrated (Guo et al. (2017)), which has led to a growing interest in the calibration of neural networks over the past few years (Kull et al. (2019); Kumar et al. (2019; 2018); Müller et al. (2019)). Considering classification problems, a classifier is said to be calibrated if the probability values it associates with the class labels match the true probabilities of correct class assignments. For instance, if an image classifier outputs 0.2 probability for the “horse” label for 100 test images, then out of those 100 images approximately 20 images should be classified as horse. It is important to ensure calibration when using classifiers for safety-critical applications such as medical image analysis and autonomous driving where the downstream decision making depends on the predicted probabilities.
+
+One of the important aspects of machine learning research is the measure used to evaluate the performance of a model and in the context of calibration, this amounts to measuring the difference between two empirical probability distributions. To this end, the popular metric, Expected Calibration Error (ECE) (Naeini et al. (2015)), approximates the classwise probability distributions using histograms and takes an expected difference. This histogram approximation has a weakness that the resulting calibration error depends on the binning scheme (number of bins and bin divisions). Even though the drawbacks of ECE have been pointed out and some improvements have been proposed (Kumar et al. (2019); Nixon et al. (2019)), the histogram approximation has not been eliminated.1
+
+In this paper, we first introduce a simple, binning-free calibration measure inspired by the classical Kolmogorov-Smirnov (KS) statistical test (Kolmogorov (1933); Smirnov (1939)), which also provides an effective visualization of the degree of miscalibration similar to the reliability diagram (NiculescuMizil & Caruana (2005)). To this end, the main idea of the KS-test is to compare the respective classwise cumulative (empirical) distributions. Furthermore, by approximating the empirical cumulative distribution using a differentiable function via splines (McKinley & Levine (1998)), we obtain an analytical recalibration function2 which maps the given network outputs to the actual class assignment probabilities. Such a direct mapping was previously unavailable and the problem has been approached indirectly via learning, for example, by optimizing the (modified) cross-entropy loss (Guo et al. (2017); Mukhoti et al. (2020); Müller et al. (2019)). Similar to the existing methods (Guo et al. (2017); Kull et al. (2019)) the spline-fitting is performed using a held-out calibration set and the obtained recalibration function is evaluated on an unseen test set.
+
+We evaluated our method against existing calibration approaches on various image classification datasets and our spline-based recalibration approach consistently outperforms existing methods on KS error, ECE as well as other commonly used calibration measures. Our approach to calibration does not update the model parameters, which allows it to be applied on any trained network and it retains the original classification accuracy in all the tested cases.
+
+# 2 NOTATION AND PRELIMINARIES
+
+We abstract the network as a function $f _ { \theta } : { \mathcal { D } } \to [ 0 , 1 ] ^ { K }$ , where $\mathcal { D } \subset \mathbb { R } ^ { d }$ , and write $f _ { \boldsymbol { \theta } } ( \mathbf { x } ) = \mathbf { z }$ . Here, $\mathbf { x }$ may be an image, or other input datum, and $\mathbf { z }$ is a vector, sometimes known as the vector of logits. In this paper, the parameters $\theta$ will not be considered, and we write simply $f$ to represent the network function. We often refer to this function as a classifier, and in theory this could be of some other type than a neural network.
+
+In a classification problem, $K$ is the number of classes to be distinguished, and we call the value $z _ { k }$ (the ftma $k$ -th component of vecayer, then the values $\mathbf { z }$ ) the atisfy lass , an $k$ final layer of. Hence, the network is aare pseudo$z _ { k }$ $\textstyle \sum _ { k = 1 } ^ { K } z _ { k } = 1$ $z _ { k } \ge 0$ $z _ { k }$ class assignments. Typically, the value $y ^ { * } = \arg \operatorname* { m a x } _ { k } z _ { k }$ is taken as the (top-1) prediction of the network, and the corresponding score, $\operatorname* { m a x } _ { k } \ z _ { k }$ is called the confidence of the prediction. However, the term confidence does not have any mathematical meaning in this context and we deprecate its use.
+
+We assume we are given a set of training data $( { \bf x } _ { i } , y _ { i } ) _ { i = 1 } ^ { n }$ , where $\mathbf { x } _ { i } \in \mathcal { D }$ is an input data element, which for simplicity we call an image, and $y _ { i } \in \mathcal { K } = \{ 1 , . . . , K \}$ is the so-called ground-truth label. Our method also uses two other sets of data, called calibration data and test data.
+
+It would be desirable if the numbers $z _ { k }$ output by a network represented true probabilities. For this to make sense, we posit the existence of joint random variables $( X , Y )$ , where $X$ takes values in a domain $\mathcal { D } \subset \mathbb { R } ^ { d }$ , and $Y$ takes values in $\kappa$ . Further, let $Z = f ( X )$ , another random variable, and $Z _ { k } = f _ { k } ( X )$ be its $k$ -th component. Note that in this formulation $X$ and $Y$ are joint random variables, and the probability $P ( Y \mid X )$ is not assumed to be 1 for single class, and 0 for the others.
+
+A network is said to be calibrated if for every class $k$ ,
+
+$$
+P ( Y = k \mid Z = { \bf z } ) = z _ { k } ~ .
+$$
+
+This can be written briefly as $P ( k \mid f ( \mathbf { x } ) ) = f _ { k } ( \mathbf { x } ) = z _ { k }$ . Thus, if the network takes input $\mathbf { x }$ and outputs $\mathbf { z } = f ( \mathbf { x } )$ , then $z _ { k }$ represents the probability (given $f ( \mathbf { x } ) ) ,$ ) that image $\mathbf { x }$ belongs to class $k$ .
+
+The probability $P ( k \mid \mathbf { z } )$ is difficult to evaluate, even empirically, and most metrics (such as ECE) use or measure a different notion called classwise calibration (Kull et al. (2019); Zadrozny & Elkan (2002)), defined as,
+
+$$
+P ( Y = k \mid Z _ { k } = z _ { k } ) = z _ { k } ~ .
+$$
+
+This paper uses this definition (2) of calibration in the proposed KS metric.
+
+Calibration and accuracy of a network are different concepts. For instance, one may consider a classifier that simply outputs the class probabilities for the data, ignoring the input $\mathbf { x }$ . Thus, if $f _ { k } ( { \mathbf { x } } ) = z _ { k } = P ( \bar { Y } = k )$ , this classifier $f$ is calibrated but the accuracy is no better than the random predictor. Therefore, in calibration of a classifier, it is important that this is not done while sacrificing classification (for instance top-1) accuracy.
+
+The top- $\cdot r$ prediction. The classifier $f$ being calibrated means that $f _ { k } ( { \bf x } )$ is calibrated for each class $k$ , not only for the top class. This means that scores $z _ { k }$ for all classes $k$ give a meaningful estimate of the probability of the sample belonging to class $k$ . This is particularly important in medical diagnosis where one may wish to have a reliable estimate of the probability of certain unlikely diagnoses.
+
+Frequently, however, one is most interested in the probability of the top scoring class, the top-1 prediction, or in general the top- $\cdot r$ prediction. Suppose a classifier $f$ is given with values in $[ 0 , 1 ] ^ { K }$ and let $y$ be the ground truth label. Let us use $f ^ { ( - r ) }$ to denote the $r$ -th top score (so $f ^ { ( - 1 ) }$ would denote the top score; the notation follows python semantics in which $A [ - 1 ]$ represents the last element in array $A$ ). Similarly we define $\operatorname* { m a x } ^ { ( - r ) }$ for the $r$ -th largest value. Let $f ^ { ( - r ) } : { \mathcal { D } }  [ 0 , 1 ]$ be defined as
+
+$$
+f ^ { ( - r ) } ( { \bf x } ) = \operatorname* { m a x } _ { k } ^ { ( - r ) } f _ { k } ( { \bf x } ) , \quad \mathrm { a n d } \quad y ^ { ( - r ) } = \left\{ 1 \begin{array} { l l } { { \mathrm { } } } & { { \mathrm { i f } y = \arg \operatorname* { m a x } _ { k } ^ { ( - r ) } f _ { k } ( { \bf x } ) } } \\ { { 0 } } & { { \mathrm { o t h e r w i s e } . } } \end{array} \right.
+$$
+
+In words, $y ^ { ( - r ) }$ is 1 if the $r$ -th top predicted class is the correct (ground-truth) choice. The network is calibrated for the top- $\cdot r$ predictor if for all scores $\sigma$ ,
+
+$$
+P ( y ^ { ( - r ) } = 1 \mid f ^ { ( - r ) } ( { \bf x } ) = \sigma ) = \sigma .
+$$
+
+In words, the conditional probability that the top- $\cdot r$ -th choice of the network is the correct choice, is equal to the $r$ -th top score.
+
+Similarly, one may consider probabilities that a datum belongs to one of the top- $_ r$ scoring classes. The classifier is calibrated for being within-the-top- $\mathbfit { \nabla } x$ classes if
+
+$$
+\begin{array} { r } { P \big ( \sum _ { s = 1 } ^ { r } y ^ { ( - s ) } = 1 \big | \sum _ { s = 1 } ^ { r } f ^ { ( - s ) } ( \mathbf { x } ) = \sigma \big ) = \sigma . } \end{array}
+$$
+
+Here, the sum on the left is 1 if the ground-truth label is among the top $r$ choices, 0 otherwise, and the sum on the right is the sum of the top $r$ scores.
+
+# 3 KOLMOGOROV-SMIRNOV CALIBRATION ERROR
+
+We now consider a way to measure if a classifier is classwise calibrated, including top- $\mathbfit { \nabla } x$ and withintop- $r$ calibration. This test is closely related to the Kolmogorov-Smirnov test (Kolmogorov (1933); Smirnov (1939)) for the equality of two probability distributions. This may be applied when the probability distributions are represented by samples.
+
+We start with the definition of classwise calibration:
+
+$$
+{ \begin{array} { r l } & { P ( Y = k \mid f _ { k } ( X ) = z _ { k } ) = z _ { k } . } \\ & { P ( Y = k , \ f _ { k } ( X ) = z _ { k } ) = z _ { k } P ( f _ { k } ( X ) = z _ { k } ) , \quad { \mathrm { B a y e s } } ^ { , } { \mathrm { r u l e } } . } \end{array} }
+$$
+
+This may be written more simply but with a less precise notation as
+
+$$
+P ( z _ { k } , k ) = z _ { k } P ( z _ { k } ) .
+$$
+
+Motivation of the KS test. One is motivated to test the equality (or difference between) two distributions, defined on the interval $[ 0 , 1 ]$ . However, instead of having a functional form of these distributions, one has only samples from them. Given samples $\left( \mathbf { x } _ { i } , y _ { i } \right)$ , it is not straight-forward to estimate $P ( z _ { k } )$ or $P ( \boldsymbol { z } _ { k } \mid \dot { \boldsymbol { k } } )$ , since a given value $z _ { k }$ is likely to occur only once, or not at all, since the sample set is finite. One possibility is to use histograms of these distributions. However, this requires selection of the bin size and the division between bins, and the result depends on these parameters. For this reason, we believe this is an inadequate solution.
+
+The approach suggested by the Kolmogorov-Smirnov test is to compare the cumulative distributions. Thus, with $k$ given, one tests the equality
+
+$$
+\int _ { 0 } ^ { \sigma } P ( z _ { k } , k ) d z _ { k } = \int _ { 0 } ^ { \sigma } z _ { k } P ( z _ { k } ) d z _ { k } .
+$$
+
+Writing $\phi _ { 1 } ( \sigma )$ and $\phi _ { 2 } ( \sigma )$ to be the two sides of this equation, the KS-distance between these two distributions is defined as $\begin{array} { r } { \mathrm { K S } = \operatorname* { m a x } _ { \sigma } | \phi _ { 1 } ( \sigma ) - \phi _ { 2 } ( \sigma ) | } \end{array}$ . The fact that simply the maximum is used here may suggest a lack of robustness, but this is a maximum difference between two integrals, so it reflects an accumulated difference between the two distributions.
+
+To provide more insights into the KS-distance, let us a consider a case where $z _ { k }$ consistently over or under-estimates $P ( k \mid z _ { k } )$ (which is usually the case, at least for top-1 classification (Guo et al. (2017))), then $P ( k \mid z _ { k } ) - z _ { k }$ has constant sign for all values of $z _ { k }$ . It follows that $P ( z _ { k } , k ) - z _ { k } P ( z _ { k } )$ has constant sign and so the maximum value in the KS-distance is achieved when $\sigma = 1$ . In this case,
+
+$$
+\mathrm { K S } = \int _ { 0 } ^ { 1 } \left| P ( z _ { k } , k ) - z _ { k } P ( z _ { k } ) \right| d z _ { k } = \int _ { 0 } ^ { 1 } \left| P ( k \mid z _ { k } ) - z _ { k } \right| P ( z _ { k } ) d z _ { k } ,
+$$
+
+which is the expected difference between $z _ { k }$ and $P ( k \mid z _ { k } )$ . This can be equivalently referred to as the expected calibration error for the class $k$ .
+
+Sampled distributions. Given samples $( \mathbf { x } _ { i } , y _ { i } ) _ { i = 1 } ^ { N }$ , and a fixed $k$ , one can estimate these cumulative distributions by
+
+$$
+\int _ { 0 } ^ { \sigma } P ( z _ { k } , k ) d z _ { k } \approx \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \mathbf { 1 } ( f _ { k } ( \mathbf { x } _ { i } ) \leq \sigma ) \times \mathbf { 1 } ( y _ { i } = k ) ,
+$$
+
+where $\mathbf { 1 } : B  \{ 0 , 1 \}$ is the function that returns 1 if the Boolean expression is true and otherwise 0. Thus, the sum is simply a count of the number of samples for which $y _ { i } = k$ and $f _ { k } ( { \bf x } _ { i } ) \leq \sigma$ , and so the integral represents the proportion of the data satisfying this condition. Similarly,
+
+$$
+\int _ { 0 } ^ { \sigma } z _ { k } P ( z _ { k } ) d z _ { k } \approx \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \mathbf { 1 } ( f _ { k } ( \mathbf { x } _ { i } ) \leq \sigma ) f _ { k } ( \mathbf { x } _ { i } ) .
+$$
+
+These sums can be computed quickly by sorting the data according to the values $f _ { k } ( { \bf x } _ { i } )$ , then defining two sequences as follows.
+
+$$
+\begin{array} { c } { { \tilde { h } _ { 0 } = h _ { 0 } = 0 ~ , } } \\ { { h _ { i } = h _ { i - 1 } + { \bf 1 } ( y _ { i } = k ) / N ~ , } } \\ { { \tilde { h } _ { i } = \tilde { h } _ { i - 1 } + f _ { k } ( { \bf x } _ { i } ) / N ~ . } } \end{array}
+$$
+
+The two sequences should be the same, and the metric
+
+$$
+\mathrm { K S } ( f _ { k } ) = \operatorname* { m a x } _ { i } \left| h _ { i } - \tilde { h } _ { i } \right| ,
+$$
+
+gives a numerical estimate of the similarity, and hence a measure of the degree of calibration of $f _ { k }$ .   
+This is essentially a version of the Kolmogorov-Smirnov test for equality of two distributions.
+
+Remark. All this discussion holds also when $k < 0$ , for top- $\cdot r$ and within-top- $r$ predictions as discussed in section 2. In (11), for instance, $f _ { - 1 } ( \mathbf { x } _ { i } )$ means the top score, $f _ { - 1 } ( \mathbf { x } _ { i } ) = \operatorname* { m a x } _ { k } ( f _ { k } ( \mathbf { x } _ { i } ) )$ , or more generally, $f _ { - r } ( \mathbf { x } _ { i } )$ means the $r$ -th top score. Similarly, the expression $y _ { i } = - r$ means that $y _ { i }$ is the class that has the $r$ -th top score. Note when calibrating the top-1 score, our method is applied after identifying the top-1 score, hence, it does not alter the classification accuracy.
+
+# 4 RECALIBRATION USING SPLINES
+
+The function $h _ { i }$ defined in (11) computes an empirical approximation
+
+$$
+h _ { i } \approx P ( Y = k , f _ { k } ( X ) \leq f _ { k } ( \mathbf { x } _ { i } ) ) .
+$$
+
+For convenience, the value of $f _ { k }$ will be referred to as the score. We now define a continuous function $h ( t )$ for $t \in [ 0 , 1 ]$ by
+
+$$
+h ( t ) = P ( Y = k , f _ { k } ( X ) \leq s ( t ) ) ,
+$$
+
+where $s ( t )$ is the $t$ -th fractile score, namely the value that a proportion $t$ of the scores $f _ { k } ( X )$ lie below.   
+For instance $s ( 0 . 5 )$ is the median score. So, $h _ { i }$ is an empirical approximation to $h ( t )$ where $t = i / N$ .   
+We now provide the basic observation that allows us to compute probabilities given the scores.
+
+![](images/825f238a597ada79841f43e927eda7b541a974fb37029a366ab1f4fec80663c1.jpg)  
+Figure 1: Calibration graphs for an uncalibrated DenseNet-40 (Huang et al. (2017)) trained on CIFAR-10 for top-1 class with a $K S$ error of $5 . 5 \%$ , and top-1 accuracy of $9 2 . 4 \%$ on the test set. Here (a) shows the plot of cumulative score and probability versus the fractile of the test set, (b) shows the same information with the horizontal axis warped so that the cumulative-score graph is a straight line. This is created as scatter plots of cumulative (score, score): blue and (score, probability): orange. If the network is perfectly calibrated, the probability line will be a straight line coincident with the (score, score) line. This shows that the network is substantially overestimating (score) the probability of the computation. (c) and (d) show plots of (non-cumulative) score and probability plotted against fractile, or score. How these plots are produced is described in section 4.
+
+Proposition 4.1. If $h ( t ) = P ( Y = k$ , $f _ { k } ( X ) \leq s ( t ) )$ as in $( I 4 )$ where $s ( t )$ is the $t$ -th fractile score, then $h ^ { \prime } ( t ) = P ( Y = k \mid f _ { k } ( X ) = s ( t ) )$ , where $h ^ { \prime } ( t ) = d h / d t$ .
+
+Proof. The proof relies on the equality $P ( f _ { k } ( X ) \leq s ( t ) ) = t$ . In words, since $s ( t )$ is the value that a fraction $t$ of the scores are less than or equal, the probability that a score is less than or equal to $s ( t )$ , is (obviously) equal to $t$ . See the supplementary material for a detailed proof.
+
+Notice $h ^ { \prime } ( t )$ allows direct conversion from score to probability. Therefore, our idea is to approximate $h _ { i }$ using a differentiable function and take the derivative which would be our recalibration function.
+
+# 4.1 SPLINE FITTING
+
+The function $h _ { i }$ (shown in fig 1a) is obtained through sampling only. Nevertheless, the sampled graph is smooth and increasing. There are various ways to fit a smooth curve to it, so as to take derivatives. We choose to fit the sampled points $h _ { i }$ to a cubic spline and take its derivative.
+
+Given sample points $( u _ { i } , v _ { i } ) _ { i = 1 } ^ { N }$ in $\mathbb { R } \times \mathbb { R }$ , easily available references show how to fit a smooth spline curve that passes directly through the points $( u _ { i } , v _ { i } )$ . A very clear description is given in McKinley & Levine (1998), for the case where the points $u _ { i }$ are equally spaced. We wish, however, to fit a spline curve with a small number of knot points to do a least-squares fit to the points. For convenience, this is briefly described here.
+
+A cubic spline $v ( u )$ is defined by its values at certain knot points $( \hat { u } _ { k } , \hat { v } _ { k } ) _ { k = 1 } ^ { K }$ . In fact, the value of the curve at any point $u$ can be written as a linear function $\begin{array} { r } { \boldsymbol { v } ( \boldsymbol { u } ) = \sum _ { k = 1 } ^ { K } a _ { k } ( \boldsymbol { u } ) \boldsymbol { \hat { v } _ { k } } = \mathbf { a } ^ { \top } ( \boldsymbol { u } ) \boldsymbol { \hat { \mathbf { v } } } } \end{array}$ , where the coefficients $a _ { k }$ depend on $u$ .3 Therefore, given a set of further points $( u _ { i } , v _ { i } ) _ { i = 1 } ^ { N }$ , which may be different from the knot points, and typically more in number, least-squares spline fitting of the points $( u _ { i } , v _ { i } )$ can be written as a least-squares problem minvˆ $\| \mathbb { A } ( \mathbf { u } ) \hat { \mathbf { v } } - \mathbf { v } \| ^ { 2 }$ , which is solved by standard linear least-squares techniques. Here, the matrix A has dimension $N \times K$ with $N > K$ . Once $\hat { \mathbf { v } }$ is found, the value of the spline at any further points $u$ is equal to $\boldsymbol { v } ( \boldsymbol { u } ) = \mathbf { a } ( \boldsymbol { u } ) ^ { \top } \hat { \mathbf { v } }$ , a linear combination of the knot-point values $\hat { v } _ { k }$ .
+
+Since the function is piecewise cubic, with continuous second derivatives, the first derivative of the spline is computed analytically. Furthermore, the derivative $v ^ { \prime } ( u )$ can also be written as a linear combination $\hat { v ^ { \prime } } ( u ) = \mathbf { a } ^ { \prime } ( u ) ^ { \top } \hat { \mathbf { v } }$ , where the coefficients $\mathbf { a } ^ { \prime } ( u )$ can be written explicitly.
+
+Our goal is to fit a spline to a set of data points $\left( u _ { i } , v _ { i } \right) = \left( i / N , h _ { i } \right)$ defined in (11), in other words, the values $h _ { i }$ plotted against fractile score. Then according to Proposition 4.1, the derivative of the spline is equal to $P ( k \mid f _ { k } ( X ) = s ( t ) )$ . This allows a direct computation of the conditional probability that the sample belongs to class $k$ .
+
+![](images/e6260c759c3efe50f51f40904fe3a69aa7923159f6860c0268fa757676382110.jpg)  
+Figure 2: The result of the spline calibration method, on the example given in fig $^ { l }$ for top-1 calibration. A recalibration function $\gamma : \mathbb { R } \to \mathbb { R }$ is used to adjust the scores, replacing $f _ { k } ( { \bf x } )$ with $\gamma ( f _ { k } ( { \bf x } ) )$ (see section 4.2). $A s$ is seen, the network is now almost perfectly calibrated when tested on the “calibration” set (top row) used to calibrate it. In bottom row, the recalibration function is tested on a further set “test”. It is seen that the result is not perfect, but much better than the one in fig 1d. It is also notable that the improvement in calibration is achieved without any loss of accuracy.
+
+Since the derivative of $h _ { i }$ is a probability, one might constrain the derivative to be in the range $[ 0 , 1 ]$ while fitting splines. This can be easily incorporated because the derivative of the spline is a linear expression in $\hat { v } _ { i }$ . The spline fitting problem thereby becomes a linearly-constrained quadratic program (QP). However, although we tested this, in all the reported experiments, a simple least-squares solver is used without the constraints.
+
+# 4.2 RECALIBRATION
+
+We suppose that the classifier $f = f _ { \theta }$ is fixed, through training on the training set. Typically, if the classifier is tested on the training set, it is very close to being calibrated. However, if a classifier $f$ is then tested on a different set of data, it may be substantially mis-calibrated. See fig 1.
+
+Our method of calibration is to find a further mapping $\gamma : [ 0 , 1 ]  [ 0 , 1 ]$ , such that $\gamma \circ f _ { k }$ is calibrated. This is easily obtained from the direct mapping from score $f _ { k } ( { \bf x } )$ to $P ( k \mid f _ { k } ( \mathbf { x } ) )$ (refer to fig 1d). In equations, $\dot { \gamma } ( \sigma ) = h ^ { \prime } ( s ^ { - 1 } ( \sigma ) )$ . The function $h ^ { \prime }$ is known analytically, from fitting a spline to $h ( t )$ and taking its derivative. The function $s ^ { - 1 }$ is a mapping from the given score $\sigma$ to its fractile $s ^ { - 1 } ( \sigma )$ Note that, a held out calibration set is used to fit the splines and the obtained recalibration function $\gamma$ is evaluated on an unseen test set.
+
+To this end, given a sample $\mathbf { x }$ from the test set with $f _ { k } ( { \bf x } ) = \sigma$ , one can compute $h ^ { \prime } ( s ^ { - 1 } ( \sigma ) )$ directly in one step by interpolating its value between the values of $h ^ { \prime } ( f _ { k } ( { \bf x } _ { i } ) )$ and $h ^ { \prime } ( f _ { k } ( \mathbf { \bar { x } } _ { i + 1 } ) )$ where $\mathbf { x } _ { i }$ and $\mathbf { x } _ { i + 1 }$ are two samples from the calibration set, with closest scores on either side of $\sigma$ . Assuming the samples in the calibration set are ordered, the samples $\mathbf { x } _ { i }$ and $\mathbf x _ { i + 1 }$ can be quickly located using binary search. Given a reasonable number of samples in the calibration set, (usually in the order of thousands), this can be very accurate. In our experiments, improvement in calibration is observed in the test set with no difference to the accuracy of the network (refer to fig 2d). In practice, spline fitting is much faster than one forward pass through the network and it is highly scalable compared to learning based calibration methods.
+
+# 5 RELATED WORK
+
+Modern calibration methods. In recent years, neural networks are shown to overfit to the Negative Log-Likelihood (NLL) loss and in turn produce overconfident predictions which is cited as the main reason for miscalibration (Guo et al. (2017)). To this end, modern calibration methods can be broadly categorized into 1) methods that adapt the training procedure of the classifier, and 2) methods that learn a recalibration function post training. Among the former, the main idea is to increase the entropy of the classifier to avoid overconfident predictions, which is accomplished via modifying the training loss (Kumar et al. (2018); Mukhoti et al. (2020); Seo et al. (2019)), label smoothing (Müller et al. (2019); Pereyra et al. (2017)), and data augmentation techniques (Thulasidasan et al. (2019); Yun et al. (2019); Zhang et al. (2018)).
+
+On the other hand, we are interested in calibrating an already trained classifier that eliminates the need for training from scratch. In this regard, a popular approach is Platt scaling (Platt et al. (1999)) which transforms the outputs of a binary classifier into probabilities by fitting a scaled logistic function on a held out calibration set. Similar approaches on binary classifiers include Isotonic Regression (Zadrozny & Elkan (2001)), histogram and Bayesian binning (Naeini et al. (2015); Zadrozny & Elkan (2001)), and Beta calibration (Kull et al. (2017)), which are later extended to the multiclass setting (Guo et al. (2017); Kull et al. (2019); Zadrozny & Elkan (2002)). Among these, the most popular method is temperature scaling (Guo et al. (2017)), which learns a single scalar on a held out set to calibrate the network predictions. Despite being simple and one of the early works, temperature scaling is the method to beat in calibrating modern networks. Our approach falls into this category, however, as opposed to minimizing a loss function, we obtain a recalibration function via spline-fitting, which directly maps the classifier outputs to the calibrated probabilities.
+
+Calibration measures. Expected Calibration Error (ECE) (Naeini et al. (2015)) is the most popular measure in the literature, however, it has a weakness that the resulting calibration error depends on the histogram binning scheme such as the bin endpoints and the number of bins. Even though, some improvements have been proposed (Nixon et al. (2019); Vaicenavicius et al. (2019)), the binning scheme has not been eliminated and it is recently shown that any binning scheme leads to underestimated calibration errors (Kumar et al. (2019); Widmann et al. (2019)). Note that, there are binning-free metrics exist such as Brier score (Brier (1950)), NLL, and kernel based metrics for the multiclass setting (Kumar et al. (2018); Widmann et al. (2019)). Nevertheless, the Brier score and NLL measure a combination of calibration error and classification error (not just the calibration which is the focus). Whereas kernel based metrics, besides being computationally expensive, measure the calibration of the predicted probability vector rather than the classwise calibration error (Kull et al. (2019)) (or top- $\cdot r$ prediction) which is typically the quantity of interest. To this end, we introduce a binning-free calibration measure based on the classical KS-test, which has the same benefits as ECE and provides effective visualizations similar to reliability diagrams. Furthermore, KS error can be shown to be a special case of kernel based measures (Gretton et al. (2012)).
+
+# 6 EXPERIMENTS
+
+Experimental setup. We evaluate our proposed calibration method on four different imageclassification datasets namely CIFAR-10/100 (Krizhevsky et al. (2009)), SVHN (Netzer et al. (2011)) and ImageNet (Deng et al. (2009)) using LeNet (LeCun et al. (1998)), ResNet (He et al. (2016)), ResNet with stochastic depth (Huang et al. (2017)), Wide ResNet (Zagoruyko & Komodakis (2016)) and DenseNet (Huang et al. (2017)) network architectures against state-of-the-art methods that calibrate post training. We use the pretrained network logits4 for spline fitting where we choose validation set as the calibration set, similar to the standard practice. Our final results for calibration are then reported on the test set of all datasets. Since ImageNet does not comprise the validation set, test set is divided into two halves: calibration set and test set. We use the natural cubic spline fitting method (that is, cubic splines with linear run-out) with 6 knots for all our experiments. Further experimental details are provided in the supplementary. For baseline methods namely: Temperature scaling, Vector scaling, Matrix scaling with ODIR (Off-diagonal and Intercept Regularisation), and Dirichlet calibration, we use the implementation of Kull et al. (Kull et al. (2019)).
+
+Table 1: KS Error $( i n \% )$ for top-1 prediction (with lowest in bold and second lowest underlined) on various image classification datasets and models with different calibration methods. Note, our method consistently reduces calibration error to $< 1 \%$ in almost all experiments, outperforming state-of-the-art methods.   
+
+<table><tr><td>Dataset</td><td>Model</td><td>Uncalibrated</td><td>Temp. Scaling</td><td>Vector Scaling</td><td>MS-ODIR</td><td>Dir-ODIR</td><td>Ours (Spline)</td></tr><tr><td rowspan="5">CIFAR-10</td><td>Resnet-110</td><td>4.750</td><td>0.916</td><td>0.996</td><td>0.977</td><td>1.060</td><td>0.643</td></tr><tr><td>Resnet-110-SD</td><td>4.102</td><td>0.362</td><td>0.430</td><td>0.358</td><td>0.389</td><td>0.269</td></tr><tr><td>DenseNet-40</td><td>5.493</td><td>0.900</td><td>0.890</td><td>0.897</td><td>1.057</td><td>0.773</td></tr><tr><td>Wide Resnet-32</td><td>4.475</td><td>0.296</td><td>0.267</td><td>0.305</td><td>0.291</td><td>0.367</td></tr><tr><td>Lenet-5</td><td>5.038</td><td>0.799</td><td>0.839</td><td>0.646</td><td>0.854</td><td>0.348</td></tr><tr><td rowspan="5">CIFAR-100</td><td>Resnet-110</td><td>18.481</td><td>1.489</td><td>1.827</td><td>2.845</td><td>2.575</td><td>0.575</td></tr><tr><td>Resnet-110-SD</td><td>15.832</td><td>0.748</td><td>1.303</td><td>3.572</td><td>1.645</td><td>1.028</td></tr><tr><td>DenseNet-40</td><td>21.156</td><td>0.304</td><td>0.483</td><td>2.350</td><td>0.618</td><td>0.454</td></tr><tr><td>Wide Resnet-32</td><td>18.784</td><td>1.130</td><td>1.642</td><td>2.524</td><td>1.788</td><td>0.930</td></tr><tr><td>Lenet-5</td><td>12.117</td><td>1.215</td><td>0.768</td><td>1.047</td><td>2.125</td><td>0.391</td></tr><tr><td rowspan="2">ImageNet</td><td>Densenet-161</td><td>5.721</td><td>0.744</td><td>2.014</td><td>4.723</td><td>3.103</td><td>0.406</td></tr><tr><td>Resnet-152</td><td>6.544</td><td>0.791</td><td>1.985</td><td>5.805</td><td>3.528</td><td>0.441</td></tr><tr><td>SVHN</td><td>Resnet-152-SD</td><td>0.852</td><td>0.552</td><td>0.570</td><td>0.573</td><td>0.607</td><td>0.556</td></tr></table>
+
+Table 2: KS Error $( i n \% )$ for top-2 prediction (with lowest in bold and second lowest underlined) on various image classification datasets and models with different calibration methods. Again, our method consistently reduces calibration error to $< 1 \%$ (less then $0 . 7 \%$ , except for one case), in all experiments, the only one of the methods to achieve this.   
+
+<table><tr><td>Dataset</td><td>Model</td><td>Uncalibrated</td><td>Temp. Scaling</td><td>Vector Scaling</td><td>MS-ODIR</td><td>Dir-ODIR</td><td>Ours (Spline)</td></tr><tr><td rowspan="5">CIFAR-10</td><td>Resnet-110</td><td>3.011</td><td>0.947</td><td>0.948</td><td>0.598</td><td>0.953</td><td>0.347</td></tr><tr><td>Resnet-110-SD</td><td>2.716</td><td>0.478</td><td>0.486</td><td>0.401</td><td>0.500</td><td>0.310</td></tr><tr><td>DenseNet-40</td><td>3.342</td><td>0.535</td><td>0.543</td><td>0.598</td><td>0.696</td><td>0.695</td></tr><tr><td>Wide Resnet-32</td><td>2.669</td><td>0.426</td><td>0.369</td><td>0.412</td><td>0.382</td><td>0.364</td></tr><tr><td>Lenet-5</td><td>1.708</td><td>0.367</td><td>0.279</td><td>0.409</td><td>0.426</td><td>0.837</td></tr><tr><td rowspan="5">CIFAR-100</td><td>Resnet-110</td><td>4.731</td><td>1.401</td><td>1.436</td><td>0.961</td><td>1.269</td><td>0.371</td></tr><tr><td>Resnet-110-SD</td><td>3.923</td><td>0.315</td><td>0.481</td><td>0.772</td><td>0.506</td><td>0.595</td></tr><tr><td>DenseNet-40</td><td>5.803</td><td>0.305</td><td>0.653</td><td>0.219</td><td>0.135</td><td>0.903</td></tr><tr><td>Wide Resnet-32</td><td>5.349</td><td>0.790</td><td>1.095</td><td>0.646</td><td>0.845</td><td>0.372</td></tr><tr><td>Lenet-5</td><td>2.615</td><td>0.571</td><td>0.439</td><td>0.324</td><td>0.799</td><td>0.587</td></tr><tr><td rowspan="2">ImageNet</td><td>Densenet-161</td><td>1.689</td><td>1.044</td><td>1.166</td><td>1.288</td><td>1.321</td><td>0.178</td></tr><tr><td>Resnet-152</td><td>1.793</td><td>1.151</td><td>1.264</td><td>1.660</td><td>1.430</td><td>0.580</td></tr><tr><td>SVHN</td><td>Resnet-152-SD</td><td>0.373</td><td>0.226</td><td>0.216</td><td>0.973</td><td>0.218</td><td>0.492</td></tr></table>
+
+Results. We provide comparisons of our method using proposed KS error for the top most prediction against state-of-the-art calibration methods namely temperature scaling (Guo et al. (2017)), vector scaling, MS-ODIR, and Dirichlet Calibration (Dir-ODIR) (Kull et al. (2019)) in Table 1. Our method reduces calibration error to $1 \%$ in almost all experiments performed on different datasets without any loss in accuracy. It clearly reflects the efficacy of our method irrespective of the scale of the dataset as well as the depth of the network architecture. It consistently performs better than the recently introduced Dirichlet calibration and Matrix scaling with ODIR (Kull et al. (2019)) in all the experiments. Note this is consistent with the top-1 calibration results reported in Table 15 of (Kull et al. (2019)). The closest competitor to our method is temperature scaling, against which our method performs better in 9 out of 13 experiments. Note, in the cases where temperature scaling outperforms our method, the gap in KS error between the two methods is marginal $( < \mathbf { 0 . 3 \% } )$ and our method is the second best. We provide comparisons using other calibration metrics in the supplementary.
+
+From the practical point of view, it is also important for a network to be calibrated for top second/third predictions and so on. We thus show comparisons for top-2 prediction KS error in Table 2. An observation similar to the one noted in Table 1 can be made for the top-2 predictions as well. Our method achieves $< 1 \%$ calibration error in all the experiments. It consistently performs well especially for experiments performed on large scale ImageNet dataset where it sets new state-of-the-art for calibration. We would like to emphasize here, though for some cases Kull et al. (Kull et al. (2019)) and Vector Scaling perform better than our method in terms of top-2 KS calibration error, overall (considering both top-1 and top-2 predictions) our method performs better.
+
+# 7 CONCLUSION
+
+In this work, we have introduced a binning-free calibration metric based on the Kolmogorov-Smirnov test to measure classwise or (within)-top- $\cdot r$ calibration errors. Our KS error eliminates the shortcomings of the popular ECE measure and its variants while accurately measuring the expected calibration error and provides effective visualizations similar to reliability diagrams. Furthermore, we introduced a simple and effective calibration method based on spline-fitting which does not involve any learning and yet consistently yields the lowest calibration error in the majority of our experiments. We believe, the KS metric would be of wide-spread use to measure classwise calibration and our spline method would inspire learning-free approaches to neural network calibration. We intend to focus on calibration beyond classification problems as future work.
+
+# 8 ACKNOWLEDGEMENTS
+
+The work is supported by the Australian Research Council Centre of Excellence for Robotic Vision (project number CE140100016). We would also like to thank Google Research and Data61, CSIRO for their support.
+
+# REFERENCES
+
+Glenn W Brier. Verification of forecasts expressed in terms of probability. Monthly weather review, 78(1):1–3, 1950.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009.
+
+Arthur Gretton, Karsten M Borgwardt, Malte J Rasch, Bernhard Schölkopf, and Alexander Smola. A kernel two-sample test. Journal of Machine Learning Research, 2012.
+
+Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q Weinberger. On calibration of modern neural networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1321–1330. JMLR. org, 2017.
+
+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.
+
+Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4700–4708, 2017.
+
+A Kolmogorov. Sulla determinazione empírica di uma legge di distribuzione. 1933.
+
+Alex Krizhevsky et al. Learning multiple layers of features from tiny images. 2009.
+
+Meelis Kull, Telmo Silva Filho, and Peter Flach. Beta calibration: a well-founded and easily implemented improvement on logistic calibration for binary classifiers. In Artificial Intelligence and Statistics, pp. 623–631, 2017.
+
+Meelis Kull, Miquel Perello Nieto, Markus Kängsepp, Telmo Silva Filho, Hao Song, and Peter Flach. Beyond temperature scaling: Obtaining well-calibrated multi-class probabilities with dirichlet calibration. In Advances in Neural Information Processing Systems, pp. 12295–12305, 2019.
+
+Ananya Kumar, Percy S Liang, and Tengyu Ma. Verified uncertainty calibration. In Advances in Neural Information Processing Systems, pp. 3787–3798, 2019.
+
+Aviral Kumar, Sunita Sarawagi, and Ujjwal Jain. Trainable calibration measures for neural networks from kernel mean embeddings. In International Conference on Machine Learning, pp. 2805–2814, 2018.
+
+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.
+
+Sky McKinley and Megan Levine. Cubic spline interpolation. College of the Redwoods, 1998.
+
+Jishnu Mukhoti, Viveka Kulharia, Amartya Sanyal, Stuart Golodetz, Philip HS Torr, and Puneet K Dokania. Calibrating deep neural networks using focal loss. arXiv preprint arXiv:2002.09437, 2020.
+
+Rafael Müller, Simon Kornblith, and Geoffrey E Hinton. When does label smoothing help? In Advances in Neural Information Processing Systems, pp. 4696–4705, 2019.
+
+Mahdi Pakdaman Naeini, Gregory Cooper, and Milos Hauskrecht. Obtaining well calibrated probabilities using bayesian binning. In Twenty-Ninth AAAI Conference on Artificial Intelligence, 2015.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. 2011.
+
+Alexandru Niculescu-Mizil and Rich Caruana. Predicting good probabilities with supervised learning. In Proceedings of the 22nd international conference on Machine learning, 2005.
+
+Jeremy Nixon, Michael W Dusenberry, Linchuan Zhang, Ghassen Jerfel, and Dustin Tran. Measuring calibration in deep learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pp. 38–41, 2019.
+
+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.
+
+John Platt et al. Probabilistic outputs for support vector machines and comparisons to regularized likelihood methods. Advances in large margin classifiers, 10(3):61–74, 1999.
+
+Seonguk Seo, Paul Hongsuck Seo, and Bohyung Han. Learning for single-shot confidence calibration in deep neural networks through stochastic inferences. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9030–9038, 2019.
+
+Nikolai Smirnov. On the estimation of the discrepancy between empirical curves of distribution for two independent samples. 1939.
+
+Sunil Thulasidasan, Gopinath Chennupati, Jeff A Bilmes, Tanmoy Bhattacharya, and Sarah Michalak. On mixup training: Improved calibration and predictive uncertainty for deep neural networks. In Advances in Neural Information Processing Systems, pp. 13888–13899, 2019.
+
+Juozas Vaicenavicius, David Widmann, Carl Andersson, Fredrik Lindsten, Jacob Roll, and Thomas B Schön. Evaluating model calibration in classification. AISTATS, 2019.
+
+David Widmann, Fredrik Lindsten, and Dave Zachariah. Calibration tests in multi-class classification: A unifying framework. In Advances in Neural Information Processing Systems, pp. 12236–12246, 2019.
+
+Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In Proceedings of the IEEE International Conference on Computer Vision, pp. 6023–6032, 2019.
+
+Bianca Zadrozny and Charles Elkan. Obtaining calibrated probability estimates from decision trees and naive bayesian classifiers. In Icml, volume 1, pp. 609–616. Citeseer, 2001.
+
+Bianca Zadrozny and Charles Elkan. Transforming classifier scores into accurate multiclass probability estimates. In Proceedings of the eighth ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 694–699, 2002.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.
+
+Hongyi Zhang, Moustapha Cissé, Yann N. Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In 6th International Conference on Learning Representations, ICLR 2018, 2018.
+
+Jize Zhang, Bhavya Kailkhura, and T Han. Mix-n-match: Ensemble and compositional methods for uncertainty calibration in deep learning. ICML, 2020.
+
+# Appendices
+
+Here, we first provide the proof of our main result, discuss more about top- $\cdot r$ calibration and splinefitting, and then turn to additional experiments.
+
+# A PROOF OF PROPOSITION 4.1
+
+We first restate our proposition below.
+
+Proposition A.2. If $h ( t ) = P ( Y = k , f _ { k } ( X ) \leq s ( t ) )$ as in (14) of the main paper where $s ( t )$ is the $t$ -th fractile score. Then $h ^ { \prime } ( t ) = P ( Y = k \mid f _ { k } ( X ) = s ( t ) )$ , where $h ^ { \prime } ( t ) = d h / d t$ .
+
+Proof. The proof is using the fundamental relationship between the Probability Distribution Function (PDF) and the Cumulative Distribution Function (CDF) and it is provided here for completeness. Taking derivatives, we see (writing $P ( k )$ instead of $P ( Y = k ) )$ ):
+
+$$
+{ \begin{array} { r l } & { h ^ { \prime } ( t ) = P ( k , f _ { k } ( X ) = s ( t ) ) \cdot s ^ { \prime } ( t ) } \\ & { \qquad = P ( k \mid f _ { k } ( X ) = s ( t ) ) \cdot P ( f _ { k } ( X ) = s ( t ) ) \cdot s ^ { \prime } ( t ) } \\ & { \qquad = P ( k \mid f _ { k } ( X ) = s ( t ) ) \cdot { \frac { d } { d t } } { \big ( } P ( f _ { k } ( X ) \leq s ( t ) ) { \big ) } } \\ & { \qquad = P ( k \mid f _ { k } ( X ) = s ( t ) ) \cdot { \frac { d } { d t } } ( t ) } \\ & { \qquad = P ( k \mid f _ { k } ( X ) = s ( t ) ) . } \end{array} }
+$$
+
+The proof relies on the equality $P ( f _ { k } ( X ) \leq s ( t ) ) = t .$ . In words: $s ( t )$ is the value that a fraction $t$ of the scores are less than or equal. This equality then says: the probability that a score is less than or equal to the value that a fraction $t$ of the scores lie below, is (obviously) equal to $t$ .
+
+# B MORE ON TOP- $r$ AND WITHIN-TOP- $r$ CALIBRATION
+
+In the main paper, definitions of top- $_ r$ and within-top- $\cdot r$ calibration are given in equations (4) and (5). Here, a few more details are given of how to calibrate the classifier $f$ for top- $\mathbfit { \nabla } \mathcal { r }$ and within-top- $r$ calibration.
+
+The method of calibration using splines described in this paper consists of fitting a spline to the cumulative accuracy, defined as $h _ { i }$ in equation (11) in the main paper. For top- $r$ classification, the method is much the same as for the classification for class $k$ . Equation (11) is replaced by sorting the data according to the $r$ -th top score, then defining
+
+$$
+\begin{array} { r } { \tilde { h } _ { 0 } = h _ { 0 } = 0 , \qquad } \\ { h _ { i } = h _ { i - 1 } + { \bf 1 } ( y ^ { ( - r ) } = 1 ) / N , \qquad } \\ { \tilde { h } _ { i } = \tilde { h } _ { i - 1 } + f ^ { ( - r ) } ( { \bf x } _ { i } ) / N , \qquad } \end{array}
+$$
+
+where $y ^ { ( - r ) }$ and $f ^ { ( - r ) } ( \mathbf { x } _ { i } )$ are defined in the main paper, equation (3). These sequences may then be used both as a metric for the correct top- $r$ calibration and for calibration using spline-fitting as described.
+
+For within-top $\cdot r$ calibration, one sorts the data according to the sum of the top $r$ scores, namely $\textstyle \sum _ { s = 1 } ^ { r } f ^ { ( - s ) } { \bigl ( } { \bar { \mathbf { x } } } _ { i } { \bigr ) }$ , then computes
+
+$$
+\begin{array} { c } { { \displaystyle \tilde { h } _ { 0 } = h _ { 0 } = 0 ~ , } } \\ { { \displaystyle h _ { i } = h _ { i - 1 } + { \bf 1 } \biggl ( \sum _ { s = 1 } ^ { r } y ^ { ( - s ) } = 1 \biggr ) \bigg / N ~ , } } \\ { { \displaystyle \tilde { h } _ { i } = \tilde { h } _ { i - 1 } + \sum _ { s = 1 } ^ { r } f ^ { ( - s ) } ( { \bf x } _ { i } ) / N ~ , } } \end{array}
+$$
+
+As before, this can be used as a metric, or as the starting point for within-top- $\cdot r$ calibration by our method. Examples of this type of calibration (graphs for uncalibrated networks in fig 7 and fig 9) is given in the graphs provided in fig 8 and fig 10 for within-top-2 predictions and within-top-3 predictions respectively.
+
+It is notable that if a classifier is calibrated in the sense of equation (1) in the main paper (also called multi-class-calibrated), then it is also calibrated for top- $\cdot r$ and within-top- $\mathbfit { \nabla } x$ classification.
+
+# C LEAST SQUARE SPLINE FITTING
+
+Least-square fitting using cubic splines is a known technique. However, details are given here for the convenience of the reader. Our primary reference is (McKinley & Levine (1998)), which we adapt to least-squares fitting. We consider the case where the knot-points are evenly spaced.
+
+We change notation from that used in the main paper by denoting points by $( x , y )$ instead of $( u , v )$ . Thus, given knot points $( \hat { x } _ { i } , \hat { y } _ { i } ) _ { k = 1 } ^ { K }$ one is required to fit some points $( x _ { i } , y _ { i } ) _ { i = 1 } ^ { N }$ . Given a point $x$ the corresponding spline value is given by $\boldsymbol { y } = \mathbf { a } ( \boldsymbol { x } ) ^ { \top } \mathbb { M } \hat { \mathbf { y } }$ , where $\hat { \mathbf { y } }$ is the vector of values $\hat { y } _ { i }$ . The form of the vector $\mathbf { a } ( x )$ and the matrix M are given in the following.
+
+The form of the matrix $\mathbb { M }$ is derived from equation (25) in McKinley & Levine (1998). Define the matrices
+
+$$
+\mathbb { A } = \left[ \begin{array} { c c c c c c } { 4 } & { 1 } & & & & \\ { 1 } & { 4 } & { 1 } & & & \\ & { 1 } & { 4 } & { 1 } & & \\ & & & { \ddots } & & \\ & & & & { 1 } & { 4 } & { 1 } \\ & & & & & { 1 } & { 4 } \end{array} \right] ~ ; ~ \mathbb { B } = \frac { 6 } { h ^ { 2 } } \left[ \begin{array} { c c c c c c } { 1 } & { - 2 } & { 1 } & & & \\ & { 1 } & { - 2 } & { 1 } & & \\ & & & { \ddots } & & \\ & & & & { 1 } & { - 2 } & { 1 } \end{array} \right]
+$$
+
+where $h$ is the distance between the knot points. These matrices are of dimensions $K - 2 \times K - 2$ and $K - 2 \times K$ respectively. Finally, let $\mathbb { M }$ be the matrix
+
+$$
+\begin{array} { r } { \mathbb { M } = \left[ \begin{array} { l } { { \bf 0 } _ { K } ^ { \phantom { \dagger } } } \\ { { \bf A } ^ { - 1 } { \bf B } } \\ { { \bf 0 } _ { K } ^ { \phantom { \dagger } } } \\ { { \bf T } _ { K \times K } ^ { \phantom { \dagger } } } \end{array} \right] . } \end{array}
+$$
+
+Here, ${ \bf 0 } _ { K }$ is a vector of zeros of length $K$ , and $\mathbb { I } _ { K \times K }$ is the identity matrix. The matrix M has dimension $2 K \times K$ .
+
+Next, let the point $x$ lie between the knots $j$ and $j + 1$ and let $\boldsymbol { u } = \boldsymbol { x } - \hat { \boldsymbol { x } } _ { j }$ . Then define the vector $\mathbf { v } = \mathbf { a } ( x )$ by values
+
+$$
+\begin{array} { c } { { v _ { j } = - u ^ { 3 } / ( 6 h ) + u ^ { 2 } / 2 - h u / 3 \ , } } \\ { { v _ { j + 1 } = u ^ { 3 } / ( 6 h ) - h u / 6 \ , } } \\ { { v _ { j + K } = - u / h + 1 \ , \ } } \\ { { v _ { j + 1 + K } = u / h \ , \ } } \end{array}
+$$
+
+with other entries equal to $0$ .
+
+<table><tr><td>Dataset</td><td>Image Size</td><td>#class</td><td>Calibration set</td><td>Test set</td></tr><tr><td>CIFAR-10</td><td>32×32</td><td>10</td><td>5000</td><td>10000</td></tr><tr><td>CIFAR-100</td><td>32×32</td><td>100</td><td>5000</td><td>10000</td></tr><tr><td>SVHN</td><td>32×32</td><td>10</td><td>6000</td><td>26032</td></tr><tr><td>ImageNet</td><td>224 × 224</td><td>1000</td><td>25000</td><td>25000</td></tr></table>
+
+Table 3: Dataset splits used for all the calibration experiments. Note, “calibration” set is used for spline fitting in our method and calibration for the baseline methods and then different methods are evaluated on “test” set.   
+Table 4: Within-top-2 predictions. $K S$ Error $( i n \% )$ within-top-2 prediction (with lowest in bold and second lowest underlined) on various image classification datasets and models with different calibration methods. Note, for this experiment we use $^ { 1 4 }$ knots for spline fitting.   
+
+<table><tr><td>Dataset</td><td>Model</td><td>Uncalibrated</td><td>Temp.Scaling</td><td>Vector Scaling</td><td>MS-ODIR</td><td>Dir-ODIR</td><td>Ours (Spline)</td></tr><tr><td rowspan="5">CIFAR-10</td><td>Resnet-110</td><td>1.805</td><td>0.097</td><td>0.176</td><td>0.140</td><td>0.195</td><td>0.277</td></tr><tr><td>Resnet-110-SD</td><td>1.423</td><td>0.111</td><td>0.089</td><td>0.082</td><td>0.073</td><td>0.104</td></tr><tr><td>DenseNet-40</td><td>2.256</td><td>0.435</td><td>0.409</td><td>0.395</td><td>0.348</td><td>0.571</td></tr><tr><td>Wide Resnet-32</td><td>1.812</td><td>0.145</td><td>0.105</td><td>0.124</td><td>0.139</td><td>0.537</td></tr><tr><td>Lenet-5</td><td>3.545</td><td>0.832</td><td>0.831</td><td>0.631</td><td>0.804</td><td>0.670</td></tr><tr><td rowspan="5">CIFAR-100</td><td>Resnet-110</td><td>14.270</td><td>0.885</td><td>0.649</td><td>1.425</td><td>1.190</td><td>0.503</td></tr><tr><td>Resnet-110-SD</td><td>12.404</td><td>0.762</td><td>1.311</td><td>2.120</td><td>1.588</td><td>0.684</td></tr><tr><td>DenseNet-40</td><td>15.901</td><td>0.437</td><td>0.368</td><td>2.205</td><td>0.518</td><td>0.724</td></tr><tr><td>Wide Resnet-32</td><td>14.078</td><td>0.414</td><td>0.548</td><td>1.915</td><td>1.099</td><td>1.017</td></tr><tr><td>Lenet-5</td><td>14.713</td><td>0.787</td><td>1.249</td><td>0.643</td><td>2.682</td><td>0.518</td></tr><tr><td rowspan="2">ImageNet</td><td>Densenet-161</td><td>4.266</td><td>1.051</td><td>0.868</td><td>3.372</td><td>2.536</td><td>0.408</td></tr><tr><td>Resnet-152</td><td>4.851</td><td>1.167</td><td>0.776</td><td>4.093</td><td>2.839</td><td>0.247</td></tr><tr><td>SVHN</td><td>Resnet-152-SD</td><td>0.485</td><td>0.388</td><td>0.410</td><td>0.407</td><td>0.388</td><td>0.158</td></tr></table>
+
+Then the value of the spline is given by
+
+$$
+y = \mathbf { a } ( x ) ^ { \top } \mathbb { M } \hat { \mathbf { y } } ,
+$$
+
+as required. This allows us to fit the spline (varying the values of $\hat { \mathbf { y } }$ ) to points $( x _ { i } , y _ { i } )$ by least-squares fit, as described in the main paper.
+
+The above description is for so-called natural (linear-runout) splines. For quadratic-runout or cubicrunout splines the only difference is that the first and last rows of matrix A are changed – see McKinley & Levine (1998) for details.
+
+As described in the main paper, it is also possible to add linear constraints to this least-squares problem, such as constraints on derivatives of the spline. This results in a linearly-constrained quadratic programming problem.
+
+# D ADDITIONAL EXPERIMENTS
+
+We first provide the experimental setup for different datasets in Table 3. Note, the calibration set is used for spline fitting in our method and then final evaluation is based on an unseen test set.
+
+We also provide comparisons of our method against baseline methods for within-top-2 predictions (equation 5 of the main paper) in Table 4 using KS error. Our method achieves comparable or better results for within-top-2 predictions. It should be noted that the scores for top-3 $( f ^ { ( - 3 ) } ( \mathbf { x } ) )$ or even top-4, top-5, etc., are very close to zero for majority of the samples (due to overconfidence of top-1 predictions). Therefore the calibration error for top- $\cdot r$ with $r > 2$ predictions is very close to zero and comparing different methods with respect to it is of little value. Furthermore, for visual illustration, we provide calibration graphs of top-2 predictions in fig 3 and fig 4 for uncalibrated and calibrated network respectively. Similar graphs for top-3, within-top-2, and within-top-3 predictions are presented in figures 5 – 10.
+
+We also provide classification accuracy comparisons for different post-hoc calibration methods against our method if we apply calibration for all top- $1 , 2 , 3 , \ldots , K$ predictions for $K$ -class classification problem in Table 5. We would like to point out that there is negligible change in accuracy between the calibrated networks (using our method) and the uncalibrated ones.
+
+![](images/97663ca465234bd1e3eccc0b7e499c908265be58d2b79a27ea4f7dc4e4ec9f22.jpg)  
+Test Class[-2] | Uncalibrated KS-error = 3.343%, Probability=   
+Figure 3: Top-2 predictions, Uncalibrated. Calibration graphs for an uncalibrated DenseNet-40 (Huang et al. (2017)) trained on CIFAR-10 for top-2 class with a $K S$ error of $3 . 3 4 3 \%$ on the test set. Here (a) shows the plot of cumulative score and probability versus the fractile of the test set, $( b )$ shows the same information with the horizontal axis warped so that the cumulative-score graph is a straight line. This is created as scatter plots of cumulative (score, score): blue and (score, probability): orange. If the network is perfectly calibrated, the probability line will be a straight line coincident with the (score, score) line. This shows that the network is substantially overestimating (score) the probability of the computation. (c) and (d) show plots of (non-cumulative) score and probability plotted against fractile, or score. How these plots are produced is described in Section 4 of main paper.
+
+![](images/50a3f8806d36d7460a21d74ed5a382b50826eca9c9ce4571ae2d7a15c5f0ac38.jpg)  
+Figure 4: Top-2 predictions, Calibrated. The result of the spline calibration method, on the example given in fig 3 for top-2 calibration. A recalibration function $\gamma : \mathbb { R } \to \mathbb { R }$ is used to adjust the scores, replacing $f _ { k } ( { \bf x } )$ with $\gamma ( f _ { k } ( { \bf x } ) )$ (see Section 4 of main paper). As is seen, the network is now almost perfectly calibrated when tested on the “calibration” set (top row) used to calibrate it. In bottom row, the recalibration function is tested on a further set “test”. It is seen that the result is not perfect, but much better than the original results in fig $3 d$
+
+![](images/43fedb6b50d603d0c11126ee5513afbfc247310082b3e91805ab208f7a4fd459.jpg)  
+Figure 5: Top-3 predictions, Uncalibrated. Calibration graphs for an uncalibrated DenseNet-40 trained on CIFAR-10 for top-3 class with a $K S$ error of $1 . 2 7 7 \%$ on the test set. Here (a) shows the plot of cumulative score and probability versus the fractile of the test set, $( b )$ shows the same information with the horizontal axis warped so that the cumulative-score graph is a straight line. (c) and (d) show plots of (non-cumulative) score and probability plotted against fractile, or score.
+
+![](images/436db6fa107d756d10760032552a206ae84630f00b564e71ac75d0083eb96bf7.jpg)  
+Calib Class[-3] | Calibrated   
+Figure 6: Top-3 predictions, Calibrated. The result of the spline calibration method, on the example given in fig 5 for top-3 calibration. A recalibration function $\gamma : \mathbb { R } \to \mathbb { R }$ is used to adjust the scores, replacing $f _ { k } ( { \bf x } )$ with $\gamma ( f _ { k } ( { \bf x } ) )$ . As is seen, the network is now almost perfectly calibrated when tested on the “calibration” set (top row) used to calibrate it. In bottom row, the recalibration function is tested on a further set “test”. $I t$ is seen that the result is not perfect, but much better than the original results in fig $5 d .$ .
+
+![](images/5b5e4c02a17fb309af59b11a79e0050e28d8f6bf392db5207560bac7a9ca9789.jpg)  
+Figure 7: Within-top-2 predictions, Uncalibrated. Calibration graphs for an uncalibrated DenseNet-40 trained on CIFAR-10 for within-top-2 predictions with a $K S$ error of $2 . 2 5 6 \%$ on the test set. Here (a) shows the plot of cumulative score and probability versus the fractile of the test set, $( b )$ shows the same information with the horizontal axis warped so that the cumulative-score graph is a straight line. (c) and (d) show plots of (non-cumulative) score and probability plotted against fractile, or score.
+
+![](images/d9fd2afebee506773d75d2ffda80d55bd15de8d2153fdf1a43ebd182f4bcdc8d.jpg)  
+Figure 8: Within-top-2 predictions, Calibrated. The result of the spline calibration method, on the example given in fig 7 for within-top-2 calibration. A recalibration function $\gamma : \mathbb { R } \to \mathbb { R }$ is used to adjust the scores, replacing $f _ { k } ( { \bf x } )$ with $\gamma ( f _ { k } ( { \bf x } ) )$ . As is seen, the network is now almost perfectly calibrated when tested on the “calibration” set (top row) used to calibrate it. In bottom row, the recalibration function is tested on a further set “test”. It is seen that the result is not perfect, but much better than the original results in fig 7d.
+
+![](images/91e54bcb7c2e45652297f75ddcd5ab49df0dea4f85dbc644d439bf64395f5950.jpg)  
+Figure 9: Within-top-3 predictions, Uncalibrated. Calibration graphs for an uncalibrated DenseNet-40 trained on CIFAR-10 for within-top-3 predictions with a $K S$ error of $0 . 9 8 3 \%$ on the test set. Here (a) shows the plot of cumulative score and probability versus the fractile of the test set, $( b )$ shows the same information with the horizontal axis warped so that the cumulative-score graph is a straight line. (c) and (d) show plots of (non-cumulative) score and probability plotted against fractile, or score.
+
+![](images/727ff21bd007963a3fd0a5fd45d979df000384ed467750d29a5b8151b07d3252.jpg)  
+Figure 10: Within-top-3 predictions, Calibrated. The result of the spline calibration method, on the example given in fig 9 for within-top-3 calibration. A recalibration function $\gamma : \mathbb { R } \to \mathbb { R }$ is used to adjust the scores, replacing $f _ { k } ( { \bf x } )$ with $\gamma ( f _ { k } ( { \bf x } ) )$ . As is seen, the network is now almost perfectly calibrated when tested on the “calibration” set (top row) used to calibrate it. In bottom row, the recalibration function is tested on a further set “test”. $I t$ is seen that the result is not perfect, but much better than the original results in fig 9d.
+
+Table 5: Classification (top-1) accuracy (with highest in bold and second highest underlined) post calibration on various image classification datasets and models with different calibration methods. Note, only a negligible change in accuracy is observed in our method compared to the uncalibrated networks.   
+
+<table><tr><td>Dataset</td><td>Model</td><td>Uncalibrated</td><td>Temp. Scaling</td><td>Vector Scaling</td><td>MS-ODIR</td><td>Dir-ODIR</td><td>Ours (Spline)</td></tr><tr><td rowspan="5">CIFAR-10</td><td>Resnet-110</td><td>93.56</td><td>93.56</td><td>93.50</td><td>93.53</td><td>93.52</td><td>93.55</td></tr><tr><td>Resnet-110-SD</td><td>94.04</td><td>94.04</td><td>94.04</td><td>94.18</td><td>94.20</td><td>94.05</td></tr><tr><td>DenseNet-40</td><td>92.42</td><td>92.42</td><td>92.50</td><td>92.52</td><td>92.47</td><td>92.31</td></tr><tr><td>Wide Resnet-32</td><td>93.93</td><td>93.93</td><td>94.21</td><td>94.22</td><td>94.22</td><td>93.76</td></tr><tr><td>Lenet-5</td><td>72.74</td><td>72.74</td><td>74.48</td><td>74.44</td><td>74.52</td><td>72.64</td></tr><tr><td rowspan="5">CIFAR-100</td><td>Resnet-110</td><td>71.48</td><td>71.48</td><td>71.58</td><td>71.55</td><td>71.62</td><td>71.50</td></tr><tr><td>Resnet-110-SD</td><td>72.83</td><td>72.83</td><td>73.60</td><td>73.53</td><td>73.14</td><td>72.81</td></tr><tr><td>DenseNet-40</td><td>70.00</td><td>70.00</td><td>70.13</td><td>70.40</td><td>70.24</td><td>70.17</td></tr><tr><td>Wide Resnet-32</td><td>73.82</td><td>73.82</td><td>73.87</td><td>74.05</td><td>73.99</td><td>73.74</td></tr><tr><td>Lenet-5</td><td>33.59</td><td>33.59</td><td>36.42</td><td>37.58</td><td>37.52</td><td>33.55</td></tr><tr><td rowspan="2">ImageNet</td><td>Densenet-161</td><td>77.05</td><td>77.05</td><td>76.72</td><td>77.15</td><td>77.19</td><td>77.05</td></tr><tr><td>Resnet-152</td><td>76.20</td><td>76.20</td><td>75.87</td><td>76.12</td><td>76.24</td><td>76.07</td></tr><tr><td>SVHN</td><td>Resnet-152-SD</td><td>98.15</td><td>98.15</td><td>98.13</td><td>98.12</td><td>98.19</td><td>98.17</td></tr></table>
+
+Table 6: ECE for top-1 predictions $( \dot { m } ^ { \mathrm { ~ } } )$ using 25 bins (with lowest in bold and second lowest underlined) on various image classification datasets and models with different calibration methods. Note, for this experiment we use 13 knots for spline fitting.   
+
+<table><tr><td>Dataset</td><td>Model</td><td>Uncalibrated</td><td>Temp. Scaling</td><td>Vector Scaling</td><td>MS-ODIR</td><td>Dir-ODIR</td><td>Ours (Spline)</td></tr><tr><td rowspan="5">CIFAR-10</td><td>Resnet-110</td><td>4.750</td><td>1.224</td><td>1.092</td><td>1.276</td><td>1.240</td><td>1.011</td></tr><tr><td>Resnet-110-SD</td><td>4.135</td><td>0.777</td><td>0.752</td><td>0.684</td><td>0.859</td><td>0.992</td></tr><tr><td>DenseNet-40</td><td>5.507</td><td>1.006</td><td>1.207</td><td>1.250</td><td>1.268</td><td>1.389</td></tr><tr><td>Wide Resnet-32</td><td>4.512</td><td>0.905</td><td>0.852</td><td>0.941</td><td>0.965</td><td>1.003</td></tr><tr><td>Lenet-5</td><td>5.188</td><td>1.999</td><td>1.462</td><td>1.504</td><td>1.300</td><td>1.333</td></tr><tr><td rowspan="5">CIFAR-100</td><td>Resnet-110</td><td>18.480</td><td>2.428</td><td>2.722</td><td>3.011</td><td>2.806</td><td>1.868</td></tr><tr><td>Resnet-110-SD</td><td>15.861</td><td>1.335</td><td>2.067</td><td>2.277</td><td>2.046</td><td>1.766</td></tr><tr><td>DenseNet-40</td><td>21.159</td><td>1.255</td><td>1.598</td><td>2.855</td><td>1.410</td><td>2.114</td></tr><tr><td>Wide Resnet-32</td><td>18.784</td><td>1.667</td><td>1.785</td><td>2.870</td><td>2.128</td><td>1.672</td></tr><tr><td>Lenet-5</td><td>12.117</td><td>1.535</td><td>1.350</td><td>1.696</td><td>2.159</td><td>1.029</td></tr><tr><td rowspan="2">ImageNet</td><td>Densenet-161</td><td>5.720</td><td>2.059</td><td>2.637</td><td>4.337</td><td>3.989</td><td>0.798</td></tr><tr><td>Resnet-152</td><td>6.545</td><td>2.166</td><td>2.641</td><td>5.377</td><td>4.556</td><td>0.913</td></tr><tr><td>SVHN</td><td>Resnet-152-SD</td><td>0.877</td><td>0.675</td><td>0.630</td><td>0.646</td><td>0.651</td><td>0.832</td></tr></table>
+
+For the sake of completeness, we present calibration results using the existing calibration metric, Expected Calibration Error (ECE) (Naeini et al. (2015)) in Table 6. We would like to reiterate the fact that ECE metric is highly dependent on the chosen number of bins and thus does not really reflect true calibration performance. To reflect the efficacy of our proposed calibration method, we also present calibration results using other calibration metrics such as recently proposed binning free measure KDE-ECE (Zhang et al. (2020)), MCE (Maximum Calibration Error) (Guo et al. (2017)) and Brier Scores for top-1 predictions on ImageNet dataset in Table 7. Since, the original formulation of Brier Score for multi-class predictions is highly biased on the accuracy and is approximately similar for all calibration methods, we hereby use top-1 Brier Score which is the mean squared error between top-1 scores and ground truths for the top-1 predictions (1 if the prediction is correct and 0 otherwise). It can be clearly observed that our approach consistently outperforms all the baselines on different calibration measures.
+
+Table 7: Calibration Error using other different metrics such as binning-free KDE-ECE (Zhang et al. (2020)), MCE (Maximum Calibration Error) (Guo et al. (2017)) and Brier Score for top-1 predictions (with lowest in bold and and second lowest underlined) on ImageNet dataset with different calibration methods. Note, for this experiment we use 6 knots for spline fitting.   
+
+<table><tr><td>Calibration Metric</td><td>Model</td><td>Uncalibrated</td><td>Temp. Scaling</td><td>MS-ODIR</td><td>Dir-ODIR</td><td>Ours (Spline)</td></tr><tr><td rowspan="2">KDE-ECE</td><td>Densenet-161</td><td>0.03786</td><td>0.01501</td><td>0.02874</td><td>0.02979</td><td>0.00637</td></tr><tr><td>Resnet-152</td><td>0.04650</td><td>0.01864</td><td>0.03448</td><td>0.03488</td><td>0.00847</td></tr><tr><td rowspan="2">MCE</td><td>Densenet-161</td><td>0.13123</td><td>0.05442</td><td>0.09077</td><td>0.09653</td><td>0.06289</td></tr><tr><td>Resnet-152</td><td>0.15930</td><td>0.09051</td><td>0.11201</td><td>0.09868</td><td>0.04950</td></tr><tr><td rowspan="2">Brier Score</td><td>Densenet-161</td><td>0.12172</td><td>0.11852</td><td>0.11982</td><td>0.11978</td><td>0.11734</td></tr><tr><td>Resnet-152</td><td>0.12626</td><td>0.12145</td><td>0.12406</td><td>0.12308</td><td>0.12034</td></tr></table>

parse/train/rJXTf9Bxg/rJXTf9Bxg.md

@@ -0,0 +1,205 @@
+# CONDITIONAL IMAGE SYNTHESIS WITH AUXILIARY CLASSIFIER GANS
+
+Augustus Odena∗, Christopher Olah & Jonathon Shlens Google Brain {augustusodena,colah,shlens}@google.com
+
+# ABSTRACT
+
+Synthesizing high resolution photorealistic images has been a long-standing challenge in machine learning. In this paper we introduce new methods for the improved training of generative adversarial networks (GANs) for image synthesis. We construct a variant of GANs employing label conditioning that results in $1 2 8 \times 1 2 8$ resolution image samples exhibiting global coherence. We expand on previous work for image quality assessment to provide two new analyses for assessing the discriminability and diversity of samples from class-conditional image synthesis models. These analyses demonstrate that high resolution samples provide class information not present in low resolution samples. Across 1000 ImageNet classes, $1 2 8 \times 1 2 8$ samples are more than twice as discriminable as artificially resized $3 2 \times 3 2$ samples. In addition, $8 4 . 7 \%$ of the classes have samples exhibiting diversity comparable to real ImageNet data.
+
+# 1 INTRODUCTION
+
+Characterizing the structure of natural images has been a rich research endeavor. Natural images obey intrinsic invariances and exhibit multi-scale statistical structures that have historically been difficult to quantify (Simoncelli & Olshausen, 2001). Recent advances in machine learning offer an opportunity to substantially improve the quality of image models. Improved image models advance the state-of-the-art in image denoising (Balle et al., 2015), compression (Toderici et al., ´ 2016), in-painting (van den Oord et al., 2016a), and super-resolution (Ledig et al., 2016). Better models of natural images also improve performance in semi-supervised learning tasks (Kingma et al., 2014; Springenberg, 2015; Odena, 2016; Salimans et al., 2016) and reinforcement learning problems (Blundell et al., 2016).
+
+One method for understanding natural image statistics is to build a system that synthesizes images de novo. There are several promising approaches for building image synthesis models. Variational autoencoders (VAEs) maximize a variational lower bound on the log-likelihood of the training data (Kingma & Welling, 2013; Rezende et al., 2014). VAEs are straightforward to train but introduce potentially restrictive assumptions about the approximate posterior distribution (but see Rezende & Mohamed (2015); Kingma et al. (2016)). Autoregressive models dispense with latent variables and directly model the conditional distribution over pixels (van den Oord et al., 2016a;b). These models produce convincing samples but are costly to sample from and do not provide a latent representation. Invertible density estimators transform latent variables directly using a series of parameterized functions constrained to be invertible (Dinh et al., 2016). This technique allows for exact log-likelihood computation and exact inference, but the invertibility constraint is restrictive.
+
+Generative adversarial networks (GANs) offer a distinct and promising approach that focuses on a game-theoretic formulation for training an image synthesis model (Goodfellow et al., 2014). Recent work has shown that GANs can produce convincing image samples on datasets with low variability and low resolution (Denton et al., 2015; Radford et al., 2015). However, GANs struggle to generate globally coherent, high resolution samples - particularly from datasets with high variability. Moreover, a theoretical understanding of GANs is an on-going research topic (Uehara et al., 2016; Mohamed & Lakshminarayanan, 2016).
+
+![](images/6c54ff79e795f9c8c06ba6f5fddd92ded1c68470b9b4689df4c6f2fe2425a2ae.jpg)  
+Figure 1: $1 2 8 \times 1 2 8$ resolution samples from 5 classes taken from an AC-GAN trained on the ImageNet dataset. Note that the classes shown have been selected to highlight the success of the model and are not representative. Samples from all ImageNet classes are in the Appendix.
+
+In this work we demonstrate that that adding more structure to the GAN latent space along with a specialized cost function results in higher quality samples. We exhibit $1 2 8 \times 1 2 8$ pixel samples from all classes of the ImageNet dataset (Russakovsky et al., 2015) with increased global coherence (Figure 1). Importantly, we demonstrate quantitatively that our high resolution samples are not just naive resizings of low resolution samples. In particular, downsampling our $1 2 8 \times 1 2 8$ samples to $3 2 \times 3 2$ leads to a $50 \%$ decrease in visual discriminability. We also introduce a new metric for assessing the variability across image samples and employ this metric to demonstrate that our synthesized images exhibit diversity comparable to training data for a large fraction $( 8 4 . 7 \% )$ o f ImageNet classes.
+
+# 2 BACKGROUND
+
+A generative adversarial network (GAN) consists of two neural networks trained in opposition to one another. The generator $G$ takes as input a random noise vector $z$ and outputs an image $X _ { f a k e } =$ $G ( z )$ . The discriminator $D$ receives as input either a training image or a synthesized image from the generator and outputs a probability distribution $P ( S \mid X ) { \bar { = } } D ( { \bar { X } } )$ over possible image sources. The discriminator is trained to maximize the log-likelihood it assigns to the correct source:
+
+$$
+L = E [ \log P ( S = r e a l \mid X _ { r e a l } ) ] + E [ \log P ( S = f a k e \mid X _ { f a k e } ) ]
+$$
+
+The generator is trained to minimize that same quantity.
+
+The basic GAN framework can be augmented using side information. One strategy is to supply both the generator and discriminator with class labels in order to produce class conditional samples (Mirza & Osindero, 2014). Class conditional synthesis can significantly improve the quality of generated samples (van den Oord et al., 2016b). Richer side information such as image captions and bounding box localizations may improve sample quality further (Reed et al., 2016a;b).
+
+Instead of feeding side information to the discriminator, one can task the discriminator with reconstructing side information. This is done by modifying the discriminator to contain an auxiliary decoder network1 that outputs the class label for the training data (Odena, 2016; Salimans et al., 2016) or a subset of the latent variables from which the samples are generated (Chen et al., 2016). Forcing a model to perform additional tasks is known to improve performance on the original task (e.g. Sutskever et al. (2014); Szegedy et al. (2014); Ramsundar et al. (2016)). In addition, an auxiliary decoder could leverage pre-trained discriminators (e.g. image classifiers) for further improving the synthesized images (Nguyen et al., 2016). Motivated by these considerations, we introduce a model that combines both strategies for leveraging side information. That is, the model proposed below is class conditional, but with an auxiliary decoder that is tasked with reconstructing class labels.
+
+![](images/2c8e4b75bbef0abbd48b3621fe4c58406b2eb46d2aa4772586d617c0e61a3b9a.jpg)  
+Figure 2: A comparison of several GAN architectures with the proposed AC-GAN architecture.
+
+# 3 AC-GANS
+
+We propose a variant of the GAN architecture which we call an auxiliary classifier GAN (or ACGAN - see Figure 2). In the AC-GAN, every generated sample has a corresponding class label, $c \sim$ $p _ { c }$ in addition to the noise $z$ . $G$ uses both to generate images $X _ { f a k e } = G ( c , z )$ . The discriminator gives both a probability distribution over sources and a probability distribution over the class labels, $P ( S \mid X )$ , $P ( C \mid X ) = D ( X )$ . The objective function has two parts: the log-likelihood of the correct source, $L _ { S }$ , and the log-likelihood of the correct class, $L _ { C }$ .
+
+$$
+\begin{array} { c } { { L _ { S } = E [ \log P ( S = r e a l \mid X _ { r e a l } ) ] + E [ \log P ( S = f a k e \mid X _ { f a k e } ) ] } } \\ { { L _ { C } = E [ \log P ( C = c \mid X _ { r e a l } ) ] + E [ \log P ( C = c \mid X _ { f a k e } ) ] } } \end{array}
+$$
+
+$D$ is trained to maximize $L _ { S } + L _ { C }$ while $G$ is trained to maximize $L _ { C } - L _ { S }$ . AC-GANs learn a representation for $z$ that is independent of class label (e.g. Kingma et al. (2014)).
+
+Early experiments demonstrated that increasing the number of classes trained on while holding the model fixed decreased the quality of the model outputs (Appendix B). The structure of the ACGAN model permits separating large datasets into subsets by class and training a generator and discriminator for each subset. We exploit this property in our experiments to train across the entire ImageNet data set.
+
+# 4 RESULTS
+
+We train several AC-GAN models on the ImageNet data set (Russakovsky et al., 2015). Broadly speaking, the architecture of the generator $G$ is a series of ‘deconvolution’ layers that transform the noise $z$ and class $c$ into an image (Odena et al., 2016). We train two variants of the model architecture for generating images at $1 2 8 \times 1 2 8$ and $6 4 \times 6 4$ spatial resolutions. The discriminator $D$ is a deep convolutional neural network with a Leaky ReLU nonlinearity (Maas et al., 2013). See Appendix A for more details. As mentioned earlier, we find that reducing the variability introduced by all 1000 classes of ImageNet significantly improves the quality of training. We train 100 AC-GAN models – each on images from just 10 classes – for 50000 mini-batches of size 100.
+
+Evaluating the quality of image synthesis models is challenging due to the variety of probabilistic criteria (Theis et al., 2015) and the lack of a perceptually meaningful image similarity metric. Nonetheless, in subsequent sections we attempt to measure the quality of the AC-GAN by building several ad-hoc measures for image sample discriminability and diversity. Our hope is that this work might provide quantitative measures that may be used to aid training and subsequent development of image synthesis models.
+
+![](images/d56f4dbab4265245abb44ef2c0bebe10e50f195c62fca3d365953998b4cd05dc.jpg)  
+Figure 3: Generating high resolution images improves discriminability. Top: Training data and synthesized images from the zebra class resized to a lower spatial resolution (indicated above) and subsequently artificially resized to the original resolution. Inception accuracy is shown below the corresponding images. Bottom Left: Summary of accuracies across varying spatial resolutions for training data and image samples from $6 4 \times 6 4$ and $1 2 8 \times 1 2 8$ models. Error bar measures standard deviation across 10 subsets of images. Dashed lines highlight the accuracy at the output spatial resolution of the model. The training data (clipped) achieves accuracies of $24 \%$ , $54 \%$ , $81 \%$ and $81 \%$ at resolutions of 32, 64, 128, and 256 respectively. Bottom Right: Comparison of accuracy scores at $1 2 8 \times 1 2 8$ and $3 2 \times 3 2$ spatial resolutions $x$ and $_ y$ axis, respectively). Each point represents an ImageNet class. $8 4 . 4 \%$ of the classes are below the line of equality. The green dot corresponds to the zebra class.
+
+# 4.1 GENERATING HIGH RESOLUTION IMAGES IMPROVES DISCRIMINABILITY
+
+Building a class-conditional image synthesis model necessitates measuring the extent to which synthesized images appear to belong to the intended class. In particular, we would like to know that a high resolution sample is not just a naive resizing of a low resolution sample. Consider a simple experiment: pretend there exists a model that synthesizes $3 2 \times 3 2$ images. One can trivially increase the resolution of synthesized images by performing bilinear interpolation. This would yield higher resolution images, but these images would just be blurry versions of the low resolution images that are not discriminable. Hence, the goal of an image synthesis model is not simply to produce high resolution images, but to produce high resolution images that are more discriminable than low resolution images.
+
+To measure discriminability, we feed synthesized images to a pre-trained Inception network (Szegedy et al., 2015) and report the fraction of the samples for which the Inception network assigned the correct label2. We calculate this accuracy measure on a series of real and synthesized images which have had their spatial resolution artificially decreased by bilinear interpolation (Figure 3, top panels). Note that as the spatial resolution is decreased, the accuracy decreases - indicating that resulting images contain less class information (Figure 3, scores below top panels). We summarized this finding across all 1000 ImageNet classes for the ImageNet training data (black), a $1 2 8 \times 1 2 8$ resolution AC-GAN (red) and a $6 4 \times 6 4$ resolution AC-GAN (blue) in Figure 3 (bottom, left). The black curve (clipped) provides an upper-bound on the discriminability of real images.
+
+The goal of this analysis is to show that synthesizing higher resolution images leads to increased discriminability. The $1 2 8 \times 1 2 8$ model achieves an accuracy of $1 0 . 1 \% \pm 2 . 0 \%$ versus $7 . 0 \% \pm 2 . 0 \%$ with samples resized to $6 4 \times 6 4$ and $5 . 0 \% \pm 2 . 0 \%$ with samples resized to $3 2 \times 3 2$ . In other words, downsizing the outputs of the AC-GAN to $3 2 \times 3 2$ and $6 4 \times 6 4$ decreases visual discriminability by $50 \%$ and $38 \%$ respectively. Furthermore, $8 4 . 4 \%$ of the ImageNet classes have higher accuracy at $1 2 8 \times 1 2 8$ than at $3 2 \times 3 2$ (Figure 3, bottom left).
+
+We performed the same analysis on an AC-GAN trained to $6 4 \times 6 4$ spatial resolution. This model achieved less discriminability than a $1 2 8 \times 1 2 8$ AC-GAN model. Accuracies from the $6 4 \times 6 4$ model plateau at a $6 4 \times 6 4$ spatial resolution consistent with previous results. Finally, the $6 4 \times 6 4$ resolution model achieves less discriminability at 64 spatial resolution than the $1 2 8 \times 1 2 8$ model.
+
+# 4.2 MEASURING THE DIVERSITY OF GENERATED IMAGES
+
+An image synthesis model is not very interesting if it only outputs one image. Indeed, a well-known failure mode of GANs is that the generator will collapse and output a single prototype that maximally fools the discriminator (Goodfellow et al., 2014; Salimans et al., 2016). A class-conditional model of images is not very interesting if it only outputs one image per class. The Inception accuracy can not measure whether a model has collapsed. A model that simply memorized one example from each ImageNet class would do very well by this metric. Thus, we seek a complementary metric to explicitly evaluate the intra-class diversity of samples generated by the AC-GAN.
+
+Several methods exist for quantitatively evaluating image similarity by attempting to predict human perceptual similarity judgements. The most successful of these is multi-scale structural similarity (MS-SSIM) (Wang et al., 2004b; Ma et al., 2016). MS-SSIM is a multi-scale variant of a wellcharacterized perceptual similarity metric that attempts to discount aspects of an image that are not important for human perception (Wang et al., 2004a). MS-SSIM values range between 0.0 and 1.0; higher MS-SSIM values correspond to perceptually more similar images. As a proxy for image diversity, we measure the MS-SSIM scores between randomly chosen pairs of images within a given class. Samples from classes that have higher diversity result in lower mean MS-SSIM scores (Figure 4, left columns); samples from classes with lower diversity have higher mean MS-SSIM scores (Figure 4, right columns). Training images from the ImageNet training data contain a variety of mean MS-SSIM scores across the classes indicating the variability of image diversity in ImageNet classes (Figure 5, left panel, x-axis). Note that the highest mean MS-SSIM score (indicating the least variability) is 0.25 for the training data.
+
+We calculate the mean MS-SSIM score for all 1000 ImageNet classes generated by the AC-GAN model. We track this value during training to identify whether the generator has collapsed (Figure 5, right panel, red curve). We also employ this metric to compare the diversity of the training images to the samples from the GAN model after training has completed. Figure 5 (left) plots the mean MS-SSIM values for image samples and training data broken up by class. The blue line is the line of equality. Out of the 1000 classes, we find that 847 have mean sample MS-SSIM scores below that of the maximum MS-SSIM for the training data. In other words, $8 4 . 7 \%$ of classes have sample variability that exceeds that of the least variable class from the ImageNet training data.
+
+# .3 GENERATED IMAGES ARE BOTH DIVERSE AND DISCRIMINABLE
+
+We have presented quantitative metrics demonstrating that AC-GAN samples may be diverse and discriminable but we have yet to examine how these metrics interact. Figure 6 shows the joint distribution of Inception accuracies and MS-SSIM scores across all classes. Inception accuracy and MS-SSIM are anti-correlated $( r ^ { 2 } = - 0 . 1 6 )$ . In fact, $74 \%$ of the classes with low diversity (MS$\mathrm { S S I M } \geq 0 . 2 5 )$ ) contain Inception accuracies $\leq 1 \%$ . These results suggest that GANs that drop modes are most likely to produce low quality images. Conversely, $78 \%$ of classes with high diversity (MS$\mathrm { S S I M } < 0 . 2 5 )$ ) have Inception accuracies that exceed $1 \%$ . In comparison, the Inception-v3 model achieves $78 . 8 \%$ accuracy on average across all 1000 classes (Szegedy et al., 2015). A fraction of the classes AC-GAN samples reach this level of accuracy. This indicates opportunity for future image synthesis models.
+
+![](images/d1c09fc189f805c2f92ce95cea6c018d4411f17fa6c643c606281246a6c2c832.jpg)  
+Figure 4: Examples of different MS-SSIM scores. The top and bottom rows contain AC-GAN samples and training data, respectively.
+
+![](images/e90290666c512929542137b05c935ee1c50f9d623f412cfcb51c43a09bfbb4d9.jpg)  
+Figure 5: (Left) Comparison of the mean MS-SSIM scores between pairs of images within a given class for ImageNet training data and samples from the GAN (blue line is equality). The horizontal red line marks the maximum MS-SSIM value across all ImageNet classes. Each point is an individual class. The mean standard deviation of scores across the training data and the samples was 0.06 and 0.08 respectively. Scores below the red line $8 4 . 7 \%$ of classes) arise from classes where GAN training largely succeeded. (Right) Intra-class MS-SSIM for selected ImageNet classes throughout a training run. Classes that successfully train tend to have decreasing mean MS-SSIM scores, to a point.
+
+# 4.4 COMPARISON TO PREVIOUS RESULTS
+
+Previous quantitative results for image synthesis models trained on ImageNet are reported in terms of log-likelihood (van den Oord et al., 2016a;b). Log-likelihood is a coarse and potentially inaccurate measure of sample quality (Theis et al., 2015). Addditionally, log-likelihood is intractable to compute for GANs. Instead we compare with previous state-of-the-art results on CIFAR-10 using a lower spatial resolution $( 3 2 \times 3 2 )$ . Following the procedure in Salimans et al. (2016), we compute the Inception score3 for 50000 samples from an AC-GAN with resolution $( 3 2 \times 3 2 )$ , split into 10 groups at random. We also compute the Inception score for 25000 extra samples, split into 5 groups at random. We select the best model based on the first score and report the second score. Performing a grid search across 27 hyperparameter configurations, we are able to achieve a score of $8 . 2 5 \pm 0 . 0 \bar { 7 }$ compared to state of the art $8 . 0 9 \pm 0 . 0 7$ (Salimans et al., 2016). Moreover, we accomplish this without employing any of the new techniques introduced in that work (i.e. virtual batch normalization, minibatch discrimination, and label smoothing). This provides additional evidence that AC-GANs are effective even without the benefit of class splitting (Appendix B).
+
+![](images/c7340ee3cd4c3d0cd70374c54c149138743e0f6739d04163cc3f5eff95c62882.jpg)  
+Figure 6: Inception accuracy vs MS-SSIM for all 1000 ImageNet classes $( r ^ { 2 } = - 0 . 1 6 )$ . Samples from ACGAN models do not achieve variability at the expense of discriminability.
+
+# 4.5 SEARCHING FOR SIGNATURES OF OVERFITTING
+
+One possibility that must be investigated is that the AC-GAN has overfit on the training data. As a first check that the network does not memorize the training data, we identify the nearest neighbors of image samples in the training data measured by L1 distance in pixel space (Figure 7). The nearest neighbors from the training data do not resemble the corresponding samples. This provides evidence that the AC-GAN is not merely memorizing the training data.
+
+![](images/120e5224c6b0bd27e21d9da5672a1e4a777b36a22e113a7da9c570cebc7526fc.jpg)  
+Figure 7: Nearest neighbor analysis. (Left) Samples from a single ImageNet class. (Right) Corresponding nearest neighbor (L1 distance) in training data for each sample.
+
+A more sophisticated method for understanding the degree of overfitting in a model is to explore that model’s latent space by interpolation. In an overfit model one might observe discrete transitions in the interpolated images and regions in latent space that do not correspond to meaningful images (Bengio et al., 2012; Radford et al., 2015; Dinh et al., 2016). Figure 8 (left) highlights interpolations in the latent space between several image samples. Notably, the generator learned that certain combinations of dimensions correspond to semantically meaningful features (e.g. size of the arch, length of a bird’s beak) and there are no discrete transitions or ‘holes’ in the latent space. A second method for exploring the latent space of the AC-GAN is to exploit the structure of the model. The AC-GAN factorizes its representation into class information and a class-independent latent representation $z$ . Sampling the AC-GAN with $z$ fixed but altering the class label corresponds to generating samples with the same ‘style’ across multiple classes (Kingma et al., 2014). Figure 8 (right) shows samples from 8 bird classes. Elements of the same row have the same $z$ . Although the class changes for each column, elements of the global structure (e.g. position, layout, background) are preserved, indicating that AC-GAN can represent certain types of ‘compositionality’.
+
+![](images/d60141da6931af7de4eef8da76d32149f4da27466edabbb461f0317e02590fe0.jpg)  
+Figure 8: (Left) Latent space interpolations for selected ImageNet classes. Left-most and right-columns show three pairs of image samples - each pair from a distinct class. Intermediate columns highlight linear interpolations in the latent space between these three pairs of images. (Right) Class-independent information contains global structure about the synthesized image. Each column is a distinct bird class while each row corresponds to a fixed latent code $z$ .
+
+# 5 DISCUSSION
+
+This work introduced the AC-GAN architecture and demonstrated that AC-GANs can generate globally coherent ImageNet samples. We provided a new quantitative metric for image discriminability as a function of spatial resolution. Using this metric we demonstrated that our samples are more discriminable than those from a model that generates lower resolution images and performs a naive resize operation. We also analyzed the diversity of our samples with respect to the training data and provided some evidence that the image samples from the majority of classes are comparable in diversity to ImageNet training data. We hope that these metrics might provide quantitative measures of sample quality for evaluating and improving future image synthesis models.
+
+Several directions exist for building upon this work. Much work needs to be done to improve the visual discriminability of the $1 2 8 \times 1 2 8$ resolution model. Although some synthesized image classes exhibit high Inception accuracies, the average Inception accuracy of the model $( 1 0 . 1 \% \pm 2 . 0 \% )$ is still far below real training data at $81 \%$ . One immediate opportunity for addressing this is to augment the discriminator with a pre-trained model to perform additional supervised tasks (e.g. image segmentation, Ronneberger et al. (2015)). Such techniques might allow for the synthesis of even higher resolution images with global coherence and meaningful visual content.
+
+Improving the robustness and reliability of training a GAN is an ongoing research topic. Only $8 4 . 7 \%$ of the ImageNet classes avoided mode dropping and exhibited a diversity comparable to real training data. Training stability was vastly aided by dividing up 1000 ImageNet classes across 100 AC-GAN models. Building a single unified model that could generate diverse samples from all 1000 classes would be an important step forward.
+
+Image synthesis models provide a unique opportunity for performing semi-supervised learning. Namely, these models build a rich prior over natural image statistics that can be leveraged by classifiers to improve predictions on datasets for which few labels exist. The AC-GAN model can perform semi-supervised learning by simply ignoring the component of the loss arising from class labels when a label is unavailable for a given training image. Interestingly, prior work suggests that achieving good sample quality might be independent of success in semi-supervised learning (Salimans et al., 2016).
+
+# ACKNOWLEDGMENTS
+
+We thank the developers of TensorFlow (Abadi et al., 2016). We thank Luke Metz and Vincent Dumoulin for extensive and helpful comments on drafts. We also thank Ben Poole, Sam Schoenholz, Barret Zoph, Mart´ın Abadi, Manjunath Kudlur and Jascha Sohl-Dickstein for helpful discussions.
+
+# REFERENCES
+
+Abadi et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. CoRR, abs/1603.04467, 2016. URL http://arxiv.org/abs/1603.04467.
+
+Johannes Balle, Valero Laparra, and Eero P. Simoncelli. Density modeling of images using a gen- ´ eralized normalization transformation. CoRR, abs/1511.06281, 2015. URL http://arxiv. org/abs/1511.06281.
+
+Yoshua Bengio, Gregoire Mesnil, Yann Dauphin, and Salah Rifai. Better mixing via deep represen- ´ tations. CoRR, abs/1207.4404, 2012. URL http://arxiv.org/abs/1207.4404.
+
+C. Blundell, B. Uria, A. Pritzel, Y. Li, A. Ruderman, J. Z Leibo, J. Rae, D. Wierstra, and D. Hassabis. Model-Free Episodic Control. ArXiv e-prints, June 2016.
+
+X. Chen, Y. Duan, R. Houthooft, J. Schulman, I. Sutskever, and P. Abbeel. InfoGAN: Interpretable Representation Learning by Information Maximizing Generative Adversarial Nets. ArXiv eprints, June 2016.
+
+Emily L. Denton, Soumith Chintala, Arthur Szlam, and Robert Fergus. Deep generative image models using a laplacian pyramid of adversarial networks. CoRR, abs/1506.05751, 2015. URL http://arxiv.org/abs/1506.05751.
+
+Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using real NVP. CoRR, abs/1605.08803, 2016. URL http://arxiv.org/abs/1605.08803.
+
+J. Donahue, P. Krahenb ¨ uhl, and T. Darrell. Adversarial Feature Learning. ¨ ArXiv e-prints, May 2016.
+
+V. Dumoulin, I. Belghazi, B. Poole, A. Lamb, M. Arjovsky, O. Mastropietro, and A. Courville. Adversarially Learned Inference. ArXiv e-prints, June 2016.
+
+I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative Adversarial Networks. ArXiv e-prints, June 2014.
+
+D. P Kingma and M. Welling. Auto-Encoding Variational Bayes. ArXiv e-prints, December 2013.
+
+Diederik P. Kingma, Danilo Jimenez Rezende, Shakir Mohamed, and Max Welling. Semisupervised learning with deep generative models. CoRR, abs/1406.5298, 2014. URL http: //arxiv.org/abs/1406.5298.
+
+Diederik P. Kingma, Tim Salimans, and Max Welling. Improving variational inference with inverse autoregressive flow. CoRR, abs/1606.04934, 2016. URL http://arxiv.org/abs/1606. 04934.
+
+C. Ledig, L. Theis, F. Huszar, J. Caballero, A. Aitken, A. Tejani, J. Totz, Z. Wang, and W. Shi. Photo-Realistic Single Image Super-Resolution Using a Generative Adversarial Network. ArXiv e-prints, September 2016.
+
+Kede Ma, Qingbo Wu, Zhou Wang, Zhengfang Duanmu, Hongwei Yong, Hongliang Li, and Lei Zhang. Group mad competition - a new methodology to compare objective image quality models. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2016.
+
+Andrew Maas, Awni Hannun, and Andrew Ng. Rectifier nonlinearities improve neural network acoustic models. In Proceedings of The 33rd International Conference on Machine Learning, 2013.
+
+Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. CoRR, abs/1411.1784, 2014. URL http://arxiv.org/abs/1411.1784.
+
+Shakir Mohamed and Balaji Lakshminarayanan. Learning in implicit generative models. arXiv preprint arXiv:1610.03483, 2016.
+
+Anh Mai Nguyen, Alexey Dosovitskiy, Jason Yosinski, Thomas Brox, and Jeff Clune. Synthesizing the preferred inputs for neurons in neural networks via deep generator networks. CoRR, abs/1605.09304, 2016. URL http://arxiv.org/abs/1605.09304.
+
+A. Odena. Semi-Supervised Learning with Generative Adversarial Networks. ArXiv e-prints, June 2016.   
+Augustus Odena, Vincent Dumoulin, and Chris Olah. Deconvolution and checkerboard artifacts. http://distill.pub/2016/deconv-checkerboard/, 2016.   
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. CoRR, abs/1511.06434, 2015. URL http:// arxiv.org/abs/1511.06434.   
+Bharath Ramsundar, Steven Kearnes, Patrick Riley, Dale Webster, David Konerding, and Vijay Pande. Massively multitask networks for drug discovery. In Proceedings of The 33rd International Conference on Machine Learning, 2016.   
+Scott Reed, Zeynep Akata, Santosh Mohan, Samuel Tenka, Bernt Schiele, and Honglak Lee. Learning what and where to draw. arXiv preprint arXiv:1610.02454, 2016a.   
+Scott Reed, Zeynep Akata, Xinchen Yan, Lajanugen Logeswaran, Bernt Schiele, and Honglak Lee. Generative adversarial text-to-image synthesis. In Proceedings of The 33rd International Conference on Machine Learning, 2016b.   
+D. Rezende and S. Mohamed. Variational Inference with Normalizing Flows. ArXiv e-prints, May 2015.   
+D. Rezende, S. Mohamed, and D. Wierstra. Stochastic Backpropagation and Approximate Inference in Deep Generative Models. ArXiv e-prints, January 2014.   
+Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. CoRR, abs/1505.04597, 2015. URL http://arxiv.org/abs/ 1505.04597.   
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115(3):211–252, 2015. doi: 10.1007/s11263-015-0816-y.   
+T. Salimans, I. Goodfellow, W. Zaremba, V. Cheung, A. Radford, and X. Chen. Improved Techniques for Training GANs. ArXiv e-prints, June 2016.   
+Eero Simoncelli and Bruno Olshausen. Natural image statistics and neural representation. Annual Review of Neuroscience, 24:1193–1216, 2001.   
+J. T. Springenberg. Unsupervised and Semi-supervised Learning with Categorical Generative Adversarial Networks. ArXiv e-prints, November 2015.   
+Ilya Sutskever, Oriol Vinyals, and Le Quoc V. Sequence to sequence learning with neural networks. In Neural Information Processing Systems, 2014.   
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott E. Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. CoRR, abs/1409.4842, 2014. URL http://arxiv.org/abs/1409.4842.   
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. CoRR, abs/1512.00567, 2015. URL http://arxiv.org/abs/1512.00567.   
+L. Theis, A. van den Oord, and M. Bethge. A note on the evaluation of generative models. ArXiv e-prints, November 2015.   
+George Toderici, Damien Vincent, Nick Johnston, Sung Jin Hwang, David Minnen, Joel Shor, and Michele Covell. Full resolution image compression with recurrent neural networks. CoRR, abs/1608.05148, 2016. URL http://arxiv.org/abs/1608.05148.   
+M. Uehara, I. Sato, M. Suzuki, K. Nakayama, and Y. Matsuo. Generative Adversarial Nets from a Density Ratio Estimation Perspective. ArXiv e-prints, October 2016.
+
+Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. ¨ CoRR, abs/1601.06759, 2016a. URL http://arxiv.org/abs/1601.06759.
+
+Aaron van den Oord, Nal Kalchbrenner, Oriol Vinyals, Lasse Espeholt, Alex Graves, and Koray ¨ Kavukcuoglu. Conditional image generation with pixelcnn decoders. CoRR, abs/1606.05328, 2016b. URL http://arxiv.org/abs/1606.05328.
+
+Zhou Wang, Alan C Bovik, Hamid R Sheikh, and Eero P Simoncelli. Image quality assessment: from error visibility to structural similarity. IEEE transactions on image processing, 13(4):600– 612, 2004a.
+
+Zhou Wang, Eero P Simoncelli, and Alan C Bovik. Multiscale structural similarity for image quality assessment. In Signals, Systems and Computers, 2004. Conference Record of the Thirty-Seventh Asilomar Conference on, volume 2, pp. 1398–1402. Ieee, 2004b.
+
+A HYPERPARAMETERS   
+Table 1: Model hyperparameters. A Soft-Sigmoid refers to an operation over $K + 1$ output units where we apply a Softmax activation to $K$ of the units and a Sigmoid activation to the remaining unit. We also use activation noise in the discriminator as suggested in Salimans et al. (2016).   
+
+<table><tr><td>Operation</td><td>Kernel</td><td></td><td>Strides</td><td>Feature maps</td><td>BN?</td><td>Dropout</td><td>Nonlinearity</td></tr><tr><td>Gx(z)-110 ×1 ×1 input</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>Linear</td><td>N/A</td><td>N/A</td><td>768</td><td></td><td>0.0</td><td>ReLU</td></tr><tr><td>Transposed Convolution</td><td></td><td>5×5</td><td>2×2</td><td>384</td><td></td><td>0.0</td><td>ReLU</td></tr><tr><td>Transposed Convolution</td><td></td><td>5×5</td><td>2×2</td><td>256</td><td>×√&lt;√</td><td>0.0</td><td>ReLU</td></tr><tr><td>Transposed Convolution</td><td></td><td>5×5</td><td>2×2</td><td>192</td><td></td><td>0.0</td><td>ReLU</td></tr><tr><td>Transposed Convolution</td><td></td><td>5×5</td><td>2×2</td><td>3</td><td>×</td><td>0.0</td><td>Tanh</td></tr><tr><td>D(x)-128 ×3 × 3 input</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>Convolution</td><td>3×3</td><td>2×2</td><td>16</td><td>×</td><td>0.5</td><td>Leaky ReLU</td></tr><tr><td></td><td>Convolution</td><td>3×3</td><td>1×1</td><td>32</td><td>&gt;&gt;&gt;&gt;</td><td>0.5</td><td>Leaky ReLU</td></tr><tr><td></td><td>Convolution</td><td>3×3</td><td>2×2</td><td>64</td><td></td><td>0.5</td><td>Leaky ReLU</td></tr><tr><td></td><td>Convolution</td><td>3×3</td><td>1×1</td><td>128</td><td></td><td>0.5</td><td>Leaky ReLU</td></tr><tr><td></td><td>Convolution</td><td>3×3</td><td>2×2</td><td>256</td><td></td><td>0.5</td><td>Leaky ReLU</td></tr><tr><td></td><td>Convolution</td><td>3×3</td><td>1×1</td><td>512</td><td>√</td><td>0.5</td><td>Leaky ReLU</td></tr><tr><td></td><td>Linear</td><td>N/A</td><td>N/A</td><td>11</td><td>×</td><td>0.0</td><td>Soft-Sigmoid</td></tr><tr><td></td><td>Optimizer</td><td>Adam(α = 0.0002,β1 =0.5,β2= 10-3)</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>Batch size 100</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>Iterations</td><td>50000</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td>0.2</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Leaky ReLU slope Weight,bias initialization</td><td></td><td></td><td></td><td>Isotropic gaussian (μ = O,σ = 0.02), Constant(O)</td><td></td><td></td><td></td></tr></table>
+
+Class conditional image synthesis affords the opportunity to divide up a dataset based on image label. In our final model we divide 1000 ImageNet classes across 100 AC-GAN models. In this section we describe early experiments that highlight the benefit of cutting down the diversity of classes for training an AC-GAN. We employed an ordering of the labels and divided it into contiguous groups of 10. This ordering can be seen in the following section, where we display samples from all 1000 classes. Two aspects of the split merit discussion: the number of classes per split and the intra-split diversity.
+
+We find that training a fixed model on more classes harms the model’s ability to produce compelling samples (Figure 9). Performance on larger splits can be improved by giving the model more parameters. However, using a small split is not sufficient to achieve good performance. We were unable to train a GAN (Goodfellow et al., 2014) to converge reliably even for a split size of 1.
+
+![](images/e3069887d03fd9025f36454200575158f52bf8d153f430c0e8cf8b2c2c82fe6d.jpg)  
+Figure 9: Mean pairwise MS-SSIM values for 10 ImageNet classes plotted against the number of ImageNet classes used during training. We fix everything except the number of classes trained on, using values from 10 to 100. We only report the MS-SSIM values for the first 10 classes to keep the scores comparable. MS-SSIM quickly goes above 0.25 (the red line) as the class count increases. These scores were computed using 9 random restarts per class count, using the same number of training steps for each model.
+
+This raises the question of whether it is easier to train a model on a diverse set of classes than on a similar set of classes. We were unable to find conclusive evidence that the selection of classes in a split significantly affects sample quality.
+
+C SAMPLES FROM ALL 1000 IMAGENET CLASSES
+
+The following is a link to 10 samples from each of the 1000 ImageNet classes: https://goo.gl/photos/8bgHBkCwDEVTXAPaA

parse/train/rJXTf9Bxg/rJXTf9Bxg_content_list.json

@@ -0,0 +1,1052 @@
+[
+    {
+        "type": "text",
+        "text": "CONDITIONAL IMAGE SYNTHESIS WITH AUXILIARY CLASSIFIER GANS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Augustus Odena∗, Christopher Olah & Jonathon Shlens Google Brain {augustusodena,colah,shlens}@google.com ",
+        "bbox": [
+            183,
+            170,
+            570,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Synthesizing high resolution photorealistic images has been a long-standing challenge in machine learning. In this paper we introduce new methods for the improved training of generative adversarial networks (GANs) for image synthesis. We construct a variant of GANs employing label conditioning that results in $1 2 8 \\times 1 2 8$ resolution image samples exhibiting global coherence. We expand on previous work for image quality assessment to provide two new analyses for assessing the discriminability and diversity of samples from class-conditional image synthesis models. These analyses demonstrate that high resolution samples provide class information not present in low resolution samples. Across 1000 ImageNet classes, $1 2 8 \\times 1 2 8$ samples are more than twice as discriminable as artificially resized $3 2 \\times 3 2$ samples. In addition, $8 4 . 7 \\%$ of the classes have samples exhibiting diversity comparable to real ImageNet data. ",
+        "bbox": [
+            233,
+            281,
+            764,
+            448
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            477,
+            334,
+            492
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Characterizing the structure of natural images has been a rich research endeavor. Natural images obey intrinsic invariances and exhibit multi-scale statistical structures that have historically been difficult to quantify (Simoncelli & Olshausen, 2001). Recent advances in machine learning offer an opportunity to substantially improve the quality of image models. Improved image models advance the state-of-the-art in image denoising (Balle et al., 2015), compression (Toderici et al., ´ 2016), in-painting (van den Oord et al., 2016a), and super-resolution (Ledig et al., 2016). Better models of natural images also improve performance in semi-supervised learning tasks (Kingma et al., 2014; Springenberg, 2015; Odena, 2016; Salimans et al., 2016) and reinforcement learning problems (Blundell et al., 2016). ",
+        "bbox": [
+            174,
+            510,
+            825,
+            633
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One method for understanding natural image statistics is to build a system that synthesizes images de novo. There are several promising approaches for building image synthesis models. Variational autoencoders (VAEs) maximize a variational lower bound on the log-likelihood of the training data (Kingma & Welling, 2013; Rezende et al., 2014). VAEs are straightforward to train but introduce potentially restrictive assumptions about the approximate posterior distribution (but see Rezende & Mohamed (2015); Kingma et al. (2016)). Autoregressive models dispense with latent variables and directly model the conditional distribution over pixels (van den Oord et al., 2016a;b). These models produce convincing samples but are costly to sample from and do not provide a latent representation. Invertible density estimators transform latent variables directly using a series of parameterized functions constrained to be invertible (Dinh et al., 2016). This technique allows for exact log-likelihood computation and exact inference, but the invertibility constraint is restrictive. ",
+        "bbox": [
+            174,
+            641,
+            825,
+            794
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative adversarial networks (GANs) offer a distinct and promising approach that focuses on a game-theoretic formulation for training an image synthesis model (Goodfellow et al., 2014). Recent work has shown that GANs can produce convincing image samples on datasets with low variability and low resolution (Denton et al., 2015; Radford et al., 2015). However, GANs struggle to generate globally coherent, high resolution samples - particularly from datasets with high variability. Moreover, a theoretical understanding of GANs is an on-going research topic (Uehara et al., 2016; Mohamed & Lakshminarayanan, 2016). ",
+        "bbox": [
+            174,
+            801,
+            823,
+            898
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/6c54ff79e795f9c8c06ba6f5fddd92ded1c68470b9b4689df4c6f2fe2425a2ae.jpg",
+        "image_caption": [
+            "Figure 1: $1 2 8 \\times 1 2 8$ resolution samples from 5 classes taken from an AC-GAN trained on the ImageNet dataset. Note that the classes shown have been selected to highlight the success of the model and are not representative. Samples from all ImageNet classes are in the Appendix. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            99,
+            828,
+            251
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work we demonstrate that that adding more structure to the GAN latent space along with a specialized cost function results in higher quality samples. We exhibit $1 2 8 \\times 1 2 8$ pixel samples from all classes of the ImageNet dataset (Russakovsky et al., 2015) with increased global coherence (Figure 1). Importantly, we demonstrate quantitatively that our high resolution samples are not just naive resizings of low resolution samples. In particular, downsampling our $1 2 8 \\times 1 2 8$ samples to $3 2 \\times 3 2$ leads to a $50 \\%$ decrease in visual discriminability. We also introduce a new metric for assessing the variability across image samples and employ this metric to demonstrate that our synthesized images exhibit diversity comparable to training data for a large fraction $( 8 4 . 7 \\% )$ o f ImageNet classes. ",
+        "bbox": [
+            173,
+            342,
+            825,
+            467
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            503,
+            326,
+            518
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A generative adversarial network (GAN) consists of two neural networks trained in opposition to one another. The generator $G$ takes as input a random noise vector $z$ and outputs an image $X _ { f a k e } =$ $G ( z )$ . The discriminator $D$ receives as input either a training image or a synthesized image from the generator and outputs a probability distribution $P ( S \\mid X ) { \\bar { = } } D ( { \\bar { X } } )$ over possible image sources. The discriminator is trained to maximize the log-likelihood it assigns to the correct source: ",
+        "bbox": [
+            174,
+            544,
+            825,
+            614
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0e733157b57cecbca286d23849be013526af37a77b1dc91272de7615039d934f.jpg",
+        "text": "$$\nL = E [ \\log P ( S = r e a l \\mid X _ { r e a l } ) ] + E [ \\log P ( S = f a k e \\mid X _ { f a k e } ) ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            635,
+            717,
+            652
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The generator is trained to minimize that same quantity. ",
+        "bbox": [
+            174,
+            672,
+            540,
+            688
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The basic GAN framework can be augmented using side information. One strategy is to supply both the generator and discriminator with class labels in order to produce class conditional samples (Mirza & Osindero, 2014). Class conditional synthesis can significantly improve the quality of generated samples (van den Oord et al., 2016b). Richer side information such as image captions and bounding box localizations may improve sample quality further (Reed et al., 2016a;b). ",
+        "bbox": [
+            174,
+            694,
+            825,
+            763
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Instead of feeding side information to the discriminator, one can task the discriminator with reconstructing side information. This is done by modifying the discriminator to contain an auxiliary decoder network1 that outputs the class label for the training data (Odena, 2016; Salimans et al., 2016) or a subset of the latent variables from which the samples are generated (Chen et al., 2016). Forcing a model to perform additional tasks is known to improve performance on the original task (e.g. Sutskever et al. (2014); Szegedy et al. (2014); Ramsundar et al. (2016)). In addition, an auxiliary decoder could leverage pre-trained discriminators (e.g. image classifiers) for further improving the synthesized images (Nguyen et al., 2016). Motivated by these considerations, we introduce a model that combines both strategies for leveraging side information. That is, the model proposed below is class conditional, but with an auxiliary decoder that is tasked with reconstructing class labels. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/2c8e4b75bbef0abbd48b3621fe4c58406b2eb46d2aa4772586d617c0e61a3b9a.jpg",
+        "image_caption": [
+            "Figure 2: A comparison of several GAN architectures with the proposed AC-GAN architecture. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            813,
+            303
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 AC-GANS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            354,
+            297,
+            371
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose a variant of the GAN architecture which we call an auxiliary classifier GAN (or ACGAN - see Figure 2). In the AC-GAN, every generated sample has a corresponding class label, $c \\sim$ $p _ { c }$ in addition to the noise $z$ . $G$ uses both to generate images $X _ { f a k e } = G ( c , z )$ . The discriminator gives both a probability distribution over sources and a probability distribution over the class labels, $P ( S \\mid X )$ , $P ( C \\mid X ) = D ( X )$ . The objective function has two parts: the log-likelihood of the correct source, $L _ { S }$ , and the log-likelihood of the correct class, $L _ { C }$ . ",
+        "bbox": [
+            173,
+            386,
+            825,
+            469
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/76c44bfa50511f657e8c1ffd9d163471abd6534d89b554cf115383a790da7208.jpg",
+        "text": "$$\n\\begin{array} { c } { { L _ { S } = E [ \\log P ( S = r e a l \\mid X _ { r e a l } ) ] + E [ \\log P ( S = f a k e \\mid X _ { f a k e } ) ] } } \\\\ { { L _ { C } = E [ \\log P ( C = c \\mid X _ { r e a l } ) ] + E [ \\log P ( C = c \\mid X _ { f a k e } ) ] } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            488,
+            723,
+            525
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$D$ is trained to maximize $L _ { S } + L _ { C }$ while $G$ is trained to maximize $L _ { C } - L _ { S }$ . AC-GANs learn a representation for $z$ that is independent of class label (e.g. Kingma et al. (2014)). ",
+        "bbox": [
+            173,
+            531,
+            823,
+            560
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Early experiments demonstrated that increasing the number of classes trained on while holding the model fixed decreased the quality of the model outputs (Appendix B). The structure of the ACGAN model permits separating large datasets into subsets by class and training a generator and discriminator for each subset. We exploit this property in our experiments to train across the entire ImageNet data set. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            636
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            656,
+            281,
+            671
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We train several AC-GAN models on the ImageNet data set (Russakovsky et al., 2015). Broadly speaking, the architecture of the generator $G$ is a series of ‘deconvolution’ layers that transform the noise $z$ and class $c$ into an image (Odena et al., 2016). We train two variants of the model architecture for generating images at $1 2 8 \\times 1 2 8$ and $6 4 \\times 6 4$ spatial resolutions. The discriminator $D$ is a deep convolutional neural network with a Leaky ReLU nonlinearity (Maas et al., 2013). See Appendix A for more details. As mentioned earlier, we find that reducing the variability introduced by all 1000 classes of ImageNet significantly improves the quality of training. We train 100 AC-GAN models – each on images from just 10 classes – for 50000 mini-batches of size 100. ",
+        "bbox": [
+            173,
+            686,
+            825,
+            797
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Evaluating the quality of image synthesis models is challenging due to the variety of probabilistic criteria (Theis et al., 2015) and the lack of a perceptually meaningful image similarity metric. Nonetheless, in subsequent sections we attempt to measure the quality of the AC-GAN by building several ad-hoc measures for image sample discriminability and diversity. Our hope is that this work might provide quantitative measures that may be used to aid training and subsequent development of image synthesis models. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/d56f4dbab4265245abb44ef2c0bebe10e50f195c62fca3d365953998b4cd05dc.jpg",
+        "image_caption": [
+            "Figure 3: Generating high resolution images improves discriminability. Top: Training data and synthesized images from the zebra class resized to a lower spatial resolution (indicated above) and subsequently artificially resized to the original resolution. Inception accuracy is shown below the corresponding images. Bottom Left: Summary of accuracies across varying spatial resolutions for training data and image samples from $6 4 \\times 6 4$ and $1 2 8 \\times 1 2 8$ models. Error bar measures standard deviation across 10 subsets of images. Dashed lines highlight the accuracy at the output spatial resolution of the model. The training data (clipped) achieves accuracies of $24 \\%$ , $54 \\%$ , $81 \\%$ and $81 \\%$ at resolutions of 32, 64, 128, and 256 respectively. Bottom Right: Comparison of accuracy scores at $1 2 8 \\times 1 2 8$ and $3 2 \\times 3 2$ spatial resolutions $x$ and $_ y$ axis, respectively). Each point represents an ImageNet class. $8 4 . 4 \\%$ of the classes are below the line of equality. The green dot corresponds to the zebra class. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            116,
+            808,
+            482
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 GENERATING HIGH RESOLUTION IMAGES IMPROVES DISCRIMINABILITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            661,
+            718,
+            675
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Building a class-conditional image synthesis model necessitates measuring the extent to which synthesized images appear to belong to the intended class. In particular, we would like to know that a high resolution sample is not just a naive resizing of a low resolution sample. Consider a simple experiment: pretend there exists a model that synthesizes $3 2 \\times 3 2$ images. One can trivially increase the resolution of synthesized images by performing bilinear interpolation. This would yield higher resolution images, but these images would just be blurry versions of the low resolution images that are not discriminable. Hence, the goal of an image synthesis model is not simply to produce high resolution images, but to produce high resolution images that are more discriminable than low resolution images. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            811
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To measure discriminability, we feed synthesized images to a pre-trained Inception network (Szegedy et al., 2015) and report the fraction of the samples for which the Inception network assigned the correct label2. We calculate this accuracy measure on a series of real and synthesized images which have had their spatial resolution artificially decreased by bilinear interpolation (Figure 3, top panels). Note that as the spatial resolution is decreased, the accuracy decreases - indicating that resulting images contain less class information (Figure 3, scores below top panels). We summarized this finding across all 1000 ImageNet classes for the ImageNet training data (black), a $1 2 8 \\times 1 2 8$ resolution AC-GAN (red) and a $6 4 \\times 6 4$ resolution AC-GAN (blue) in Figure 3 (bottom, left). The black curve (clipped) provides an upper-bound on the discriminability of real images. ",
+        "bbox": [
+            174,
+            819,
+            823,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The goal of this analysis is to show that synthesizing higher resolution images leads to increased discriminability. The $1 2 8 \\times 1 2 8$ model achieves an accuracy of $1 0 . 1 \\% \\pm 2 . 0 \\%$ versus $7 . 0 \\% \\pm 2 . 0 \\%$ with samples resized to $6 4 \\times 6 4$ and $5 . 0 \\% \\pm 2 . 0 \\%$ with samples resized to $3 2 \\times 3 2$ . In other words, downsizing the outputs of the AC-GAN to $3 2 \\times 3 2$ and $6 4 \\times 6 4$ decreases visual discriminability by $50 \\%$ and $38 \\%$ respectively. Furthermore, $8 4 . 4 \\%$ of the ImageNet classes have higher accuracy at $1 2 8 \\times 1 2 8$ than at $3 2 \\times 3 2$ (Figure 3, bottom left). ",
+        "bbox": [
+            174,
+            180,
+            823,
+            263
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We performed the same analysis on an AC-GAN trained to $6 4 \\times 6 4$ spatial resolution. This model achieved less discriminability than a $1 2 8 \\times 1 2 8$ AC-GAN model. Accuracies from the $6 4 \\times 6 4$ model plateau at a $6 4 \\times 6 4$ spatial resolution consistent with previous results. Finally, the $6 4 \\times 6 4$ resolution model achieves less discriminability at 64 spatial resolution than the $1 2 8 \\times 1 2 8$ model. ",
+        "bbox": [
+            174,
+            271,
+            825,
+            327
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 MEASURING THE DIVERSITY OF GENERATED IMAGES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            344,
+            588,
+            358
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "An image synthesis model is not very interesting if it only outputs one image. Indeed, a well-known failure mode of GANs is that the generator will collapse and output a single prototype that maximally fools the discriminator (Goodfellow et al., 2014; Salimans et al., 2016). A class-conditional model of images is not very interesting if it only outputs one image per class. The Inception accuracy can not measure whether a model has collapsed. A model that simply memorized one example from each ImageNet class would do very well by this metric. Thus, we seek a complementary metric to explicitly evaluate the intra-class diversity of samples generated by the AC-GAN. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            468
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Several methods exist for quantitatively evaluating image similarity by attempting to predict human perceptual similarity judgements. The most successful of these is multi-scale structural similarity (MS-SSIM) (Wang et al., 2004b; Ma et al., 2016). MS-SSIM is a multi-scale variant of a wellcharacterized perceptual similarity metric that attempts to discount aspects of an image that are not important for human perception (Wang et al., 2004a). MS-SSIM values range between 0.0 and 1.0; higher MS-SSIM values correspond to perceptually more similar images. As a proxy for image diversity, we measure the MS-SSIM scores between randomly chosen pairs of images within a given class. Samples from classes that have higher diversity result in lower mean MS-SSIM scores (Figure 4, left columns); samples from classes with lower diversity have higher mean MS-SSIM scores (Figure 4, right columns). Training images from the ImageNet training data contain a variety of mean MS-SSIM scores across the classes indicating the variability of image diversity in ImageNet classes (Figure 5, left panel, x-axis). Note that the highest mean MS-SSIM score (indicating the least variability) is 0.25 for the training data. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            655
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We calculate the mean MS-SSIM score for all 1000 ImageNet classes generated by the AC-GAN model. We track this value during training to identify whether the generator has collapsed (Figure 5, right panel, red curve). We also employ this metric to compare the diversity of the training images to the samples from the GAN model after training has completed. Figure 5 (left) plots the mean MS-SSIM values for image samples and training data broken up by class. The blue line is the line of equality. Out of the 1000 classes, we find that 847 have mean sample MS-SSIM scores below that of the maximum MS-SSIM for the training data. In other words, $8 4 . 7 \\%$ of classes have sample variability that exceeds that of the least variable class from the ImageNet training data. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            773
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": ".3 GENERATED IMAGES ARE BOTH DIVERSE AND DISCRIMINABLE ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            791,
+            650,
+            806
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We have presented quantitative metrics demonstrating that AC-GAN samples may be diverse and discriminable but we have yet to examine how these metrics interact. Figure 6 shows the joint distribution of Inception accuracies and MS-SSIM scores across all classes. Inception accuracy and MS-SSIM are anti-correlated $( r ^ { 2 } = - 0 . 1 6 )$ . In fact, $74 \\%$ of the classes with low diversity (MS$\\mathrm { S S I M } \\geq 0 . 2 5 )$ ) contain Inception accuracies $\\leq 1 \\%$ . These results suggest that GANs that drop modes are most likely to produce low quality images. Conversely, $78 \\%$ of classes with high diversity (MS$\\mathrm { S S I M } < 0 . 2 5 )$ ) have Inception accuracies that exceed $1 \\%$ . In comparison, the Inception-v3 model achieves $78 . 8 \\%$ accuracy on average across all 1000 classes (Szegedy et al., 2015). A fraction of the classes AC-GAN samples reach this level of accuracy. This indicates opportunity for future image synthesis models. ",
+        "bbox": [
+            174,
+            818,
+            823,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/d1c09fc189f805c2f92ce95cea6c018d4411f17fa6c643c606281246a6c2c832.jpg",
+        "image_caption": [
+            "Figure 4: Examples of different MS-SSIM scores. The top and bottom rows contain AC-GAN samples and training data, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            823,
+            363
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/e90290666c512929542137b05c935ee1c50f9d623f412cfcb51c43a09bfbb4d9.jpg",
+        "image_caption": [
+            "Figure 5: (Left) Comparison of the mean MS-SSIM scores between pairs of images within a given class for ImageNet training data and samples from the GAN (blue line is equality). The horizontal red line marks the maximum MS-SSIM value across all ImageNet classes. Each point is an individual class. The mean standard deviation of scores across the training data and the samples was 0.06 and 0.08 respectively. Scores below the red line $8 4 . 7 \\%$ of classes) arise from classes where GAN training largely succeeded. (Right) Intra-class MS-SSIM for selected ImageNet classes throughout a training run. Classes that successfully train tend to have decreasing mean MS-SSIM scores, to a point. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            430,
+            792,
+            603
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            734,
+            825,
+            804
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.4 COMPARISON TO PREVIOUS RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            827,
+            475,
+            840
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Previous quantitative results for image synthesis models trained on ImageNet are reported in terms of log-likelihood (van den Oord et al., 2016a;b). Log-likelihood is a coarse and potentially inaccurate measure of sample quality (Theis et al., 2015). Addditionally, log-likelihood is intractable to compute for GANs. Instead we compare with previous state-of-the-art results on CIFAR-10 using a lower spatial resolution $( 3 2 \\times 3 2 )$ . Following the procedure in Salimans et al. (2016), we compute the Inception score3 for 50000 samples from an AC-GAN with resolution $( 3 2 \\times 3 2 )$ , split into 10 groups at random. We also compute the Inception score for 25000 extra samples, split into 5 groups at random. We select the best model based on the first score and report the second score. Performing a grid search across 27 hyperparameter configurations, we are able to achieve a score of $8 . 2 5 \\pm 0 . 0 \\bar { 7 }$ compared to state of the art $8 . 0 9 \\pm 0 . 0 7$ (Salimans et al., 2016). Moreover, we accomplish this without employing any of the new techniques introduced in that work (i.e. virtual batch normalization, minibatch discrimination, and label smoothing). This provides additional evidence that AC-GANs are effective even without the benefit of class splitting (Appendix B). ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/c7340ee3cd4c3d0cd70374c54c149138743e0f6739d04163cc3f5eff95c62882.jpg",
+        "image_caption": [
+            "Figure 6: Inception accuracy vs MS-SSIM for all 1000 ImageNet classes $( r ^ { 2 } = - 0 . 1 6 )$ . Samples from ACGAN models do not achieve variability at the expense of discriminability. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            351,
+            114,
+            630,
+            285
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            338,
+            825,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.5 SEARCHING FOR SIGNATURES OF OVERFITTING ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            467,
+            542,
+            481
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "One possibility that must be investigated is that the AC-GAN has overfit on the training data. As a first check that the network does not memorize the training data, we identify the nearest neighbors of image samples in the training data measured by L1 distance in pixel space (Figure 7). The nearest neighbors from the training data do not resemble the corresponding samples. This provides evidence that the AC-GAN is not merely memorizing the training data. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            563
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/120e5224c6b0bd27e21d9da5672a1e4a777b36a22e113a7da9c570cebc7526fc.jpg",
+        "image_caption": [
+            "Figure 7: Nearest neighbor analysis. (Left) Samples from a single ImageNet class. (Right) Corresponding nearest neighbor (L1 distance) in training data for each sample. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            575,
+            820,
+            670
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A more sophisticated method for understanding the degree of overfitting in a model is to explore that model’s latent space by interpolation. In an overfit model one might observe discrete transitions in the interpolated images and regions in latent space that do not correspond to meaningful images (Bengio et al., 2012; Radford et al., 2015; Dinh et al., 2016). Figure 8 (left) highlights interpolations in the latent space between several image samples. Notably, the generator learned that certain combinations of dimensions correspond to semantically meaningful features (e.g. size of the arch, length of a bird’s beak) and there are no discrete transitions or ‘holes’ in the latent space. A second method for exploring the latent space of the AC-GAN is to exploit the structure of the model. The AC-GAN factorizes its representation into class information and a class-independent latent representation $z$ . Sampling the AC-GAN with $z$ fixed but altering the class label corresponds to generating samples with the same ‘style’ across multiple classes (Kingma et al., 2014). Figure 8 (right) shows samples from 8 bird classes. Elements of the same row have the same $z$ . Although the class changes for each column, elements of the global structure (e.g. position, layout, background) are preserved, indicating that AC-GAN can represent certain types of ‘compositionality’. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/d60141da6931af7de4eef8da76d32149f4da27466edabbb461f0317e02590fe0.jpg",
+        "image_caption": [
+            "Figure 8: (Left) Latent space interpolations for selected ImageNet classes. Left-most and right-columns show three pairs of image samples - each pair from a distinct class. Intermediate columns highlight linear interpolations in the latent space between these three pairs of images. (Right) Class-independent information contains global structure about the synthesized image. Each column is a distinct bird class while each row corresponds to a fixed latent code $z$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            159,
+            820,
+            252
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            356,
+            310,
+            372
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This work introduced the AC-GAN architecture and demonstrated that AC-GANs can generate globally coherent ImageNet samples. We provided a new quantitative metric for image discriminability as a function of spatial resolution. Using this metric we demonstrated that our samples are more discriminable than those from a model that generates lower resolution images and performs a naive resize operation. We also analyzed the diversity of our samples with respect to the training data and provided some evidence that the image samples from the majority of classes are comparable in diversity to ImageNet training data. We hope that these metrics might provide quantitative measures of sample quality for evaluating and improving future image synthesis models. ",
+        "bbox": [
+            173,
+            387,
+            825,
+            500
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Several directions exist for building upon this work. Much work needs to be done to improve the visual discriminability of the $1 2 8 \\times 1 2 8$ resolution model. Although some synthesized image classes exhibit high Inception accuracies, the average Inception accuracy of the model $( 1 0 . 1 \\% \\pm 2 . 0 \\% )$ is still far below real training data at $81 \\%$ . One immediate opportunity for addressing this is to augment the discriminator with a pre-trained model to perform additional supervised tasks (e.g. image segmentation, Ronneberger et al. (2015)). Such techniques might allow for the synthesis of even higher resolution images with global coherence and meaningful visual content. ",
+        "bbox": [
+            174,
+            506,
+            825,
+            603
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Improving the robustness and reliability of training a GAN is an ongoing research topic. Only $8 4 . 7 \\%$ of the ImageNet classes avoided mode dropping and exhibited a diversity comparable to real training data. Training stability was vastly aided by dividing up 1000 ImageNet classes across 100 AC-GAN models. Building a single unified model that could generate diverse samples from all 1000 classes would be an important step forward. ",
+        "bbox": [
+            174,
+            611,
+            823,
+            679
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Image synthesis models provide a unique opportunity for performing semi-supervised learning. Namely, these models build a rich prior over natural image statistics that can be leveraged by classifiers to improve predictions on datasets for which few labels exist. The AC-GAN model can perform semi-supervised learning by simply ignoring the component of the loss arising from class labels when a label is unavailable for a given training image. Interestingly, prior work suggests that achieving good sample quality might be independent of success in semi-supervised learning (Salimans et al., 2016). ",
+        "bbox": [
+            174,
+            688,
+            825,
+            784
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            801,
+            326,
+            814
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We thank the developers of TensorFlow (Abadi et al., 2016). We thank Luke Metz and Vincent Dumoulin for extensive and helpful comments on drafts. We also thank Ben Poole, Sam Schoenholz, Barret Zoph, Mart´ın Abadi, Manjunath Kudlur and Jascha Sohl-Dickstein for helpful discussions. ",
+        "bbox": [
+            176,
+            824,
+            825,
+            866
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Abadi et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. CoRR, abs/1603.04467, 2016. URL http://arxiv.org/abs/1603.04467. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Johannes Balle, Valero Laparra, and Eero P. Simoncelli. Density modeling of images using a gen- ´ eralized normalization transformation. CoRR, abs/1511.06281, 2015. URL http://arxiv. org/abs/1511.06281. ",
+        "bbox": [
+            173,
+            162,
+            820,
+            205
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Gregoire Mesnil, Yann Dauphin, and Salah Rifai. Better mixing via deep represen- ´ tations. CoRR, abs/1207.4404, 2012. URL http://arxiv.org/abs/1207.4404. ",
+        "bbox": [
+            171,
+            213,
+            823,
+            243
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "C. Blundell, B. Uria, A. Pritzel, Y. Li, A. Ruderman, J. Z Leibo, J. Rae, D. Wierstra, and D. Hassabis. Model-Free Episodic Control. ArXiv e-prints, June 2016. ",
+        "bbox": [
+            171,
+            251,
+            823,
+            281
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "X. Chen, Y. Duan, R. Houthooft, J. Schulman, I. Sutskever, and P. Abbeel. InfoGAN: Interpretable Representation Learning by Information Maximizing Generative Adversarial Nets. ArXiv eprints, June 2016. ",
+        "bbox": [
+            173,
+            289,
+            825,
+            332
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Emily L. Denton, Soumith Chintala, Arthur Szlam, and Robert Fergus. Deep generative image models using a laplacian pyramid of adversarial networks. CoRR, abs/1506.05751, 2015. URL http://arxiv.org/abs/1506.05751. ",
+        "bbox": [
+            173,
+            339,
+            823,
+            383
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using real NVP. CoRR, abs/1605.08803, 2016. URL http://arxiv.org/abs/1605.08803. ",
+        "bbox": [
+            169,
+            390,
+            823,
+            421
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "J. Donahue, P. Krahenb ¨ uhl, and T. Darrell. Adversarial Feature Learning. ¨ ArXiv e-prints, May 2016. ",
+        "bbox": [
+            173,
+            428,
+            823,
+            444
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "V. Dumoulin, I. Belghazi, B. Poole, A. Lamb, M. Arjovsky, O. Mastropietro, and A. Courville. Adversarially Learned Inference. ArXiv e-prints, June 2016. ",
+        "bbox": [
+            169,
+            452,
+            821,
+            482
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative Adversarial Networks. ArXiv e-prints, June 2014. ",
+        "bbox": [
+            171,
+            489,
+            823,
+            518
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "D. P Kingma and M. Welling. Auto-Encoding Variational Bayes. ArXiv e-prints, December 2013. ",
+        "bbox": [
+            171,
+            526,
+            815,
+            542
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma, Danilo Jimenez Rezende, Shakir Mohamed, and Max Welling. Semisupervised learning with deep generative models. CoRR, abs/1406.5298, 2014. URL http: //arxiv.org/abs/1406.5298. ",
+        "bbox": [
+            173,
+            550,
+            820,
+            593
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma, Tim Salimans, and Max Welling. Improving variational inference with inverse autoregressive flow. CoRR, abs/1606.04934, 2016. URL http://arxiv.org/abs/1606. 04934. ",
+        "bbox": [
+            173,
+            601,
+            823,
+            643
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "C. Ledig, L. Theis, F. Huszar, J. Caballero, A. Aitken, A. Tejani, J. Totz, Z. Wang, and W. Shi. Photo-Realistic Single Image Super-Resolution Using a Generative Adversarial Network. ArXiv e-prints, September 2016. ",
+        "bbox": [
+            176,
+            652,
+            823,
+            695
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kede Ma, Qingbo Wu, Zhou Wang, Zhengfang Duanmu, Hongwei Yong, Hongliang Li, and Lei Zhang. Group mad competition - a new methodology to compare objective image quality models. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2016. ",
+        "bbox": [
+            174,
+            704,
+            823,
+            747
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrew Maas, Awni Hannun, and Andrew Ng. Rectifier nonlinearities improve neural network acoustic models. In Proceedings of The 33rd International Conference on Machine Learning, 2013. ",
+        "bbox": [
+            173,
+            755,
+            823,
+            797
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. CoRR, abs/1411.1784, 2014. URL http://arxiv.org/abs/1411.1784. ",
+        "bbox": [
+            173,
+            806,
+            820,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shakir Mohamed and Balaji Lakshminarayanan. Learning in implicit generative models. arXiv preprint arXiv:1610.03483, 2016. ",
+        "bbox": [
+            173,
+            843,
+            821,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Anh Mai Nguyen, Alexey Dosovitskiy, Jason Yosinski, Thomas Brox, and Jeff Clune. Synthesizing the preferred inputs for neurons in neural networks via deep generator networks. CoRR, abs/1605.09304, 2016. URL http://arxiv.org/abs/1605.09304. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A. Odena. Semi-Supervised Learning with Generative Adversarial Networks. ArXiv e-prints, June 2016.   \nAugustus Odena, Vincent Dumoulin, and Chris Olah. Deconvolution and checkerboard artifacts. http://distill.pub/2016/deconv-checkerboard/, 2016.   \nAlec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. CoRR, abs/1511.06434, 2015. URL http:// arxiv.org/abs/1511.06434.   \nBharath Ramsundar, Steven Kearnes, Patrick Riley, Dale Webster, David Konerding, and Vijay Pande. Massively multitask networks for drug discovery. In Proceedings of The 33rd International Conference on Machine Learning, 2016.   \nScott Reed, Zeynep Akata, Santosh Mohan, Samuel Tenka, Bernt Schiele, and Honglak Lee. Learning what and where to draw. arXiv preprint arXiv:1610.02454, 2016a.   \nScott Reed, Zeynep Akata, Xinchen Yan, Lajanugen Logeswaran, Bernt Schiele, and Honglak Lee. Generative adversarial text-to-image synthesis. In Proceedings of The 33rd International Conference on Machine Learning, 2016b.   \nD. Rezende and S. Mohamed. Variational Inference with Normalizing Flows. ArXiv e-prints, May 2015.   \nD. Rezende, S. Mohamed, and D. Wierstra. Stochastic Backpropagation and Approximate Inference in Deep Generative Models. ArXiv e-prints, January 2014.   \nOlaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. CoRR, abs/1505.04597, 2015. URL http://arxiv.org/abs/ 1505.04597.   \nOlga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115(3):211–252, 2015. doi: 10.1007/s11263-015-0816-y.   \nT. Salimans, I. Goodfellow, W. Zaremba, V. Cheung, A. Radford, and X. Chen. Improved Techniques for Training GANs. ArXiv e-prints, June 2016.   \nEero Simoncelli and Bruno Olshausen. Natural image statistics and neural representation. Annual Review of Neuroscience, 24:1193–1216, 2001.   \nJ. T. Springenberg. Unsupervised and Semi-supervised Learning with Categorical Generative Adversarial Networks. ArXiv e-prints, November 2015.   \nIlya Sutskever, Oriol Vinyals, and Le Quoc V. Sequence to sequence learning with neural networks. In Neural Information Processing Systems, 2014.   \nChristian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott E. Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. CoRR, abs/1409.4842, 2014. URL http://arxiv.org/abs/1409.4842.   \nChristian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. CoRR, abs/1512.00567, 2015. URL http://arxiv.org/abs/1512.00567.   \nL. Theis, A. van den Oord, and M. Bethge. A note on the evaluation of generative models. ArXiv e-prints, November 2015.   \nGeorge Toderici, Damien Vincent, Nick Johnston, Sung Jin Hwang, David Minnen, Joel Shor, and Michele Covell. Full resolution image compression with recurrent neural networks. CoRR, abs/1608.05148, 2016. URL http://arxiv.org/abs/1608.05148.   \nM. Uehara, I. Sato, M. Suzuki, K. Nakayama, and Y. Matsuo. Generative Adversarial Nets from a Density Ratio Estimation Perspective. ArXiv e-prints, October 2016. ",
+        "bbox": [
+            171,
+            63,
+            826,
+            928
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. ¨ CoRR, abs/1601.06759, 2016a. URL http://arxiv.org/abs/1601.06759. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Nal Kalchbrenner, Oriol Vinyals, Lasse Espeholt, Alex Graves, and Koray ¨ Kavukcuoglu. Conditional image generation with pixelcnn decoders. CoRR, abs/1606.05328, 2016b. URL http://arxiv.org/abs/1606.05328. ",
+        "bbox": [
+            178,
+            140,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhou Wang, Alan C Bovik, Hamid R Sheikh, and Eero P Simoncelli. Image quality assessment: from error visibility to structural similarity. IEEE transactions on image processing, 13(4):600– 612, 2004a. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            234
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhou Wang, Eero P Simoncelli, and Alan C Bovik. Multiscale structural similarity for image quality assessment. In Signals, Systems and Computers, 2004. Conference Record of the Thirty-Seventh Asilomar Conference on, volume 2, pp. 1398–1402. Ieee, 2004b. ",
+        "bbox": [
+            173,
+            244,
+            826,
+            286
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/685354496823e38a88f1ae1e3bb20ef16b06a5c44678cc2810026c51a91226ee.jpg",
+        "table_caption": [
+            "A HYPERPARAMETERS ",
+            "Table 1: Model hyperparameters. A Soft-Sigmoid refers to an operation over $K + 1$ output units where we apply a Softmax activation to $K$ of the units and a Sigmoid activation to the remaining unit. We also use activation noise in the discriminator as suggested in Salimans et al. (2016). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Operation</td><td>Kernel</td><td></td><td>Strides</td><td>Feature maps</td><td>BN?</td><td>Dropout</td><td>Nonlinearity</td></tr><tr><td>Gx(z)-110 ×1 ×1 input</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>Linear</td><td>N/A</td><td>N/A</td><td>768</td><td></td><td>0.0</td><td>ReLU</td></tr><tr><td>Transposed Convolution</td><td></td><td>5×5</td><td>2×2</td><td>384</td><td></td><td>0.0</td><td>ReLU</td></tr><tr><td>Transposed Convolution</td><td></td><td>5×5</td><td>2×2</td><td>256</td><td>×√&lt;√</td><td>0.0</td><td>ReLU</td></tr><tr><td>Transposed Convolution</td><td></td><td>5×5</td><td>2×2</td><td>192</td><td></td><td>0.0</td><td>ReLU</td></tr><tr><td>Transposed Convolution</td><td></td><td>5×5</td><td>2×2</td><td>3</td><td>×</td><td>0.0</td><td>Tanh</td></tr><tr><td>D(x)-128 ×3 × 3 input</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>Convolution</td><td>3×3</td><td>2×2</td><td>16</td><td>×</td><td>0.5</td><td>Leaky ReLU</td></tr><tr><td></td><td>Convolution</td><td>3×3</td><td>1×1</td><td>32</td><td>&gt;&gt;&gt;&gt;</td><td>0.5</td><td>Leaky ReLU</td></tr><tr><td></td><td>Convolution</td><td>3×3</td><td>2×2</td><td>64</td><td></td><td>0.5</td><td>Leaky ReLU</td></tr><tr><td></td><td>Convolution</td><td>3×3</td><td>1×1</td><td>128</td><td></td><td>0.5</td><td>Leaky ReLU</td></tr><tr><td></td><td>Convolution</td><td>3×3</td><td>2×2</td><td>256</td><td></td><td>0.5</td><td>Leaky ReLU</td></tr><tr><td></td><td>Convolution</td><td>3×3</td><td>1×1</td><td>512</td><td>√</td><td>0.5</td><td>Leaky ReLU</td></tr><tr><td></td><td>Linear</td><td>N/A</td><td>N/A</td><td>11</td><td>×</td><td>0.0</td><td>Soft-Sigmoid</td></tr><tr><td></td><td>Optimizer</td><td>Adam(α = 0.0002,β1 =0.5,β2= 10-3)</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>Batch size 100</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>Iterations</td><td>50000</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td>0.2</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Leaky ReLU slope Weight,bias initialization</td><td></td><td></td><td></td><td>Isotropic gaussian (μ = O,σ = 0.02), Constant(O)</td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            173,
+            135,
+            820,
+            431
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Class conditional image synthesis affords the opportunity to divide up a dataset based on image label. In our final model we divide 1000 ImageNet classes across 100 AC-GAN models. In this section we describe early experiments that highlight the benefit of cutting down the diversity of classes for training an AC-GAN. We employed an ordering of the labels and divided it into contiguous groups of 10. This ordering can be seen in the following section, where we display samples from all 1000 classes. Two aspects of the split merit discussion: the number of classes per split and the intra-split diversity. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            231
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We find that training a fixed model on more classes harms the model’s ability to produce compelling samples (Figure 9). Performance on larger splits can be improved by giving the model more parameters. However, using a small split is not sufficient to achieve good performance. We were unable to train a GAN (Goodfellow et al., 2014) to converge reliably even for a split size of 1. ",
+        "bbox": [
+            174,
+            238,
+            825,
+            294
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/e3069887d03fd9025f36454200575158f52bf8d153f430c0e8cf8b2c2c82fe6d.jpg",
+        "image_caption": [
+            "Figure 9: Mean pairwise MS-SSIM values for 10 ImageNet classes plotted against the number of ImageNet classes used during training. We fix everything except the number of classes trained on, using values from 10 to 100. We only report the MS-SSIM values for the first 10 classes to keep the scores comparable. MS-SSIM quickly goes above 0.25 (the red line) as the class count increases. These scores were computed using 9 random restarts per class count, using the same number of training steps for each model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            348,
+            321,
+            630,
+            494
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "This raises the question of whether it is easier to train a model on a diverse set of classes than on a similar set of classes. We were unable to find conclusive evidence that the selection of classes in a split significantly affects sample quality. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            628
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C SAMPLES FROM ALL 1000 IMAGENET CLASSES ",
+        "bbox": [
+            173,
+            102,
+            599,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The following is a link to 10 samples from each of the 1000 ImageNet classes: https://goo.gl/photos/8bgHBkCwDEVTXAPaA ",
+        "bbox": [
+            173,
+            133,
+            823,
+            161
+        ],
+        "page_idx": 13
+    }
+]