Datasets:

zai-org
/

RPC-Bench

+# GENERATING MULTIPLE OBJECTS AT SPATIALLY DISTINCT LOCATIONS
+Tobias Hinz, Stefan Heinrich, Stefan Wermter Knowledge Technology, Department of Informatics, Universitat Hamburg ¨ Vogt-Koelln-Str. 30, 22527 Hamburg, Germany https://www.inf.uni-hamburg.de/en/inst/ab/wtm/ {hinz,heinrich,wermter}@informatik.uni-hamburg.de
+# ABSTRACT
+Recent improvements to Generative Adversarial Networks (GANs) have made it possible to generate realistic images in high resolution based on natural language descriptions such as image captions. However, fine-grained control of the image layout, i.e. where in the image specific objects should be located, is still difficult to achieve. We introduce a new approach which allows us to control the location of arbitrarily many objects within an image by adding an object pathway to both the generator and the discriminator. Our approach does not need a detailed semantic layout but only bounding boxes and the respective labels of the desired objects are needed. The object pathway focuses solely on the individual objects and is iteratively applied at the locations specified by the bounding boxes. The global pathway focuses on the image background and the general image layout. We perform experiments on the Multi-MNIST, CLEVR, and the more complex MSCOCO data set. Our experiments show that through the use of the object pathway we can control object locations within images and can model complex scenes with multiple objects at various locations. We further show that the object pathway focuses on the individual objects and learns features relevant for these, while the global pathway focuses on global image characteristics and the image background.
+# 1 INTRODUCTION
+Understanding how to learn powerful representations from complex distributions is the intriguing goal behind adversarial training on image data. While recent advances have enabled us to generate high-resolution images with Generative Adversarial Networks (GANs), currently most GAN models still focus on modeling images that either contain only one centralized object (e.g. faces (CelebA), objects (ImageNet), birds (CUB-200), flowers (Oxford-102), etc.) or on images from one specific domain (e.g. LSUN bedrooms, LSUN churches, etc.). This means that, overall, the variance between images used for training GANs tends to be low (Raj et al., 2017). However, many real-life images contain multiple distinct objects at different locations within the image and with different relations to each other. This is for example visible in the MS-COCO data set (Lin et al., 2014), which consists of images of different objects at different locations within one image. In order to model images with these complex relationships, we need models that can model images containing multiple objects at distinct locations. To achieve this, we need control over what kind of objects are generated (e.g. persons, animals, objects, etc.), the location, and the size of these objects. This is a much more challenging task than generating a single object in the center of an image.
+Current work (Karacan et al., 2016; Johnson et al., 2018; Hong et al., 2018b; Wang et al., 2018) often approaches this challenge by using a semantic layout as additional conditional input. While this can be successful in controlling the image layout and object placement, it also places a high burden on the generating process since a complete scene layout must be obtained first. We propose a model that does not require a full semantic layout, but instead only requires the desired object locations and identities (see Figure 1). One part of our model, called the global pathway, is responsible for generating the general layout of the complete image, while a second path, the object pathway, is used to explicitly generate the features of different objects based on the relevant object label and location.
+The generator gets as input a natural language description of the scene (if existent), the locations and labels of the various objects within the scene, and a random noise vector. The global pathway uses this to create a scene layout encoding which describes high-level features and generates a global feature representation from this. The object pathway generates a feature representation of a given object at a location described by the respective bounding box and is applied iteratively over the scene at the locations specified by the individual bounding boxes. We then concatenate the feature representations of the global and the object pathway and use this to generate the final image.
+The discriminator, which also consists of a global and object pathway, gets as input the image, the bounding boxes and their respective object labels, and the textual description. The global pathway is then applied to the whole image and obtains a feature representation of the global image features. In parallel, the object pathway focuses only on the areas described by the bounding boxes and the respective object labels and obtains feature representations of these specific locations. Again, the outputs of both the global and the object pathway are merged and the discriminator is trained to distinguish between real and generated images.
+In contrast to previous work we do not generate a scene layout of the whole scene but only focus on relevant objects which are placed at the specified locations, while the global consistency of the image is the responsibility of the other part of our model. To summarize our model and contributions: 1) We propose a GAN model that enables us to control the layout of a scene without the use of a scene layout. 2) Through the use of an object pathway which is responsible for learning features of different object categories, we gain control over the identity and location of arbitrarily many objects within a scene. 3) The discriminator judges not only if the image is realistic and aligned to the natural language description, but also whether the specified objects are at the given locations and of the correct object category. 4) We show that the object pathway does indeed learn relevant features for the different objects, while the global pathway focuses on general image features and the background.
+# 2 RELATED WORK
+Having more control over the general image layout can lead to a higher quality of images (Reed et al., 2016a; Hong et al., 2018b) and is also an important requirement for semantic image manipulation (Hong et al., 2018a; Wang et al., 2018). Approaches that try to exert some control over the image layout utilize Generative Adversarial Nets (Goodfellow et al., 2014), Refinement Networks (e.g. Chen & Koltun (2017); Xu et al. (2018a)), recurrent attention-based models (e.g. Mansimov et al. (2016)), autoregressive models (e.g. Reed et al. (2016c)), and even memory networks supplying the image generation process with previously extracted image features (Zhang et al., 2018b).
+One way to exert control over the image layout is by using natural language descriptions of the image, e.g. image captions, as shown by Reed et al. (2016b), Zhang et al. (2018a), Sharma et al. (2018), and $\mathrm { X u }$ et al. (2018b). However, these approaches are trained only with images and their respective captions and it is not possible to specifically control the layout or placement of specific objects within the image. Several approaches suggested using a semantic layout of the image, generated from the image caption, to gain more fine-grained control over the final image. Karacan et al. (2016), Johnson et al. (2018), and Wang et al. (2018) use a scene layout to generate images in which given objects are drawn within their specified segments based on the generated scene layout. Hong et al. (2018b) use the image caption to generate bounding boxes of specific objects within the image and predict the object’s shape within each bounding box. This is further extended by Hong et al. (2018a) by making it possible to manipulate images on a semantic level. While these approaches offer a more detailed control over the image layout they heavily rely on a semantic scene layout for the image generating process, often implying complex preprocessing steps in which the scene layout is constructed.
+The two approaches most closely related to ours are by Reed et al. (2016a) and Raj et al. (2017). Raj et al. (2017) introduce a model that consists of individual “blocks” which are responsible for different object characteristics (e.g. color, shape, etc.). However, their approach was only tested on the synthetic SHAPES data set (Andreas et al., 2016), which has only comparatively low variability and no image captions. Reed et al. (2016b) condition both the generator and the discriminator on either a bounding box containing the object or keypoints describing the object’s shape. However, the used images are still of relatively low variability (e.g. birds (Wah et al., 2011)) and only contain one object, usually located in the center of the image. In contrast, we model images with several different objects at various locations and apply our object pathway multiple times at each image, both in the generator and in the discriminator. Additionally, we use the image caption and bounding box label to obtain individual labels for each bounding box, while Reed et al. (2016b) only use the image caption as conditional information.
+![](images/ce8759ca371daed0c65e336f9f8905733d7dc145cc9833ecfa6c8f9aadbf5e1d.jpg)
+Figure 1: Both the generator and the discriminator of our model consist of a global and an object pathway. The global pathway focuses on global image characteristics, such as the background, while the object pathway is responsible for modeling individual objects at their specified location.
+# 3 APPROACH
+For our approach1, the central goal is to generate objects at arbitrary locations within a scene while keeping the scene overall consistent. For this we make use of a generative adversarial network (GAN) (Goodfellow et al., 2014). A GAN consists of two networks, a generator and a discriminator, where the generator tries to reproduce the true data distribution and the discriminator tries to distinguish between generated data points and data points sampled from the true distribution. We use the conditional GAN framework, in which both the generator and the discriminator get additional information, such as labels, as input. The generator $G$ (see Figure 1) gets as input a randomly sampled noise vector $z$ the location and size of the individual bounding boxes $b b o x _ { i }$ , a label for each of the bounding boxes encoded as a one-hot vector $l _ { \mathrm { o n e h o t } _ { i } }$ , and, if existent, an image caption embedding $\varphi$ obtained with a pretrained char-CNN-RNN network from Reed et al. (2016b). As a pre-processing step (A), the generator constructs labels $l a b e l _ { i }$ for the individual bounding boxes from the image caption $\varphi$ and the provided labels $l _ { \mathrm { o n e h o t } _ { i } }$ of each bounding box. For this, we concatenate the image caption embedding $\varphi$ and the one-hot vector of a given bounding box $l _ { \mathrm { o n e h o t } _ { i } }$ and create a new label embedding $l a b e l _ { i }$ by applying a matrix-multiplication followed by a non-linearity (i.e. a fully connected layer). The resulting label $l a b e l _ { i }$ contains the previous label as well as additional information from the image caption, such as color or shape, and is potentially more meaningful. In case of missing image captions, we use the one-hot embedding $l _ { \mathrm { o n e h o t } _ { i } }$ only.
+The generator consists of two different streams which get combined later in the process. First, the global pathway (B) is responsible for creating a general layout of the global scene. It processes the previously generated local labels $l a b e l _ { i }$ for each of the bounding boxes and replicates them spatially at the location of each bounding box. In areas where the bounding boxes overlap the label embeddings $l a b e l _ { i }$ are summed up, while the areas with no bounding boxes remain filled with zeros. Convolutional layers are applied to this layout to obtain a high-level layout encoding which is concatenated with the noise vector $z$ and the image caption embedding $\varphi$ and the result is used to generate a general image layout $f _ { \mathrm { g l o b a l } }$ .
+Second, the object pathway (C) is responsible for generating features of the objects $f _ { \mathrm { l o c a l } _ { i } }$ within the given bounding boxes. This pathway creates a feature map of a predefined resolution using convolutional layers which receive the previously generated label $l a b e l _ { i }$ as input. This feature map is further transformed with a Spatial Transformer Network (STN) (Jaderberg et al., 2015) to fit into the bounding box at the given location on an empty canvas. The same convolutional layers are applied to each of the provided labels, i.e. we have one object pathway that is applied several times across different labels $l a b e l _ { i }$ and whose output feeds onto the corresponding coordinates on the empty canvas. Again, features within overlapping bounding box areas are summed up, while areas outside of any bounding box remain zero.
+As a final step, the outputs of the global and object pathways $f _ { \mathrm { g l o b a l } }$ and $f _ { \mathrm { l o c a l } _ { i } }$ are concatenated along the channel axis and are used to generate the image in the final resolution, using common GAN procedures. The specific changes of the generator compared to standard architectures are the object pathway that generates additional features at specific locations based on provided labels, as well as the layout encoding which is used as additional input to the global pathway. These two extensions can be added to the generator in any existing architecture with limited extra effort.
+The discriminator receives as input an image (either original or generated), the location and size of the bounding boxes $b b o x _ { i }$ , the labels for the bounding boxes as one-hot vectors $l _ { \mathrm { o n e h o t } _ { i } }$ , and, if existent, the image caption embedding $\varphi$ . Similarly to the generator, the discriminator also possesses both a global (D) and an object (E) pathway respectively. The global pathway takes the image and applies multiple convolutional layers to obtain a representation $f _ { \mathrm { g l o b a l } }$ of the whole image. The object pathway first uses a STN to extract the objects from within the given bounding boxes and then concatenates these extracted features with the spatially replicated bounding box label $l _ { \mathrm { o n e h o t } _ { i } }$ Next, convolutional layers are applied and the resulting features $f _ { \mathrm { l o c a l } _ { i } }$ are again added onto an empty canvas within the coordinates specified by the bounding box. Note, similarly to the generator we only use one object pathway that is applied to multiple image locations, where the outputs are then added onto the empty canvas, summing up overlapping parts and keeping areas outside of the bounding boxes set to zero. Finally, the outputs of both the object and global pathways $f _ { \mathrm { l o c a l } _ { i } }$ and $f _ { \mathrm { g l o b a l } }$ are concatenated along the channel axis and we again apply convolutional layers to obtain a merged feature representation. At this point, the features are concatenated either with the spatially replicated image caption embedding $\varphi$ (if existent) or the sum of all one-hot vectors $l _ { \mathrm { o n e h o t } _ { i } }$ along the channel axis, one more convolutional layer is applied, and the output is classified as either generated or real.
+For the general training, we can utilize the same procedure that is used in the GAN architecture that is modified with our proposed approach. In our work we mostly use the StackGAN (Zhang et al., 2018a) and AttnGAN (Xu et al., 2018b) frameworks which use a modified objective function taking into consideration the additional conditional information and provided image captions. As such, our discriminator $D$ and our generator $G$ optimize the following objective function:
+$$
+\operatorname* { m i n } _ { G } \operatorname* { m a x } _ { D } V ( D , G ) = \mathbb { E } _ { ( x , c ) \sim p _ { \mathrm { d a t a } } } [ l o g D ( x , c ) ] + \mathbb { E } _ { ( z ) \sim p _ { z } , ( c ) \sim p _ { \mathrm { d a t a } } } [ l o g ( 1 - D ( G ( z , c ) , c ) ) ] ,
+$$
+where $x$ is an image, $c$ is the conditional information for this image (e.g. $l a b e l _ { i }$ , bounding boxes $b b o x _ { i }$ , or an image caption $\varphi$ ), $z$ is a randomly sampled noise vector used as input for $G$ , and $p _ { \mathrm { d a t a } }$ is the true data distribution. Zhang et al. (2018a) and others use an additional technique called conditioning augmentation for the image captions which helps improve the training process and the quality of the generated images. In the experiments in which we use image captions (MS-COCO) we also make use of this technique2.
+# 4 EVALUATION AND ANALYSIS
+For the evaluation, we aim to study the quality of the generated images with a particular focus on the generalization capabilities and the contribution of specific parts of our model, in both controllable and large-scale cases. Thus, in the following sections, we evaluate our approach on three different data sets: the Multi-MNIST data set, the CLEVR data set, and the MS-COCO data set.
+# 4.1 MULTI-MNIST
+In our first experiment, we used the Multi-MNIST data set (Eslami et al., 2016) for testing the basic functionality of our proposed model. Using the implementation provided by Eslami et al. (2016), we created 50,000 images of resolution $6 4 \times 6 4$ px that contain exactly three normal-sized MNIST digits in non-overlapping locations on a black background.
+![](images/ec47e731cba80f3790f2949ad4317f709a121efc24cc9f0613b77a9467378569.jpg)
+Figure 2: Multi-MNIST images generated by the model. Training included only images with three individual normal-sized digits. Highlighted bounding boxes and yellow ground truth for visualization.
+As a first step, we tested whether our model can learn to generate digits at the specified locations and whether we can control the digit identity, the generated digit’s size, and the number of generated digits per image. According to the results, we can control the location of individual digits, their identity, and their size, even though all training images contain exactly three digits in normal size. Figure 2 shows that we can control how many digits are generated within an image (rows A–B, for two to five digits) and various sizes of the bounding box (row C). As a second step, we created an additional Multi-MNIST data set in which all training images contain only digits 0–4 in the top half and only digits 5–9 in the bottom half of the image. For testing digits in the opposite half, we can see that the model is indeed capable of generalizing the position (row D, left), i.e. it can generate digits 0–4 in the bottom half of the image and digits 5–9 in the top half of the image. Nevertheless, we also observed that this does not always work perfectly, as the network sometimes alters digits towards the ones it has seen during training at the respective locations, e.g. producing a “4” more similar to a “9” if in bottom half of the image, or generating a “7” more similar to a “1” if in top half of the image.
+As a next step, we created a Multi-MNIST data set with images that only contain digits in the top half of the image, while the bottom half is always empty. We can see (Figure 2, row D, right) that the resulting model is not able to generate digits in the bottom half of the image (see Figure 6 in the Appendix for more details on this). Controlling for the location still works, i.e. bounding boxes are filled with “something”, but the digit identity is not clearly recognizable. Thus, the model is able to control both the object identity and the object location within an image and can generalize to novel object locations to some extent.
+To test the impact of our model extensions, i.e. the object pathway in both the generator and the discriminator as well as the layout encoding, we performed ablation studies on the previously created Multi-MNIST data set with three digits at random locations. We first disabled the use of the layout encoding in the generator and left the rest of the model unchanged. In the results (Figure 2, row E, left), we can see that, overall, both the digit identity and the digit locations are still correct, but minor imperfections can be observed within various images. This is most likely due to the fact that the global pathway of the generator has no information about the digit identity and location until its features get merged with the object pathway. As a next test, we disabled the object pathway of the discriminator and left the rest of the model unmodified. Again, we see (row E, right) that we can still control the digit location, although, again, minor imperfections are visible. More strikingly, we have a noticeably higher error rate in the digit identity, i.e. the wrong digit is generated at a given location, most likely due to the fact that there is not object pathway in the discriminator controlling the object identity at the various locations. In comparison, the imperfections are different when only the object pathway of the generator is disabled (row F, left). The layout encoding and the feedback of the discriminator seem to be enough to still produce the digits in the correct image location, but the digit identity is often incorrect or not recognizable at all. Finally, we tested disabling the object pathway in both the discriminator and the generator (see row F, right). This leads to a loss of control of both image location as well as identity and sometimes even results in images with more or fewer than three digits per image. This shows that only the layout encoding, without any of the object pathways, is not enough to control the digit identity and location. Overall, these results indicate that we do indeed need both the layout encoding, for a better integration of the global and object pathways, and the object pathways in both the discriminator and the generator, for optimal results.
+![](images/c2daae0680f0912055c2bcfeb2359fd3ba0e7d44e66139c5af645529bc094781.jpg)
+Figure 3: Images from the CLEVR data set. The left image of each pair shows the rendered image according to specific attributes. The right image of each pair is the image generated by our model.
+# 4.2 CLEVR
+In our second experiment we used more complex images containing multiple objects of different colors and shapes. The goal of this experiment was to evaluate the generalization ability of our object pathway across different object characteristics. For this, we performed tests similar to (Raj et al., 2017), albeit on the more complex CLEVR data set (Johnson et al., 2017). In the CLEVR data set objects are characterized by multiple properties, in our case the shape, the color, and the size. Based on the implementation provided by Johnson et al. (2017), we rendered 25,000 images with a resolution of $6 4 \times 6 4$ pixels containing $2 - 4$ objects per image. The label for a given bounding box of an object is the object shape and color (both encoded as one-hot encoding and then concatenated), while the object size is specified through the height and width of the bounding box.
+Similar to the first experiment, we tested our model for controlling the object characteristics, size, and location. In the first row of Figure 3 we present the results of the trained model, where the left image of each pair shows the originally rendered one, while the right image was generated by our model. We can confirm that the model can control both the location and the objects’ shape and color characteristics. The model can also generate images containing an arbitrary number of objects (forth and fifths pair), even though a maximum of four objects per image was seen during training.
+The CLEVR data set offers a split specifically intended to test the generalization capability of a model, in which cylinders can be either red, green, purple, or cyan and cubes can be either gray, blue, brown, or yellow during training, while spheres can have any of these colors. During testing, the colors between cylinders and cubes are reversed. Based on these restrictions, we created a second data set of 25,000 training images for testing our model. Results of the test are shown in the second row of Figure 3 (again, left image of each pair shows the originally rendered one, while the right image was generated by our model). We can see that the color transfer to novel shape-color combinations takes place, but, similarly to the Multi-MNIST results, we can see some artifacts, where e.g. some cubes look a bit more like cylinders and vice versa. Overall, the CLEVR experiment confirms the indication that our model can control object characteristics (provided through labels) and object locations (provided through bounding boxes) and can generalize to novel object locations, novel amounts of objects per image, and novel object characteristic combinations within reasonable boundaries.
+<table><tr><td>Model</td><td>Resolution</td><td>IS个</td><td>FID↓</td></tr><tr><td>GAN-INT-CLS Reed et al. (2016b) StackGAN-V2 Zhang et al. (2018a) StackGAN Zhang et al. (2018a) PPGN Nguyen et al. (2017) ChatPainter (StackGAN) Sharma et al. (2018) Semantic Layout Hong et al. (2018b) HDGan Zhang et al. (2018c)</td><td>64× 64 256 ×256 256× 256 227× 227 256× 256 128×128 256× 256</td><td>7.88 ±0.07 8.30± 0.10 8.45 ± 0.031 9.58 ± 0.21 9.74 ± 0.02 11.46 ± 0.09²</td><td>60.62 81.59 74.05</td></tr><tr><td>AttnGAN Xu et al. (2018b) StackGAN + Object Pathways (Ours)5 AttnGAN + Object Pathways (Ours)</td><td>256× 256 256×256 256 ×256</td><td>11.86 ± 0.18 23.61±0.214 12.12 ± 0.31 24.76 ± 0.43</td><td>71.27 ± 0.123 33.10 ± 0.113 55.30 ± 1.78 33.35 ± 1.15</td></tr></table>
+1 Recently updated to $1 0 . 6 2 \pm 0 . 1 9$ in its source code. 2 When using the ground truth bounding boxes at test time (as we do) the IS increases to $1 1 . 9 4 \pm 0 . 0 9$ . 3 FID score was calculated with samples generated with the pretrained model provided by the authors. 4 The authors report a “best” value of $2 5 . 8 9 \pm 0 . 4 7$ , but when calculating the IS with the pretrained model provided by the authors we only obtain an IS of 23.61. Other researchers on the authors’ Github website report a similar value for the pretrained model. 5 We use the updated source code (IS of 10.62) as our baseline model.
+Table 1: Comparison of the Inception Score (IS) and Frechet Inception Distance (FID) on the MS- ´ COCO data set for different models. Note: the IS and FID values of our models are not necessarily directly comparable to the other models, since our model gets at test time, in addition to the image caption, up to three bounding boxes and their respective object labels as input.
+# 4.3 MS-COCO
+For our final experiment, we used the MS-COCO data set (Lin et al., 2014) to evaluate our model on natural images of complex scenes. In order to keep our evaluation comparable to previous work, we used the 2014 train/test split consisting of roughly 80,000 training and 40,000 test images and rescaled the images to a resolution of $2 5 6 \times 2 5 6 \ : \mathrm { p x }$ . At train-time, we used the bounding boxes and object labels of the three largest objects within an image, i.e. we used zero to three bounding boxes per image. Similarly to work by Johnson et al. (2018) we only considered objects that cover at least $2 \%$ of the image for the bounding boxes. To evaluate our results quantitatively, we computed both the Inception Score (IS, larger is better), which tries to evaluate how recognizable and diverse objects within images are (Salimans et al., 2016), as well as the Frechet Inception Distance (FID, smaller is ´ better), which compares the statistics of generated images with real images (Heusel et al., 2017). As a qualitative evaluation, we generated images that contain more than one object, and checked, whether the bounding boxes can control the object placement. We tested our approach with two commonly used architectures for text-to-image synthesis, namely the StackGAN (Zhang et al., 2017) and the AttnGAN (Xu et al., 2018b), and compared the images generated by these and our models.
+In the StackGAN, the training process is divided into two steps: first, it learns a generator for images with a resolution of $6 4 \times 6 4$ px based on the image captions, and second, it trains a second generator, which uses the smaller images $( 6 4 \times 6 4 \ : \mathrm { p x } )$ from the first generator and the image caption as input to generate images with a resolution of $2 5 6 \times 2 5 6$ px. Here, we added the object pathways and the layout encoding at the beginning of both the first generator and the second generator and used the object pathway in both discriminators. The other parts of StackGAN architecture and all hyperparameters remain the same as in the original training procedure for the MS-COCO data set. We trained the model three times from scratch and randomly sampled 3 times 30,000 image captions from the test set for each model. We then calculated the IS and FID values on each of the nine samples of 30,000 generated images and report the averaged values. As presented in Table 1, our StackGAN with added object pathways outperforms the original StackGAN both on the IS and the FID, increasing the IS from 10.62 to 12.12 and decreasing the FID from 74.05 to 55.30. Note, however, that this might also be due to the additional information our model is provided with as it receives up to three bounding boxes and respective bounding box labels per image in addition to the image caption.
+We also extended the AttnGAN by Xu et al. (2018b), the current state-of-the-art model on the MS-COCO data set (based on the Inception Score), with our object pathway to evaluate its impact on a different model. As opposed to the StackGAN, the AttnGAN consists of only one model which is trained end-to-end on the image captions by making use of multiple, intermediate, discriminators. Three discriminators judge the output of the generator at an image resolution of $6 4 \times 6 4$ , $1 2 8 \times 1 2 8$ , and $2 5 6 \times 2 5 6 \ : \mathrm { p x }$ . Through this, the image generation process is guided at multiple levels, which helps during the training process. Additionally, the AttnGAN implements an attention technique through which the networks focus on specific areas of the image for specific words in the image caption and adds an additional loss that checks if the image depicts the content as described by the image caption. There, in the same way as for the StackGAN, we added our object pathway at the beginning of the generator as well as to the discriminator that judges the generator outputs at a resolution of $6 4 \times 6 4 \mathrm { p x }$ . All other discriminators, the higher layers of the generator, and all other hyperparameters and training details stay unchanged. Table 1 shows that adding the object pathway to the AttnGAN increases the IS of our baseline model (the pretrained model provided by the authors) from 23.61 to 24.76, while the FID is roughly the same as for the baseline model.
+![](images/4e9c1e00bcda158b81163305c8ec34aff750f4ecbdfeb81a247e235f20303449.jpg)
+Figure 4: Examples of images generated from the given caption from the MS-COCO data set. A) shows the original images and the respective image captions, $B$ ) shows images generated by our StackGAN $\mathrm { + O P }$ (with the corresponding bounding boxes for visualization), and $C _ { \cdot }$ ) shows images generated by the original StackGAN (Zhang et al., 2017)3
+To evaluate whether the StackGAN model equipped with an object pathway $\mathrm { \ S t a c k G A N + O P }$ ) actually generates objects at the given positions we generated images that contain multiple objects and inspected them visually. Figure 4 shows some example images, more results can be seen in the Appendix in Figures 7 and 9. We can observe that the $\mathrm { S t a c k G A N + O P }$ indeed generates images in which the objects are at appropriate locations. In order to more closely inspect our global and object pathways, we can also disable them during the image generation process. Figure 5 shows additional examples, in which we generate the same image with either the global or the object pathway disabled during the generation process. Row C of Figure 5 shows images in which the object pathway was disabled and, indeed, we observe that the images contain mostly background information and objects at the location of the bounding boxes are either not present or of much less detail than when the object pathway is enabled. Conversely, row D of Figure 5 shows images which were generated when the global pathway was disabled. As expected, areas outside of the bounding boxes are empty, but we also observe that the bounding boxes indeed contain images that resemble the appropriate objects. These results indicate, as in the previous experiments, that the global pathway does indeed model holistic image features, while the object pathway focuses on specific, individual objects.
+When we add the object pathway to the AttnGAN $\mathrm { \Delta A t t n G A N + O P ) }$ we can observe similar results4. Again, we are able to control the location and identity of objects through the object pathway, however, we observe that the AttnGAN+OP, as well as the AttnGAN in general, tends to place objects corresponding to specific features at many locations throughout the image. For example, if the caption contains the word “traffic light” the AttnGAN tends to place objects similar to traffic lights throughout the whole image. Since our model only focuses on generating objects at given locations, while not enforcing that these objects only occur at these locations, this behavior leads to the result that the AttnGAN+OP generates desired objects at the desired locations, but might also place the same object at other locations within the image. Note, however, that we only added the object pathway to the lowest generator and discriminator and that we might gain even more control over the object location by introducing object pathways to the higher generators and discriminators, too.
+![](images/b164c6b003e8813aa5a1bdbe9b13a92b1bef465c6eb4cbede4b38aadb57db22b.jpg)
+Figure 5: Examples of images generated from the given caption from the MS-COCO data set. A) shows the original images and the respective image captions, $B$ ) shows images generated by our $\mathrm { S t a c k G A N + O P }$ (with the corresponding bounding boxes for visualization) with the object pathway enabled, $C _ { \epsilon }$ ) shows images generated by the our StackGAN $\mathrm { + O P }$ when the object pathway is disabled, and $D$ ) shows images generated by the our StackGAN $\mathrm { + O P }$ when the global pathway is disabled.
+In order to further evaluate the quality of the generations, we ran an object detection test on the generated images using a pretrained YOLOv3 network (Redmon & Farhadi, 2018). Here, the goal is to measure how often an object detection framework, which was trained on MS-COSO as well, can detect a specified object at a specified location5. The results confirm the previously made observations: For both the StackGAN and the AttnGAN the object pathway seems to improve the image quality, since YOLOv3 detects a given object more often correctly when the images are generated with an object pathway as opposed to images generated with the baseline models. The StackGAN generates objects at the given bounding box, resulting in an Intersection over Union (IoU) of greater than 0.3 for all tested labels and greater than 0.5 for $8 6 . 7 \%$ of the tested labels. In contrast, the AttnGAN tends to place salient object features throughout the image, which leads to an even higher detection rate by the YOLOv3 network, but a smaller average IoU (only $5 3 . 3 \%$ of the labels achieve an IoU greater than 0.3). Overall, our experiments on the MS-COCO data set indicate that it is possible to add our object pathway to pre-existing GAN models without having to change the overall model architecture or training process. Adding the object pathway provides us with more control over the image generation process and can, in some cases, increase the quality of the generated images as measured via the IS or FID.
+# 4.4 DISCUSSION
+Our experiments indicate that we do indeed get additional control over the image generation process through the introduction of object pathways in GANs. This enables us to control the identity and location of multiple objects within a given image based on bounding boxes and thereby facilitates the generation of more complex scenes. We further find that the division of work on a global and object pathway seems to improve the image quality both subjectively and based on quantitative metrics such as the Inception Score and the Frechet Inception Distance. ´
+The results further indicate that the focus on global image statistics by the global pathway and the more fine-grained attention to detail of specific objects by the object pathway works well. This is visualized for example in rows C and D of Figure 5. The global pathway (row C) generates features for the general image layout and background but does not provide sufficient details for individual objects. The object pathway (row D), on the other hand, focuses entirely on the individual objects and generates features specifically for a given object at a given location. While this is the desired behavior of our model it can also lead to sub-optimal images if there are not bounding boxes for objects that should be present within the image. This can often be the case if the foreground object is too small (in our case less than $2 \%$ of the total image) and is therefore not specifically labeled. In this case, the objects are sometimes not modeled in the image at all, despite being prominent in the respective image caption, since the object pathway does not generate any features. We can observe this, for example, in images described as “many sheep are standing on the grass”, where the individual sheep are too small to warrant a bounding box. In this case, our model will often only generate an image depicting grass and other background details, while not containing any sheep at all.
+Another weakness is that bounding boxes that overlap too much (empirically an overlap of more than roughly $30 \%$ ) also often lead to sub-optimal objects at that location. Especially in the overlapping section of bounding boxes we often observe local inconsistencies or failures. This might be the result of our merging of the different features within the object pathway since they are simply added to each other at overlapping areas. A more sophisticated merging procedure could potentially alleviate this problem.Another approach would be to additionally enhance the bounding box layout by predicting the specific object shape within each bounding box, as done for example by Hong et al. (2018b).
+Finally, currently our model does not generate the bounding boxes and labels automatically. Instead, they have to be provided at test time which somewhat limits the usability for unsupervised image generation. However, even when using ground truth bounding boxes, our models still outperform other current approaches that are tested with ground truth bounding boxes (e.g. Hong et al. (2018b)) based on the IS and FID. This is even without the additional need of learning to specify the shape within each bounding box as done by Hong et al. (2018b). In the future, this limitation can be avoided by extracting the relevant bounding boxes and labels directly from the image caption, as it is done for example by Hong et al. (2018b), Xu et al. (2018a), and Tan et al. (2018).
+# 5 CONCLUSION
+With the goal of understanding how to gain more control over the image generation process in GANs, we introduced the concept of an additional object pathway. Such a mechanism for differentiating between a scene representation and object representations allows us to control the identity, location, and size of arbitrarily many objects within an image, as long as the objects do not overlap too strongly. In parallel, a global pathway, similar to a standard GAN, focuses on the general scene layout and generates holistic image features. The object pathway, on the other hand, gets as input an object label and uses this to generate features specifically for this object which are then placed at the location given by a bounding box The object pathway is applied iteratively for each object at each given location and as such, we obtain a representation of individual objects at individual locations and of the general image layout (background, etc.) as a whole. The features generated by the object and global pathway are then concatenated and are used to generate the final image output. Our tests on synthetic and real-world data sets suggest that the object pathway is an extension that can be added to common GAN architectures without much change to the original architecture and can, along with more fine-grained control over the image layout, also lead to better image quality.
+# ACKNOWLEDGMENTS
+The authors gratefully acknowledge partial support from the German Research Foundation DFG under project CML (TRR 169) and the European Union under project SECURE (No 642667). We also thank the NVIDIA Corporation for their support through the GPU Grant Program.
+# REFERENCES
+Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Neural module networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 39–48, 2016.
+Qifeng Chen and Vladlen Koltun. Photographic image synthesis with cascaded refinement networks. In IEEE International Conference on Computer Vision, pp. 1520–1529, 2017.
+S. M. Ali Eslami, Nicolas Heess, Theophane Weber, Yuval Tassa, David Szepesvari, koray kavukcuoglu, and Geoffrey E Hinton. Attend, infer, repeat: Fast scene understanding with generative models. In Advances in Neural Information Processing Systems, pp. 3225–3233, 2016.
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems, pp. 2672–2680, 2014.
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In Advances in Neural Information Processing Systems, pp. 6626–6637, 2017.
+Seunghoon Hong, Xinchen Yan, Thomas Huang, and Honglak Lee. Learning hierarchical semantic image manipulation through structured representations. In Advances in Neural Information Processing Systems, pp. 2712–2722, 2018a.
+Seunghoon Hong, Dingdong Yang, Jongwook Choi, and Honglak Lee. Inferring semantic layout for hierarchical text-to-image synthesis. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 7986–7994, 2018b.
+Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In Advances in Neural Information Processing Systems, pp. 2017–2025, 2015.
+Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C Lawrence Zitnick, and Ross Girshick. Clevr: A diagnostic dataset for compositional language and elementary visual reasoning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1988–1997, 2017.
+Justin Johnson, Agrim Gupta, and Li Fei-Fei. Image generation from scene graphs. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1219–1228, 2018.
+Levent Karacan, Zeynep Akata, Aykut Erdem, and Erkut Erdem. Learning to generate images of outdoor scenes from attributes and semantic layouts. arXiv preprint arXiv:1612.00215, 2016.
+Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ European Conference on Computer Vision, pp. 740–755, 2014.
+Elman Mansimov, Emilio Parisotto, Jimmy Lei Ba, and Ruslan Salakhutdinov. Generating images from captions with attention. In International Conference on Learning Representations, 2016.
+Anh Nguyen, Yoshua Bengio, and Alexey Dosovitskiy. Plug & play generative networks: Conditional iterative generation of images in latent space. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4467–4477, 2017.
+Amit Raj, Cusuh Ham, Huda Alamri, Vincent Cartillier, Stefan Lee, and James Hays. Compositional generation of images. In Advances in Neural Information Processing Systems ViGIL, 2017.
+Joseph Redmon and Ali Farhadi. Yolov3: An incremental improvement. arXiv preprint arXiv:1804.02767, 2018.
+Scott Reed, Zeynep Akata, Santosh Mohan, Samuel Tenka, Bernt Schiele, and Honglak Lee. Learning what and where to draw. In Advances in Neural Information Processing Systems, pp. 217–225, 2016a.
+Scott Reed, Zeynep Akata, Xinchen Yan, Lajanugen Logeswaran, Bernt Schiele, and Honglak Lee. Generative adversarial text to image synthesis. In International Conference on Machine Learning, pp. 1060–1069, 2016b.
+Scott Reed, Aaron van den Oord, Nal Kalchbrenner, Victor Bapst, Matt Botvinick, and Nando ¨ de Freitas. Generating interpretable images with controllable structure. 2016c.
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in Neural Information Processing Systems, pp. 2234–2242, 2016.
+Shikhar Sharma, Dendi Suhubdy, Vincent Michalski, Samira Ebrahimi Kahou, and Yoshua Bengio. Chatpainter: Improving text to image generation using dialogue. In International Conference on Learning Representations Workshop, 2018.
+Fuwen Tan, Song Feng, and Vicente Ordonez. Text2scene: Generating abstract scenes from textual descriptions. arXiv preprint arXiv:1809.01110, 2018.
+Catherine Wah, Steve Branson, Peter Welinder, Pietro Perona, and Serge Belongie. The caltech-ucsd birds-200-2011 dataset. 2011.
+Ting-Chun Wang, Ming-Yu Liu, Jun-Yan Zhu, Andrew Tao, Jan Kautz, and Bryan Catanzaro. Highresolution image synthesis and semantic manipulation with conditional gans. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 8798–8807, 2018.
+Kun Xu, Haoyu Liang, Jun Zhu, Hang Su, and Bo Zhang. Deep structured generative models. In ICML Workshop on Theoretical Foundations and Applications of Deep Generative Models, 2018a.
+Tao Xu, Pengchuan Zhang, Qiuyuan Huang, Han Zhang, Zhe Gan, Xiaolei Huang, and Xiaodong He. Attngan: Fine-grained text to image generation with attentional generative adversarial networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2018b.
+Han Zhang, Tao Xu, Hongsheng Li, Shaoting Zhang, Xiaolei Huang, Xiaogang Wang, and Dimitris Metaxas. Stackgan: Text to photo-realistic image synthesis with stacked generative adversarial networks. In IEEE International Conference on Computer Vision, pp. 5907–5915, 2017.
+Han Zhang, Tao Xu, Hongsheng Li, Shaoting Zhang, Xiaogang Wang, Xiaolei Huang, and Dimitris Metaxas. Stackgan $^ { + + }$ : Realistic image synthesis with stacked generative adversarial networks. IEEE Transactions on Pattern Analysis and Machine Intelligence, pp. 1–16, 2018a.
+Shengyu Zhang, Hao Dong, Wei Hu, Yike Guo, Chao Wu, Di Xie, and Fei Wu. Text-to-image synthesis via visual-memory creative adversarial network. In Pacific Rim Conference on Multimedia, pp. 417–427, 2018b.
+Zizhao Zhang, Yuanpu Xie, and Lin Yang. Photographic text-to-image synthesis with a hierarchicallynested adversarial network. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 6199–6208, 2018c.
+# A IMPLEMENTATION DETAILS
+Here we provide some more details about the exact implementation of our experiments.
+# A.1 MULTI-MNIST AND CLEVR
+To train our GAN approach on the Multi-MNIST (CLEVR) data set we use the Stage-I Generator and Discriminator from the StackGAN MS-COCO architecture6. In our following description an upsample block describes the following sequence: nearest neighbor upsampling with factor 2, a convolutional layer with $X$ filters (filter size $3 \times 3$ , stride 1, padding 1), batch normalization, and a ReLU activation. The bounding box labels are one-hot vectors of size [1, 10] encoding the digit identity (CLEVR: [1, 13] encoding object shape and color). Please refer to Table 2 for detailed information on the individual layers described in the following. For all leaky ReLU activations alpha was set to 0.2.
+In the object pathway of the generator we first create a zero tensor $\mathbb { O } _ { G }$ which will contain the feature representations of the individual objects. We then spatially replicate each bounding box label into a $4 \times 4$ layout of shape $( 1 0 , 4 , 4 )$ (CLEVR: $( 1 3 , 4 , 4 ) ,$ ) and apply two upsampling blocks. The resulting tensor is then added to the tensor $\mathbb { O } _ { G }$ at the location of the bounding box using a spatial transformer network.
+In the global pathway of the generator we first obtain the layout encoding. For this we create a tensor of shape (10, 16, 16) (CLEVR: (13, 16, 16)) that contains the one-hot labels at the location of the bounding boxes and is zero everywhere else. We then apply three convolutional layers, each followed by batch normalization and a leaky ReLU activation. We reshape the output to shape $( 1 , 6 4 )$ and concatenate it with the noise tensor of shape $( 1 , 1 0 0 )$ (sampled from a random normal distribution) to form a tensor of shape $( 1 , 1 6 4 )$ . This tensor is then fed into a dense layer, followed by batch normalization and a ReLU activation and the output is reshaped to $( - 1 , 4 , 4 )$ . We then apply two upsampling blocks to obtain a tensor of shape $( - 1 , 1 6 , 1 6 )$ .
+At this point, the outputs of the object and the global pathway are concatenated along the channel axis to form a tensor of shape $( - 1 , 1 6 , 1 6 )$ . We then apply another two upsampling blocks resulting in a tensor of shape $( - 1 , 6 4 , 6 \dot { 4 } )$ followed by a convolutional layer and a TanH activation to obtain the final image of shape $( - 1 , 6 4 , 6 4 )$ .
+In the object pathway of the discriminator we first create a zero tensor $\mathbb { O } _ { D }$ which will contain the feature representations of the individual objects. We then use a spatial transfomer network to extract the image features at the locations of the bounding boxes and reshape them to a tensor of shape $( 1 , 1 6 , 1 6 )$ (CLEVR: $( 3 , 1 6 , 1 6 ) _ { \cdot }$ ). The one-hot label of each bounding box are spatially replicated to a shape of (10, 16, 16) (CLEVR: (13, 16, 16)) and concatenated with the previously extracted features to form a tensor of shape (11, 16, 16) (CLEVR: (16, 16, 16)). We then apply a convolutional layer, batch normalization and a leaky ReLU activation to the concatenation of features and label and, again, use a spatial transformer network to resize the output to the shape of the respective bounding box before adding it to the tensor $\mathbb { O } _ { D }$ .
+In the global pathway of the discriminator, we apply two convolutional layers, each followed by batch normalization and a leaky ReLU activation and concatenate the resulting tensor with the output of the object pathway. After this, we again apply two convolutional layers, each followed by batch normalization and a leaky ReLU activation. We concatenate the resulting tensor with the conditioning information about the image content, in this case, the sum of all one-hot vectors. To this tensor we apply another convolutional layer, batch normalization, a leaky ReLU activation, and another convolutional layer, to obtain the final output of the discriminator of shape (1).
+Similarly to the procedure of StackGAN and other conditional GANs we train the discriminator to classify real images with correct labels (the sum of one-hot vectors supplied in the last step of the process) as real, while generated images with correct labels and real images with (randomly sampled) incorrect labels should be classified as fake.
+# A.2 MS-COCO
+StackGAN-Stage-I For training the Stage-I generator and discriminator (images of size $6 4 \times 6 4$ pixels) we follow the same procedure and architecture outlined in the previous section about the training on the Multi-MNIST and CLEVR data sets. The only difference is that we now have image captions as an additional description of the image. As such, to obtain the bounding box labels we concatenate the image caption embedding7 and the one-hot encoded bounding box label and apply a dense layer with 128 units, batch normalization, and a ReLU activation to it, to obtain a label of shape $( 1 , 1 2 8 )$ for each bounding box. In the final step of the discriminator when we concatenate the feature representation with the conditioning vector, we use the image encoding as conditioning vector and do not use any bounding box labels at this step. The rest of the training proceeds as described in the previous section, except that the bounding box labels now have a shape of $( 1 , 1 2 8 )$ . All other details can be found in Table 2.
+StackGAN-Stage-II In the second part of the training, we train a second generator and discriminator to generate images with a resolution of $2 5 6 \times 2 5 6$ pixels. The generator gets as input images with a resolution of $6 4 \times 6 4$ pixels (generated by the trained Stage-I generator) and the image caption and uses them to generate images with a $2 5 6 \times 2 5 6$ pixels resolution. A new discriminator is trained to distinguish between real and generated images.
+On the Stage-II generator we perform the following modifications we use the same procedure as in the Stage-I generator to obtain the bounding box labels. To obtain an image encoding from the generated $6 4 \times 6 4$ image we use three convolutional layers, each followed by batch normalization and a ReLU activation to obtain a feature representation of shape $[ - 1 , 1 6 , 1 6 ]$ . Additionally, we replicate each bounding box label (obtained with the dense layer) spatially at the locations of the bounding boxes on an empty canvas of shape [128, 16, 16] and then concatenate it along the channel axis with the image encoding and the spatially replicated image caption embedding. As in the standard StackGAN we then apply more convolutional layers with residual connections to obtain the final image embedding of shape $[ - 1 , 1 6 , 1 6 ]$ , which provides the input for both the object and the global pathway.
+The generator’s object pathway gets as input the image encoding described in the previous step. First, we create a zero tensor $\mathbb { O } _ { G }$ which will contain the feature representations of the individual objects. We then use a spatial transformer network to extract the features from within the bounding box and reshapes those features to $[ - 1 , 1 6 , 1 6 ]$ . After this, we apply two upsample blocks and then use a spatial transformer network to add the features to $\mathbb { O } _ { G }$ within the bounding box region. This is done for each of the bounding boxes within the image.
+The generator’s global pathway gets as input the image encoding and uses the same convolutional layers and upsampling procedures as the original StackGAN Stage-II generator. The outputs of the object and global pathway are merged at the resolution of $[ - 1 , 6 4 , 6 4 ]$ by concatenating the two outputs along the channel axis. After this, we continue using the standard StackGAN architecture to generate images of shape [3, 256, 256].
+The Stage-II discriminator’s object pathway first creates a zero tensor $\mathbb { O } _ { D }$ which will contain the feature representations of the individual objects. It gets as input the image (resolution of $2 5 6 \times 2 5 6$ pixels) and we use a spatial transformer network to extract the features from the bounding box and reshape those features to a shape of [3, 32, 32]. We spatially replicate the bounding box label (one-hot encoding) to a shape of $[ - 1 , \bar { 3 2 } , 3 2 ]$ and concatenate it with the extracted features along the channel axis. This is then given to the object pathway which consists of two convolutional layers with batch normalization and a LeakyReLU activation. The output of the object pathway is again transformed to the width and height of the bounding box with a spatial transformer network and then added to $\mathbb { O } _ { D }$ This procedure is performed with each of the bounding boxes within the image (maximum of three during training).
+The Stage-II discriminator’s global pathway consists of the standard StackGAN layers, i.e. it gets as input the image $( 2 5 6 \times 2 5 6$ pixels) and applies convolutional layers with stride 2 to it. The outputs of the object and global pathways are merged at the resolution of $[ - 1 , 3 2 , 3 2 ]$ by concatenating the two outputs along the channel axis We then apply more convolutional with stride 2 to decrease the resolution. After this, we continue in the same way as the original StackGAN.
+AttnGAN On the AttnGAN8 we only modify the training at the lower layers of the generator and the first discriminator (working on images of $6 4 \times 6 4$ pixels resolution). For this, we perform the same modifications as described in the StackGAN-Stage-I generator and discriminator. In the generator we obtain the bounding box labels in the same way as in the StackGAN, by concatenating the image caption embedding with the respective one-hot vector and applying a dense layer with 100 units, batch normalization, and a ReLU activation to obtain a bounding box label. In contrast to the previous architectures, we follow the AttnGAN implementation in use the gated linear unit function (GLU) as standard activation for our convolutional layers in the generator.
+In the generator’s object pathway we first create a zero tensor $\mathbb { O } _ { G }$ of shape (192, 16, 16) which will contain the feature representations of the individual objects. We then spatially replicate each bounding box label into a $4 \times 4$ layout of shape $( 1 0 0 , 4 , 4 )$ and apply two upsampling blocks with 768 and 384 filters (filter size $\mathrm { = 3 }$ , stride ${ \mathrm { : = } } 1$ , padding ${ = } 1$ ). The resulting tensor is then added to the tensor $\mathbb { O } _ { G }$ at the location of the bounding box using a spatial transformer network.
+In the global pathway of the generator we first obtain the layout encoding in the same way as in the StackGAN-I generator, except that the three convolutional layers of the layout encoding now have 50, 25, and 12 filters respectively (filter size $\scriptstyle = 3$ , stride ${ \it \Omega } = 2 { \it \Omega }$ , padding ${ \tt = } 1$ ). We concatenate it with the noise tensor of shape $( 1 , 1 0 0 )$ (sampled from a random normal distribution) and the image caption embedding to form a tensor of shape (1, 248). This tensor is then fed into a dense layer with 24,576 units, followed by batch normalization and a ReLU activation and the output is reshaped to (768, 4, 4). We then apply two upsampling blocks with 768 and 384 filters to obtain a tensor of shape (192, 16, 16).
+At this point the outputs of the object and the global pathways are concatenated along the channel axis to form a tensor of shape (384, 16, 16). We then apply another two upsampling blocks with 192 and 96 filters, resulting in a tensor of shape (48, 64, 64). This feature representation is then used by the following layers of the AttnGAN generator in the same way as detailed in the original paper and implementation.
+In the object pathway of the discriminator we first create a zero tensor $\mathbb { O } _ { D }$ which will contain the feature representations of the individual objects. We then use a spatial transfomer network to extract the image features at the locations of the bounding boxes and reshape them to a tensor of shape (3, 16, 16). The one-hot label of each bounding box is spatially replicated to a shape of $( - 1 , 1 6 , 1 6 )$ and concatenated with the previously extracted features. We then apply a convolutional layer with 192 filters (filter size ${ = } 4$ , stride ${ \boldsymbol { \mathbf { \mathit { \varepsilon } } } } = 1$ , padding ${ \mathrm { = } } 1$ ), batch normalization and a leaky ReLU activation to the concatenation of features and label and, again, use a spatial transformer network to resize the output to the shape of the respective bounding box before adding it to the tensor $\mathbb { O } _ { D }$ .
+In the global pathway of the discriminator we apply two convolutional layers with 96 and 192 filters (filter size ${ = } 4$ , stride ${ \it \Omega } = 2 { \it \Omega }$ , padding ${ = } 1$ ), each followed by batch normalization and a leaky ReLU activation and concatenate the resulting tensor with the output of the object pathway. After this, we again apply two convolutional layers with 384 and 768 filters (filter size ${ = } 4$ , stride ${ \boldsymbol { \mathbf { \mathit { \sigma } } } } = 2 { \boldsymbol { \mathbf { \mathit { \varepsilon } } } }$ , padding ${ \tt = } 1$ ), each followed by batch normalization and a leaky ReLU activation. We concatenate the resulting tensor with the spatially replicated image caption embedding. To this tensor we apply another convolutional layer with 768 filters (filter size $\scriptstyle = 3$ , stride ${ = } 1$ , padding ${ \boldsymbol { \mathbf { \rho } } } = 1$ ), batch normalization, a leaky ReLU activation, and another convolutional layer with one filter (filter size ${ = } 4$ , stride ${ = } 4$ , padding ${ = } 0$ ), to obtain the final output of the discriminator of shape (1). The rest of the training and all other hyperparameters and architectural values are left the same as in the original implementation.
+<table><tr><td>ublisnedasaconierencepaperatiCLR2019</td><td>Multi-MNIST</td><td>CLEVR</td><td>MS-COCO-I</td><td>MS-COCO-II</td></tr><tr><td></td><td></td><td></td><td>Adam (beta1 = 0.5, betaz = 0.999)</td><td></td></tr><tr><td>Optimizer</td><td>0.0002</td><td>0.0002</td><td>0.0002</td><td>0.0002</td></tr><tr><td>Learning Rate Schedule: halve every</td><td></td><td></td><td></td><td></td></tr><tr><td>x epochs</td><td>10</td><td>20</td><td>20</td><td>20</td></tr><tr><td>Training Epochs</td><td>20</td><td>40</td><td>120</td><td>110</td></tr><tr><td>Batch Size</td><td>128</td><td>128</td><td>128</td><td>40</td></tr><tr><td>Weight Initialization</td><td>N(0,0.02)</td><td>N(0,0.02)</td><td>N(0,0.02)</td><td>N(0,0.02)</td></tr><tr><td>Z-Dim/ Img-Caption-Dim</td><td>100/10</td><td>100/13</td><td>100/128</td><td>100/128</td></tr><tr><td>Generator</td><td></td><td></td><td></td><td></td></tr><tr><td>Image Encoder</td><td></td><td></td><td></td><td></td></tr><tr><td>Conv (fs=3, s=1, p=1) Conv (fs=4, s=2, p=1)</td><td></td><td></td><td></td><td>192</td></tr><tr><td>Conv (fs=4, s=2, p=1)</td><td></td><td></td><td></td><td>384</td></tr><tr><td>Concat with image</td><td></td><td></td><td></td><td>768</td></tr><tr><td>caption and bbox labels</td><td></td><td></td><td></td><td>(1024,16,16)</td></tr><tr><td>Conv (fs=3, str=1, pad=1)</td><td></td><td></td><td></td><td>768</td></tr><tr><td>4 × Res. (fs=3,s=1,p=1)</td><td></td><td></td><td></td><td>768</td></tr><tr><td> Object Pathway</td><td></td><td></td><td></td><td></td></tr><tr><td>Og Shape</td><td>(256,16,16)</td><td>(192,16,16)</td><td>(384,16,16)</td><td>(192,64,64)</td></tr><tr><td>Upsample (fs=3, s=1, p=1)</td><td>512</td><td>384</td><td>768</td><td>384</td></tr><tr><td>Upsample (fs=3,s=1, p=1)</td><td>256</td><td>192</td><td>384</td><td>192</td></tr><tr><td>Output Shape Global Pathway</td><td>(256,16,16)</td><td>(192,16,16)</td><td>(384,16,16)</td><td>(192,64,64)</td></tr><tr><td>Layout Encoding</td><td></td><td></td><td></td><td></td></tr><tr><td>Conv (fs=3,s=2, p=1)</td><td>64</td><td>64</td><td>64</td><td></td></tr><tr><td>Conv (fs=3, s=2, p=1)</td><td>32</td><td>32</td><td>32</td><td></td></tr><tr><td>Conv (fs=3, s=2, p=1)</td><td>16</td><td>16</td><td>16</td><td></td></tr><tr><td>Dense Layer Units</td><td>16,384</td><td>12,288</td><td>24,576</td><td></td></tr><tr><td>Upsample (fs=3, s=1, p=1)</td><td>512</td><td>384</td><td>768</td><td>384</td></tr><tr><td>Upsample (fs=3,s=1, p=1)</td><td>256</td><td>192</td><td>384</td><td>192</td></tr><tr><td> Output Shape</td><td>(256,16,16)</td><td>192,16,16)</td><td>(384,16,16)</td><td>(192,64,64)</td></tr><tr><td>Concat outputs of object</td><td>(512,16,16)</td><td>(384,16,16)</td><td>(768,16,16)</td><td>(384,64,64)</td></tr><tr><td> and global pathways</td><td>128</td><td>96</td><td>192</td><td></td></tr><tr><td>Upsample (fs=3, s=1, p=1) Upsample (fs=3, s=1, p=1)</td><td>64</td><td>48</td><td>96</td><td>96 48</td></tr><tr><td>Conv (fs=3,s=1, p=1)</td><td>1</td><td>3</td><td>3</td><td>3</td></tr><tr><td>Generator Output</td><td>(1,64,64)</td><td>(3,64,64)</td><td>(3,64,64)</td><td>(3,256,256)</td></tr><tr><td>Discriminator</td><td></td><td></td><td></td><td></td></tr><tr><td> Object Pathway</td><td></td><td></td><td></td><td></td></tr><tr><td>OD Shape</td><td>(128,16,16)</td><td>(96,16,16)</td><td>(192,16,16)</td><td>(192,32,32)</td></tr><tr><td>Conv (fs=4, s=1, p=1)</td><td>128</td><td>96</td><td>192</td><td>192</td></tr><tr><td>Conv (fs=4, s=1, p=1)</td><td></td><td></td><td></td><td>192</td></tr><tr><td> Output Shape</td><td>(128,16,16)</td><td>(96,16,16)</td><td>(192,16,16)</td><td>(192,32,32)</td></tr><tr><td>Global Pathway</td><td></td><td></td><td></td><td></td></tr><tr><td>Conv (fs=4, s=2, p=1)</td><td>64</td><td>48</td><td>96</td><td>96</td></tr><tr><td>Conv (fs=4, s=2, p=1)</td><td>128</td><td>96</td><td>192</td><td>192</td></tr><tr><td>Conv (fs=4, s=2, p=1)</td><td></td><td></td><td></td><td>384</td></tr><tr><td> Output Shape</td><td>(128,16,16)</td><td>(96,16,16)</td><td>(192,16,16)</td><td>(384,32,32)</td></tr><tr><td>Concat outputs of object</td><td>(256,16,16)</td><td>(192,16,16)</td><td>(384,16,16)</td><td>(576,32,32)</td></tr><tr><td> and global pathways</td><td>256</td><td></td><td></td><td></td></tr><tr><td>Conv (fs=4, s=2, p=1) Conv (fs=4, s=2, p=1)</td><td>512</td><td>192</td><td>384 768</td><td>768</td></tr><tr><td>Conv (fs=4, s=2, p=1)</td><td></td><td>384</td><td></td><td>1,536 3,072</td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Conv (fs=3, s=1,p=1)</td><td></td><td></td><td></td><td>1,536</td></tr><tr><td>Conv (fs=3, s=1,p=1)</td><td></td><td></td><td></td><td>768</td></tr><tr><td>Concat with</td><td>(522,4,4)</td><td>(397,4,4)</td><td>(896,4,4)</td><td>(896,4,4)</td></tr><tr><td>conditioning vector Conv (fs=3, s=1, p=1)</td><td>512</td><td>384</td><td>768</td><td>768</td></tr></table>
+Table 2: Overview of the individual layers used in our networks to generate images of resolution $6 4 \times 6 4 / 2 5 6 \times 2 5 6$ pixels. Values in brackets $( C , H , W )$ represent the tensor’s shape. Numbers in the columns after convolutional, residual, or dense layers describe the number of filters / units in that layer. $\scriptstyle ( \mathbf { f s } = x , \mathbf { s } = y , \mathbf { p } = z )$ describes filter size, stride, and padding for that convolutional / residual layer.
+# B ADDITIONAL EXAMPLES OF MULTI-MNIST RESULTS: TRAINING AND TEST SET OVER COMPLEMENTARY REGIONS
+![](images/28e93a0c75c554c0c656bb190f886f6ffde0dde485bfd94e67c834b6190c8f87.jpg)
+Figure 6: Systematic test of digits over vertically different regions. Training set included three normal-sized digits only in the top half of the image. Highlighted bounding boxes and yellow ground truth for visualization. We can see that the model fails to generate recognizable digits once their location is too far in the bottom half of the image, as this location was never observed during training.
+# C ADDITIONAL EXAMPLES OF MS-COCO RESULTS: STACKGAN
+Figure 7 shows results of text-to-image synthesis on the MS-COCO data set with the StackGAN architecture. Rows A show the original image and image caption, rows B show the images generated by our StackGAN $^ +$ Object Pathway and the given bounding boxes for visualization, and rows C show images generated by the original StackGAN (pretrained model obtained from https: //github.com/hanzhanggit/StackGAN-Pytorch). The last block of examples (last row) show typical failure cases of our model, where there is no bounding box for the foreground object present. As a result our model only generates the background, without the appropriate foreground object, even though the foreground object is very clearly described in the image caption. Figure 9 provides similar results but for random bounding box positions. The first six examples show images generated by our StackGAN where we changed the location and size of the respective bounding boxes. The last three examples show failure cases in which we changed the location of the bounding boxes to “unusual” locations. For the image with the child on the bike, we put the bounding box of the bike somewhere in the top half of the image and the bounding box for the child somewhere in the bottom part. Similarly, for the man sitting on a bench, we put the bench in the top and the man in the bottom half of the image. Finally, for the image depicting a pizza on a plate, we put the plate location in the top half of the image and the pizza in the bottom half.
+# D ADDITIONAL EXAMPLES OF MS-COCO RESULTS: ATTNGAN
+Figure 8 shows results of text-to-image synthesis on the MS-COCO data set with the AttnGAN architecture. Rows A show the original image and image caption, rows B show the images generated by our AttnGAN $^ +$ Object Pathway and the given bounding boxes for visualization, and rows C show images generated by the original AttnGAN (pretrained model obtained from https: //github.com/taoxugit/AttnGAN). The last block of examples (last row) show typical failure cases, in which the model does generate the appropriate object within the bounding box, but also places the same object at multiple other locations within the image. Similarly as for StackGAN, Figure 10 shows images generated by our AttnGAN where we randomly change the location of the various bounding boxes. Again, the last three examples show failure cases where we put the locations of the bounding boxes at “uncommon” positions. In the image depicting the sandwiches we put the location of the plate in the top half of the image, in the image with the dogs we put the dogs’ location in the top half, and in the image with the motorbike we put the human in the left half and the motorbike in the right half of the image.
+![](images/664453153211417de0248a52af7600231adcfd38c67addcf35aba7f895de2d88.jpg)
+Figure 7: Additional StackGAN examples – refer to page 17 for information about the figure.
+![](images/29498a6b144e65acaf98e0663098a38c20429db5742e13e5287e4a9ebb84a25d.jpg)
+Figure 8: Additional AttnGAN examples – refer to page 17 for more information about the figure.
+![](images/fb6fc463bd22fca65ef30c87b255a971690f371444a47abf0d2590d953172b8b.jpg)
+Figure 9: StackGAN examples with random locations – refer to page 17 for more information.
+![](images/899d938a8a58ac7f554099420a1e7368902ad8dc4626971c650096a11e1d695a.jpg)
+Figure 10: AttnGAN examples with random locations – refer to page 17 for more information.
+<table><tr><td rowspan=1 colspan=1>Label</td><td rowspan=1 colspan=1>Occurrences</td><td rowspan=1 colspan=1>Words in captions</td></tr><tr><td rowspan=4 colspan=1>PersonDining table</td><td rowspan=1 colspan=1>13773</td><td rowspan=5 colspan=1>person,people,human,man,men,woman,women,childtable, deskcar,auto, vehicle,cab</td></tr><tr><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>3130</td></tr><tr><td rowspan=1 colspan=1>Car</td><td rowspan=1 colspan=1>1694</td></tr><tr><td rowspan=1 colspan=1>Cat</td><td rowspan=1 colspan=1>1658</td><td rowspan=1 colspan=1>cat</td></tr><tr><td rowspan=1 colspan=1>Dog</td><td rowspan=1 colspan=1>1543</td><td rowspan=1 colspan=1>dog</td></tr><tr><td rowspan=1 colspan=1>Bus</td><td rowspan=1 colspan=1>1198</td><td rowspan=1 colspan=1>bus</td></tr><tr><td rowspan=1 colspan=1>Train</td><td rowspan=1 colspan=1>1188</td><td rowspan=1 colspan=1>train</td></tr><tr><td rowspan=1 colspan=1>Bed</td><td rowspan=1 colspan=1>984</td><td rowspan=1 colspan=1>bed</td></tr><tr><td rowspan=1 colspan=1>Pizza</td><td rowspan=1 colspan=1>906</td><td rowspan=1 colspan=1>pizza</td></tr><tr><td rowspan=1 colspan=1>Horse</td><td rowspan=1 colspan=1>874</td><td rowspan=1 colspan=1>horse</td></tr><tr><td rowspan=1 colspan=1>Giraffe</td><td rowspan=1 colspan=1>828</td><td rowspan=1 colspan=1>giraffe</td></tr><tr><td rowspan=1 colspan=1>Toilet</td><td rowspan=1 colspan=1>797</td><td rowspan=1 colspan=1>toilet</td></tr><tr><td rowspan=1 colspan=1>Bear</td><td rowspan=1 colspan=1>777</td><td rowspan=1 colspan=1>bear</td></tr><tr><td rowspan=1 colspan=1>Bench</td><td rowspan=1 colspan=1>732</td><td rowspan=1 colspan=1>bench</td></tr></table>
+Table 3: Words that were used to identify given labels in the image caption for the YOLOv3 object detection test.
+<table><tr><td>Label</td><td>Occurrences</td><td>Words in captions</td></tr><tr><td>Umbrella</td><td>727</td><td>umbrella</td></tr><tr><td>Elephant</td><td>708</td><td>elephant</td></tr><tr><td>Chair</td><td>632</td><td>chair, stool</td></tr><tr><td>Zebra</td><td>627</td><td>zebra</td></tr><tr><td>Boat</td><td>627</td><td>boat</td></tr><tr><td>Bird</td><td>610</td><td>bird</td></tr><tr><td>Aeroplane</td><td>602</td><td>plane</td></tr><tr><td>Bicycle</td><td>600</td><td>bicycle</td></tr><tr><td>Surfboard</td><td>595</td><td>surfboard</td></tr><tr><td>Kite</td><td>593</td><td>kite</td></tr><tr><td>Truck</td><td>561</td><td>truck</td></tr><tr><td>Stop sign</td><td>522</td><td>stop</td></tr><tr><td>TV Monitor</td><td>471</td><td>tv,monitor, screen</td></tr><tr><td>Sofa</td><td>467</td><td>sofa, couch</td></tr><tr><td>Sandwich</td><td>387</td><td>sandwich</td></tr><tr><td>Sheep</td><td>368</td><td>sheep</td></tr></table>
+# E OBJECT DETECTION ON MS-COCO IMAGES
+To further inspect the quality of the location and recognizability of the generated objects within an image, we ran a test on object detection using a YOLOv3 network Redmon & Farhadi (2018) that was also pretrained on the MS-COCO data set9. We use the Pytorch implementation from https://github.com/ayooshkathuria/pytorch-yolo-v3 to get the bounding box and label predictions for our images. We follow the standard guidelines and keep all hyperparameters for the YOLOv3 network as in the implementation. We picked the 30 most common training labels (based on how many captions contain these labels) and evaluate the models on these labels, see Table 3.
+In the following, we evaluate how often the pretrained YOLOv3 network recognizes a specific object within a generated image that should contain this object based on the image caption. For example, we expect an image generated from the caption “a young woman taking a picture with her phone” to contain a person somewhere in the image and we check whether the YOLOv3 network actually recognizes a person in the generated image. Since the baseline StackGAN and AttnGAN only receive the image caption as input (no bounding boxes and no bounding box labels) we decided to only use captions that clearly imply the presence of the given label (see Table 3). We chose this strategy in order to allow for a fair comparison of the resulting presence or absence of a given object. Specifically, for a given label we choose all image captions from the test set that contain one of the associated words for this label (associated words were chosen manually, see Table 3) and then generated three images for each caption with each model. Finally, we counted the number of images in which the given object was detected by the YOLOv3 network. Table 4 shows the ratio of images for each label and each model in which the given object was detected at any location within the image.
+Additionally, for our models that also receive the bounding boxes as input, we calculated the Intersection over Union (IoU) between the ground truth bounding box (the bounding box supplied to the model) and the bounding box predicted by the YOLOv3 network for the recognized object. Table 4 presents the average IoU (for the models that have an object pathway) for each object in the images in which YOLOv3 detected the given object. For each image in which YOLOv3 detected the given object, we calculated the IoU between the predicted bounding box and the ground truth bounding box for the given object. In the cases in which either an image contains multiple instances of the given object (i.e. multiple different bounding boxes for this object were given to the generator) or YOLOv3 detects the given object multiple times we used the maximum IoU between all predicted and ground truth bounding boxes for our statistics.
+![](images/5fe525623a2030a61e5e3b26302412c1690b0c3b7bb3a2082c72c5ce8e1cf86d.jpg)
+Figure 11: Distribution of recall and IoU values in the YOLOv3 object detection test.
+Figure 11 visualizes how the IoU and recall values are distributed for the different models, and Table 4 summarizes the results with the 30 tested labels. We can observe that the StackGAN with object pathway outperforms the original StackGAN when comparing the recall of the YOLOv3 network, i.e. in how many images with a given label the YOLOv3 network actually detected the given object. The recall of the original StackGAN is higher than $1 0 \%$ for $2 6 . 7 \%$ of the labels, while our StackGAN with object pathway results in a recall greater than $1 0 \%$ for $6 0 \%$ of the labels. The IoU is greater than 0.3 for every label, while $8 6 . 7 \%$ of the labels result an IoU of greater than 0.5 (original images: $1 0 0 \%$ ) and $3 0 \%$ have an IoU of greater than 0.7 (original images: $9 6 . 7 \%$ ). This indicates that we can indeed control the location and identity of various objects within the generated images.
+Compared to the StackGAN, the AttnGAN achieves a much greater recall, with $8 0 \%$ and $8 3 . 3 \%$ of the labels having a recall of greater than $1 0 \%$ for the original AttnGAN and the AttnGAN with object pathway respectively. The difference in recall values between the original AttnGAN and the AttnGAN with object pathway is also smaller, with our AttnGAN having a higher (lower) recall than the original AttnGAN (we only count cases where the difference is at least $5 \%$ ) in $2 6 . 7 \%$ $( 1 3 . 3 \% )$ of the labels. The average IoU, on the other hand, is a lot smaller for the AttnGAN than for the StackGAN. We only achieve an IoU greater than 0.3 (0.5, 0.7) for $5 3 . 3 \%$ $( 3 . 3 \% , 0 \% )$ of the labels. As mentioned in the discussion (subsection 4.4), we attribute this to the observation that the AttnGAN tends to place seemingly recognizable features of salient objects at arbitrary locations throughout the image. This might attribute to the overall higher recall but may negatively affect the IoU.
+Overall, these results further confirm our previous experiments and highlight that the addition of the object pathway to the different models does not only enable the direct control of object location and identity but can also help to increase the image quality. The increase in image quality is supported by a higher Inception Score, lower Frechet Inception Distance (for StackGAN) and a higher performance ´ of the YOLOv3 network in detecting objects within generated images.
+Table 4: Results of YOLOv3 detections on generated and original images. Recall provides the fraction of images in which YOLOv3 detected the given object. IoU (Intersection over Union) measures the maximum IoU per image in which the given object was detected.
+<table><tr><td rowspan=2 colspan=1>Label</td><td rowspan=2 colspan=2>Orig. Img.Recall IoU</td><td rowspan=2 colspan=1>StackGANRecall</td><td rowspan=2 colspan=2>StackGAN+ OPRecall       IoU</td><td rowspan=1 colspan=1>AttnGAN</td><td rowspan=2 colspan=2>AttnGAN + OPRecall       IoU</td></tr><tr><td rowspan=1 colspan=1>Recall</td></tr><tr><td rowspan=1 colspan=1>Person</td><td rowspan=1 colspan=1>.943</td><td rowspan=1 colspan=1>.824</td><td rowspan=1 colspan=1>.355</td><td rowspan=1 colspan=1>.451± .019</td><td rowspan=1 colspan=1>.624± .012</td><td rowspan=1 colspan=1>.598</td><td rowspan=1 colspan=1>.610 ± .008</td><td rowspan=1 colspan=1>.276 ± .006</td></tr><tr><td rowspan=1 colspan=1>Dining table</td><td rowspan=1 colspan=1>.355</td><td rowspan=1 colspan=1>.774</td><td rowspan=1 colspan=1>.007</td><td rowspan=1 colspan=1>.022 ± .004</td><td rowspan=1 colspan=1>.734± .011</td><td rowspan=1 colspan=1>.069</td><td rowspan=1 colspan=1>.045± .022</td><td rowspan=1 colspan=1>.490 ± .018</td></tr><tr><td rowspan=1 colspan=1>Car</td><td rowspan=1 colspan=1>.433</td><td rowspan=1 colspan=1>.792</td><td rowspan=1 colspan=1>.012</td><td rowspan=1 colspan=1>.047± .007</td><td rowspan=1 colspan=1>.622 ± .020</td><td rowspan=1 colspan=1>.006</td><td rowspan=1 colspan=1>.063± .010</td><td rowspan=1 colspan=1>.144 ± .043</td></tr><tr><td rowspan=1 colspan=1>Cat</td><td rowspan=1 colspan=1>.715</td><td rowspan=1 colspan=1>.821</td><td rowspan=1 colspan=1>.021</td><td rowspan=1 colspan=1>.104± .100</td><td rowspan=1 colspan=1>.622 ± .008</td><td rowspan=1 colspan=1>.423</td><td rowspan=1 colspan=1>.430± .066</td><td rowspan=1 colspan=1>.350 ± .012</td></tr><tr><td rowspan=1 colspan=1>Dog</td><td rowspan=1 colspan=1>.703</td><td rowspan=1 colspan=1>.819</td><td rowspan=1 colspan=1>.068</td><td rowspan=1 colspan=1>.150± .007</td><td rowspan=1 colspan=1>.601 ± .004</td><td rowspan=1 colspan=1>.450</td><td rowspan=1 colspan=1>.488± .048</td><td rowspan=1 colspan=1>.311 ± .007</td></tr><tr><td rowspan=1 colspan=1>Bus</td><td rowspan=1 colspan=1>.747</td><td rowspan=1 colspan=1>.877</td><td rowspan=1 colspan=1>.161</td><td rowspan=1 colspan=1>.393 ± .031</td><td rowspan=1 colspan=1>.794± .009</td><td rowspan=1 colspan=1>.352</td><td rowspan=1 colspan=1>.416± .032</td><td rowspan=1 colspan=1>.374± .006</td></tr><tr><td rowspan=1 colspan=1>Train</td><td rowspan=1 colspan=1>.900</td><td rowspan=1 colspan=1>.835</td><td rowspan=1 colspan=1>.133</td><td rowspan=1 colspan=1>.310 ± .033</td><td rowspan=1 colspan=1>.700± .007</td><td rowspan=1 colspan=1>.393</td><td rowspan=1 colspan=1>.438 ± .110</td><td rowspan=1 colspan=1>.355 ± .036</td></tr><tr><td rowspan=1 colspan=1>Bed</td><td rowspan=1 colspan=1>.775</td><td rowspan=1 colspan=1>.789</td><td rowspan=1 colspan=1>.032</td><td rowspan=1 colspan=1>.141 ± .018</td><td rowspan=1 colspan=1>.701± .001</td><td rowspan=1 colspan=1>.539</td><td rowspan=1 colspan=1>.552± .030</td><td rowspan=1 colspan=1>.505 ± .002</td></tr><tr><td rowspan=1 colspan=1>Pizza</td><td rowspan=1 colspan=1>.912</td><td rowspan=1 colspan=1>.842</td><td rowspan=1 colspan=1>.119</td><td rowspan=1 colspan=1>.485 ± .101</td><td rowspan=1 colspan=1>.786 ± .004</td><td rowspan=1 colspan=1>.444</td><td rowspan=1 colspan=1>.660 ± .054</td><td rowspan=1 colspan=1>.395 ± .016</td></tr><tr><td rowspan=1 colspan=1>Horse</td><td rowspan=1 colspan=1>.933</td><td rowspan=1 colspan=1>.842</td><td rowspan=1 colspan=1>.129</td><td rowspan=1 colspan=1>.330 ± .048</td><td rowspan=1 colspan=1>.585± .039</td><td rowspan=1 colspan=1>.532</td><td rowspan=1 colspan=1>.619± .027</td><td rowspan=1 colspan=1>.300 ± .006</td></tr><tr><td rowspan=1 colspan=1>Giraffe</td><td rowspan=1 colspan=1>.972</td><td rowspan=1 colspan=1>.857</td><td rowspan=1 colspan=1>.173</td><td rowspan=1 colspan=1>.467 ± .035</td><td rowspan=1 colspan=1>.606 ± .030</td><td rowspan=1 colspan=1>.472</td><td rowspan=1 colspan=1>.650± .084</td><td rowspan=1 colspan=1>.365 ± .030</td></tr><tr><td rowspan=1 colspan=1>Toilet</td><td rowspan=1 colspan=1>.898</td><td rowspan=1 colspan=1>.826</td><td rowspan=1 colspan=1>.005</td><td rowspan=1 colspan=1>.122 ± .021</td><td rowspan=1 colspan=1>.690 ± .010</td><td rowspan=1 colspan=1>.201</td><td rowspan=1 colspan=1>.220± .021</td><td rowspan=1 colspan=1>.224± .011</td></tr><tr><td rowspan=1 colspan=1>Bear</td><td rowspan=1 colspan=1>.381</td><td rowspan=1 colspan=1>.859</td><td rowspan=1 colspan=1>.015</td><td rowspan=1 colspan=1>.120 ± .018</td><td rowspan=1 colspan=1>.720 ± .036</td><td rowspan=1 colspan=1>.319</td><td rowspan=1 colspan=1>.303±.028</td><td rowspan=1 colspan=1>.357 ± .010</td></tr><tr><td rowspan=1 colspan=1>Bench</td><td rowspan=1 colspan=1>.828</td><td rowspan=1 colspan=1>.798</td><td rowspan=1 colspan=1>.001</td><td rowspan=1 colspan=1>.030 ± .008</td><td rowspan=1 colspan=1>.627± .034</td><td rowspan=1 colspan=1>.094</td><td rowspan=1 colspan=1>.094± .031</td><td rowspan=1 colspan=1>.308 ± .018</td></tr><tr><td rowspan=1 colspan=1>Umbrella</td><td rowspan=1 colspan=1>.912</td><td rowspan=1 colspan=1>.762</td><td rowspan=1 colspan=1>.001</td><td rowspan=1 colspan=1>.023± .009</td><td rowspan=1 colspan=1>.578 ± .030</td><td rowspan=1 colspan=1>.060</td><td rowspan=1 colspan=1>.063± .017</td><td rowspan=1 colspan=1>.154± .053</td></tr><tr><td rowspan=1 colspan=1>Elephant</td><td rowspan=1 colspan=1>.940</td><td rowspan=1 colspan=1>.867</td><td rowspan=1 colspan=1>.060</td><td rowspan=1 colspan=1>.414± .069</td><td rowspan=1 colspan=1>.688 ± .033</td><td rowspan=1 colspan=1>.350</td><td rowspan=1 colspan=1>.500± .141</td><td rowspan=1 colspan=1>.353 ± .006</td></tr><tr><td rowspan=1 colspan=1>Chair</td><td rowspan=1 colspan=1>.757</td><td rowspan=1 colspan=1>.755</td><td rowspan=1 colspan=1>.014</td><td rowspan=1 colspan=1>.039 ± .004</td><td rowspan=1 colspan=1>.488 ± .039</td><td rowspan=1 colspan=1>.070</td><td rowspan=1 colspan=1>.093 ± .005</td><td rowspan=1 colspan=1>.225 ± .001</td></tr><tr><td rowspan=1 colspan=1>Zebra</td><td rowspan=1 colspan=1>.972</td><td rowspan=1 colspan=1>.875</td><td rowspan=1 colspan=1>.732</td><td rowspan=1 colspan=1>.781± .023</td><td rowspan=1 colspan=1>.686 ± .017</td><td rowspan=1 colspan=1>.870</td><td rowspan=1 colspan=1>.766± .063</td><td rowspan=1 colspan=1>.315 ± .022</td></tr><tr><td rowspan=1 colspan=1>Boat</td><td rowspan=1 colspan=1>.795</td><td rowspan=1 colspan=1>.709</td><td rowspan=1 colspan=1>.077</td><td rowspan=1 colspan=1>.010± .011</td><td rowspan=1 colspan=1>.594± .021</td><td rowspan=1 colspan=1>.168</td><td rowspan=1 colspan=1>.202 ± .027</td><td rowspan=1 colspan=1>.206 ± .020</td></tr><tr><td rowspan=1 colspan=1>Bird</td><td rowspan=1 colspan=1>.837</td><td rowspan=1 colspan=1>.781</td><td rowspan=1 colspan=1>.059</td><td rowspan=1 colspan=1>.097± .027</td><td rowspan=1 colspan=1>.500 ± .066</td><td rowspan=1 colspan=1>.322</td><td rowspan=1 colspan=1>.357 ± .042</td><td rowspan=1 colspan=1>.250 ± .020</td></tr><tr><td rowspan=1 colspan=1>Aeroplane</td><td rowspan=1 colspan=1>.912</td><td rowspan=1 colspan=1>.812</td><td rowspan=1 colspan=1>.125</td><td rowspan=1 colspan=1>.223 ± .043</td><td rowspan=1 colspan=1>.667± .026</td><td rowspan=1 colspan=1>.499</td><td rowspan=1 colspan=1>.415 ± .010</td><td rowspan=1 colspan=1>.320 ± .035</td></tr><tr><td rowspan=1 colspan=1>Bicycle</td><td rowspan=1 colspan=1>.825</td><td rowspan=1 colspan=1>.760</td><td rowspan=1 colspan=1>.007</td><td rowspan=1 colspan=1>.053 ± .020</td><td rowspan=1 colspan=1>.558 ± .052</td><td rowspan=1 colspan=1>.170</td><td rowspan=1 colspan=1>.191± .013</td><td rowspan=1 colspan=1>.233 ± .024</td></tr><tr><td rowspan=1 colspan=1>Surfboard</td><td rowspan=1 colspan=1>.873</td><td rowspan=1 colspan=1>.780</td><td rowspan=1 colspan=1>.030</td><td rowspan=1 colspan=1>.067 ± .019</td><td rowspan=1 colspan=1>.459 ± .056</td><td rowspan=1 colspan=1>.104</td><td rowspan=1 colspan=1>.110± .025</td><td rowspan=1 colspan=1>.143 ± .016</td></tr><tr><td rowspan=1 colspan=1>Kite</td><td rowspan=1 colspan=1>.772</td><td rowspan=1 colspan=1>.633</td><td rowspan=1 colspan=1>.029</td><td rowspan=1 colspan=1>.057± .028</td><td rowspan=1 colspan=1>.426 ± .086</td><td rowspan=1 colspan=1>.260</td><td rowspan=1 colspan=1>.162 ± .068</td><td rowspan=1 colspan=1>.120 ± .018</td></tr><tr><td rowspan=1 colspan=1>Truck</td><td rowspan=1 colspan=1>.887</td><td rowspan=1 colspan=1>.832</td><td rowspan=1 colspan=1>.082</td><td rowspan=1 colspan=1>.243 ± .062</td><td rowspan=1 colspan=1>.717 ± .022</td><td rowspan=1 colspan=1>.378</td><td rowspan=1 colspan=1>.367± .027</td><td rowspan=1 colspan=1>.393 ± .019</td></tr><tr><td rowspan=1 colspan=1>Stop Sign</td><td rowspan=1 colspan=1>.527</td><td rowspan=1 colspan=1>.874</td><td rowspan=1 colspan=1>.001</td><td rowspan=1 colspan=1>.261± .057</td><td rowspan=1 colspan=1>.780 ± .011</td><td rowspan=1 colspan=1>.070</td><td rowspan=1 colspan=1>.124± .048</td><td rowspan=1 colspan=1>.101± .014</td></tr><tr><td rowspan=1 colspan=1>TV Monitor</td><td rowspan=1 colspan=1>.818</td><td rowspan=1 colspan=1>.833</td><td rowspan=1 colspan=1>.037</td><td rowspan=1 colspan=1>.264± .005</td><td rowspan=1 colspan=1>.765 ± .016</td><td rowspan=1 colspan=1>.529</td><td rowspan=1 colspan=1>.435 ± .314</td><td rowspan=1 colspan=1>.243± .066</td></tr><tr><td rowspan=1 colspan=1>Sofa</td><td rowspan=1 colspan=1>.878</td><td rowspan=1 colspan=1>.794</td><td rowspan=1 colspan=1>.012</td><td rowspan=1 colspan=1>.087 ± .024</td><td rowspan=1 colspan=1>.628 ± .044</td><td rowspan=1 colspan=1>.170</td><td rowspan=1 colspan=1>.191 ± .057</td><td rowspan=1 colspan=1>.329 ± .028</td></tr><tr><td rowspan=1 colspan=1>Sandwich</td><td rowspan=1 colspan=1>.792</td><td rowspan=1 colspan=1>.796</td><td rowspan=1 colspan=1>.045</td><td rowspan=1 colspan=1>.139 ± .049</td><td rowspan=1 colspan=1>.628 ± .014</td><td rowspan=1 colspan=1>.340</td><td rowspan=1 colspan=1>.370± .054</td><td rowspan=1 colspan=1>.318 ± .031</td></tr><tr><td rowspan=1 colspan=1>Sheep</td><td rowspan=1 colspan=1>.943</td><td rowspan=1 colspan=1>.727</td><td rowspan=1 colspan=1>.004</td><td rowspan=1 colspan=1>.091± .006</td><td rowspan=1 colspan=1>.460 ± .011</td><td rowspan=1 colspan=1>.250</td><td rowspan=1 colspan=1>.304± .037</td><td rowspan=1 colspan=1>.116 ± .022</td></tr></table>

parse/train/H1edIiA9KQ/H1edIiA9KQ_content_list.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/H1edIiA9KQ/H1edIiA9KQ_middle.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/H1edIiA9KQ/H1edIiA9KQ_model.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/SyxZOsA9tX/SyxZOsA9tX_content_list.json ADDED Viewed

	@@ -0,0 +1,1748 @@

+[
+    {
+        "type": "text",
+        "text": "ACCELERATED VALUE ITERATION VIA ANDERSON MIXING ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            116,
+            851,
+            137
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            156,
+            161,
+            372,
+            189
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            226,
+            544,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Acceleration for reinforcement learning methods is an important and challenging theme. We introduce the Anderson acceleration technique into the value iteration, developing an accelerated value iteration algorithm that we call Anderson Accelerated Value Iteration (A2VI). We further apply our method to the Deep Q-learning algorithm, resulting in the Deep Anderson Accelerated Q-learning (DA2Q) algorithm. Our approach can be viewed as an approximation of the policy evaluation by interpolating on historical data. A2VI is more efficient than the modified policy iteration, which is a classical approximate method for policy evaluation. We give theoretical analysis of our algorithm and conduct experiments on both toy problems and Atari games. Both the theoretical and empirical results show the effectiveness of our algorithm. ",
+        "bbox": [
+            207,
+            258,
+            792,
+            398
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            428,
+            310,
+            444
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In reinforcement learning (Sutton & Barto, 1998), an agent seeks for the optimal policy in a specific sequential decision problem. Several algorithms have been proposed over the course of time, including the famous Q-learning (Watkins & Dayan, 1992), SARSA (Rummery & Niranjan, 1994; Sutton & Barto, 1998), and policy gradient methods (Sutton et al., 2000). In complicated decision problems where tabular representations are intractable, function approximations are usually used for estimating state-action values (Kaelbling et al., 1996; Sutton & Barto, 1998; Sutton et al., 2000). Inspired by the success of deep learning, Deep Q-Learning (DQN) (Mnih et al., 2013) and its variants (Bellemare et al., 2017; Schaul et al., 2015; Van Hasselt et al., 2016; Wang et al., 2015) utilize a deep neural network as the value approximator, which has successfully solved end-to-end decision problems such as Atari2000. ",
+        "bbox": [
+            148,
+            460,
+            851,
+            585
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The value iteration (VI) Bellman (1957) and policy iteration (PI) (Howard, 1964) are the most classical methods for value updating. The main difference between them is that PI evaluate the current policy accurately during the iteration while VI does not. Thanks to the accurate evaluation of the current policy, policy iteration uses significantly less policy improvement steps to converge to the optimal value. Although PI has a faster convergence rate than VI, most of the existing methods employ a rather slow value iteration procedure, because thoroughly evaluating a policy is costly or even intractable under complex environments. To retain the fast convergence property of policy iteration while reducing its computation overhead, researchers have proposed several modifications to the original policy iteration (Alla et al., 2015; Puterman, 1994). The modified policy iteration (MPI) method (Puterman, 1994) tries to deal with this problem by approximating the solution to policy evaluation via the truncated Neumann expansion of an inverse matrix. However, this approximation requires extra iterative steps, which is still computationally inefficient for complex decision problems where sampling is costly, compared with the value iteration procedure where the policy iteration step is skipped. ",
+        "bbox": [
+            148,
+            592,
+            851,
+            773
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Interpolation methods have been widely used in first order optimization problems (Bubeck et al., 2015; Scieur et al., 2016; 2017; Xie et al., 2018). These methods extract information from historical data and are proven to converge faster than vanilla gradient methods. However, the interpolation method is not widely applied in reinforcement learning. The most recent work related to interpolation is the averaged-DQN (Anschel et al., 2016), which calculates the average Q-value over the history and demonstrated that such an operation is effective for variance reduction. ",
+        "bbox": [
+            148,
+            780,
+            849,
+            821
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            119,
+            851,
+            162
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Acceleration in value iteration and policy iteration has attracted researchers’ great attention. Classical methods for accelerating value iteration include Gauss-Seidel value iteration (Puterman, 1994) and Jacobi value iteration (JAC) (Puterman, 1994). More recently, Alla et al. (2015) proposed an acceleration method that switches between a coarse-mesh value iteration and a fine-mesh policy iteration during different stages. Laurini et al. (2016) performed a Jacobi-like acceleration method on dynamic programming problems. In a recent work (Laurini et al., 2017), the value iteration procedure is accelerated by only updating a part of the values. None of the previous methods have proposed acceleration methods with an application of interpolation. ",
+        "bbox": [
+            147,
+            169,
+            852,
+            281
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, to solve the policy evaluation problem more efficiently, we propose an alternative algorithm based on multi-step interpolation. Explicitly, the solution to the policy evaluation problem is approximately represented by a weighted combination of historical values, whose weights are adaptively updated by an optimization procedure. To reduce the computational complexity, we resort to the Anderson mixing method (Anderson, 1965; Walker & Ni, 2011; Toth & Kelley, 2015) to do the approximation with only a short length of history. Our approach fits the gap between value iteration and policy iteration, ending in an updating rule without adding much extra computational complexity to the original value iteration procedure. We also extend this approach to deep reinforcement learning problems. ",
+        "bbox": [
+            147,
+            287,
+            851,
+            400
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The remainder of this paper is organized as follows. In Section 2, we introduce the foundations of reinforcement learning and present typical value updating algorithms. In Section 3, we derive the Anderson accelerated methods. In Section 4, we give a theoretical analysis of the convergence of our method. In Section 5, we test our method in different environments and empirically show the effectiveness of it. Finally, we conclude our work in Section 6. ",
+        "bbox": [
+            148,
+            405,
+            851,
+            476
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            502,
+            312,
+            517
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper we mainly consider a finite-state and finite-action scenario in reinforcement learning. In this case, an Markov Decision Process (MDP) system is defined by a 5-tuple $( S , { \\mathcal { A } } , P , r , \\gamma )$ , where $s$ is a finite state space, $\\mathcal { A }$ is a finite action space, $P \\in \\mathbb { R } ^ { ( | S | \\times | A | ) \\times | S | }$ is the collection of state-to-state transition probabilities, $\\pmb { r } \\in \\mathbb { R } ^ { | S | \\times | \\mathcal { A } | }$ is the reward matrix, $\\gamma$ is the discount factor. A policy $\\pi \\in { \\mathcal { A } } ^ { | s | }$ is a vector of actions at each state. The transition matrix $P _ { \\pi } \\in \\mathbb { R } ^ { | S | \\times | S | }$ and reward vector $\\boldsymbol { r } _ { \\pi } \\in \\mathbb { R } ^ { | \\boldsymbol { S } | }$ under policy $\\pi$ are defined as $P _ { \\pi } ( i , j ) = P ( ( i , \\pi ( i ) ) , j ) , r _ { \\pi } ( i ) = r ( i , \\pi ( i ) )$ . We further define the value $\\pmb { v } ^ { \\pi } \\in \\mathbb { R } ^ { | \\mathcal { S } | }$ and the $\\mathbf { Q }$ -value $\\pmb { q } ^ { \\pi } \\in \\mathbb { R } ^ { | S | \\times | \\mathcal { A } | }$ under a given MDP and policy, where each element of $\\pmb { v } ^ { \\pi }$ and $\\pmb q ^ { \\pi }$ is defined as ",
+        "bbox": [
+            147,
+            536,
+            852,
+            643
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/336199a50316eb6a4b35920097a0c4f52b31b45fd80c0eebef2332088e601ca4.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\pmb v } ^ { \\pi } ( s ) = \\mathbb { E } _ { s _ { 0 } = s , s _ { t + 1 } \\sim P _ { \\pi } ( s _ { t } , \\ldots ) } \\displaystyle \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } { \\pmb r } _ { \\pi } ( s _ { t } ) , } \\\\ { \\pmb q ^ { \\pi } ( s , a ) = { \\pmb r } ( s , a ) + \\mathbb { E } _ { s _ { 1 } \\sim P ( ( s , a ) , \\ldots ) , s _ { t + 1 } \\sim P _ { \\pi } ( s _ { t } , \\ldots ) } \\displaystyle \\sum _ { t = 1 } ^ { \\infty } \\gamma ^ { t } { \\pmb r } _ { \\pi } ( s _ { t } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            654,
+            714,
+            738
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We can verify that $\\pmb q ^ { \\pi } = \\pmb r + \\gamma P \\pmb v ^ { \\pi }$ . We define $\\pmb { q } _ { \\tilde { \\pi } } ^ { \\pi } \\in \\mathbb { R } ^ { | s | }$ by $\\pmb { q } _ { \\tilde { \\pi } } ^ { \\pi } ( i ) = \\pmb { q } ^ { \\pi } ( i , \\tilde { \\pi } ( i ) )$ , and say a vector to be the maximum among a set if each entry of it is bigger than that of the other vectors. The values satisfy the Bellman equation: ",
+        "bbox": [
+            147,
+            757,
+            849,
+            801
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d3dd746afb2ccd092db06e09199b0fed001601586e485ded9e1053c374a88ff8.jpg",
+        "text": "$$\n\\pmb { v } ^ { \\pi } = \\Gamma _ { \\pi } \\big ( \\pmb { v } ^ { \\pi } \\big ) = \\pmb { r } _ { \\pi } + \\gamma P _ { \\pi } \\pmb { v } ^ { \\pi } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            806,
+            599,
+            824
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The policy $\\pi ^ { * } = \\arg \\operatorname* { m a x } _ { \\pi } { \\pmb q } ^ { \\pi }$ is called the optimal policy, whose value or $\\mathrm { Q }$ -value is denoted as $v ^ { * }$ or $\\pmb q ^ { * }$ . Note that $v ^ { * }$ satisfies the Bellman optimality equation ",
+        "bbox": [
+            145,
+            119,
+            856,
+            148
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1257573ef1b9e90697a2f182499ca5a697f1d4080e6472ab3f7fd329bfa1ce61.jpg",
+        "text": "$$\n\\pmb { v } ^ { * } = \\Gamma ( \\pmb { v } ^ { * } ) = \\operatorname* { m a x } _ { \\pi } ( \\pmb { r } _ { \\pi } + \\gamma P _ { \\pi } \\pmb { v } ^ { * } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            154,
+            617,
+            176
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Therefore, finding the optimal policy is equivalent to finding the fixed point of the operator $\\Gamma ( v )$ . ",
+        "bbox": [
+            148,
+            188,
+            781,
+            204
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 FIXED POINT ITERATION METHODS ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            219,
+            436,
+            234
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Value iteration (VI) is the most widely used and best-understood algorithm for solving Markov decision problems. It solves the fixed point problem by iterating the following steps repeatedly, ",
+        "bbox": [
+            145,
+            246,
+            852,
+            275
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1a0de05e65cb1e1d02f1eb640e40c54ec23cc1c9ec9679f9493ced5269e3b872.jpg",
+        "text": "$$\n\\pmb { v } ^ { ( t + 1 ) } = \\Gamma ( \\pmb { v } ^ { ( t ) } ) = \\operatorname* { m a x } _ { \\pi } ( \\pmb { r } _ { \\pi } + \\gamma P _ { \\pi } \\pmb { v } ^ { ( t ) } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            279,
+            637,
+            304
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An alternative solution is policy iteration (PI), which maintains both the value ${ \\pmb v } ^ { ( t ) }$ and the policy $\\pi ^ { ( t ) }$ during each iteration. The procedure alternatively iterates the following two steps: ",
+        "bbox": [
+            147,
+            318,
+            849,
+            348
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Policy evaluation: Find a ${ \\pmb v } ^ { ( t ) }$ such that ",
+        "bbox": [
+            191,
+            358,
+            465,
+            375
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e0a54ccd5eebc43139a70d85632760fa9183c8a803c7ad1166b2d5825d65edad.jpg",
+        "text": "$$\n\\pmb { v } ^ { ( t ) } = \\Gamma _ { \\pi ^ { ( t ) } } \\big ( \\pmb { v } ^ { ( t ) } \\big ) = \\pmb { r } _ { \\pi ^ { ( t ) } } + \\gamma P _ { \\pi ^ { ( t ) } } \\pmb { v } ^ { ( t ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            378,
+            663,
+            398
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "which can be directly computed by ",
+        "bbox": [
+            205,
+            404,
+            437,
+            417
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d618c3579803b9f6abb0a08d5509d77b9b71dcba8e391e7096b0c6da78a7fb44.jpg",
+        "text": "$$\n{ \\pmb v } ^ { ( t ) } = ( I - \\gamma P _ { \\pi ^ { ( t ) } } ) ^ { - 1 } { \\pmb r } _ { \\pi ^ { ( t ) } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            433,
+            422,
+            622,
+            443
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Policy improvement: Improve the current policy by ",
+        "bbox": [
+            189,
+            449,
+            545,
+            464
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4b858500cabb24839a7312ca8ceb4fc2976565fd6dcde5b8042add5d9971f91b.jpg",
+        "text": "$$\n\\pi ^ { ( t + 1 ) } = \\underset { \\pi } { \\operatorname { a r g m a x } } ( \\pmb { r } _ { \\pi } + \\gamma P _ { \\pi } \\pmb { v } ^ { ( t ) } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            468,
+            643,
+            496
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theoretical analysis has shown that VI enjoys a $\\gamma$ -linear convergence rate (i.e., $\\| \\pmb { v } ^ { ( t ) } - \\pmb { v } ^ { * } \\| _ { \\infty } \\leq \\gamma \\| \\pmb { v } ^ { ( t - 1 ) } -$ $v ^ { * } \\| _ { \\infty } )$ , while PI converges much faster with $\\| \\pmb { v } ^ { ( t ) } - \\pmb { v } ^ { * } \\| _ { \\infty } \\leq K \\| \\pmb { v } ^ { ( t - 1 ) } - \\pmb { v } ^ { * } \\| _ { \\infty } ^ { 2 }$ (Puterman, 1994), where $K$ is some constant related with $\\gamma$ and the given MDP. Both VI and PI are model-based, because the greedy policy cannot be determined when $\\mathbfit { \\Delta } \\mathbf { r }$ and $P$ are unknown. The VI under $\\pmb q$ -notation is well-known as Q-learning (Watkins & Dayan, 1992). We will analyze our method under $\\textbf {  { v } }$ -notation, but our analysis also works under the corresponding $\\pmb q$ -notation. ",
+        "bbox": [
+            147,
+            506,
+            851,
+            593
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The main difference between VI and PI is whether the current policy is fully evaluated. Though PI converges faster than VI, this advantage diminishes under several settings. In reinforcement learning, we can only access an oracle that returns the reward and next state given the current state and selected action. Under such a setting, each value iteration step can be performed by estimating $\\Gamma ( v )$ through sampling. But the policy evaluation step based on equation (2) becomes intractable because it is quite time-consuming to compute $( I - \\gamma P _ { \\pi ^ { ( t ) } } ) ^ { - \\mathbf { \\bar { 1 } } }$ . The modified policy iteration method (Puterman & Brumelle, 1978) partially solves the problem by setting ${ \\pmb v } ^ { t } \\approx ( \\Gamma _ { \\pi ^ { ( t ) } } ) ^ { m _ { t } } ( { \\pmb v } ^ { ( t - 1 ) } )$ where $m _ { t }$ is a (possibly large) integer related to $t$ . However, this method requires to evaluate a series of values $( \\Gamma _ { \\pi ^ { ( t ) } } ) ^ { i } \\big ( { \\pmb v } ^ { ( t - 1 ) } \\big )$ for $i = 1 , 2 , \\dots , m _ { t }$ , which is computationally inefficient. ",
+        "bbox": [
+            147,
+            599,
+            851,
+            729
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 ANDERSON ACCELERATED VALUE ITERATION ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            748,
+            563,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Based on the observation that full policy evaluation accelerates convergence, we propose an approximate policy evaluation method. The method aims to approximately solve the policy evaluation problem, circumventing the matrix inversion and iterative procedures mentioned above. ",
+        "bbox": [
+            148,
+            780,
+            851,
+            821
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first utilize the linearity of equation (1), defining $B _ { \\pi } ( { \\pmb v } ) \\ = \\ \\Gamma _ { \\pi } ( { \\pmb v } ) - { \\pmb v }$ and converting the problem into an equivalent form of solving the equation $B _ { \\pi } ( \\pmb { v } ) = \\mathbf { 0 }$ . Suppose we have obtained a set of values $B _ { \\pi } ( { \\pmb v } ^ { 1 } ) , B _ { \\pi } ( { \\pmb v } ^ { 2 } ) , \\ldots , B _ { \\pi } ( { \\pmb v } ^ { k } )$ with respect to $\\pmb { v } ^ { 1 } , \\pmb { v } ^ { 2 } , \\ldots , \\pmb { v } ^ { k }$ . Consider to find a set of weights ${ \\pmb { \\alpha } } = ( \\alpha _ { 1 } , \\alpha _ { 2 } , \\ldots , \\alpha _ { k } ) ^ { T }$ , subject to $\\textstyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } = 1$ , which satisfies that ",
+        "bbox": [
+            147,
+            119,
+            852,
+            181
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e4f896bec65da31f3fffd42d662731a90694f3773dcacb618ee58dbbbccf52db.jpg",
+        "text": "$$\n\\sum _ { i = 1 } ^ { k } \\alpha _ { i } B _ { \\pi } ( { \\pmb v } ^ { i } ) = { \\bf 0 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            185,
+            565,
+            229
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Then the combination $\\begin{array} { r } { \\tilde { \\pmb { v } } = \\sum _ { i = 1 } ^ { k } \\alpha _ { i } \\pmb { v } ^ { i } } \\end{array}$ will satisfy the following relationship: ",
+        "bbox": [
+            147,
+            242,
+            653,
+            262
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eb8e6163975033a017e866d669483488dd221cad7a0d6dab4fbe88ba8f0ba59e.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle B _ { \\pi } ( { \\tilde { \\pmb v } } ) = { \\pmb r } _ { \\pi } + \\gamma P _ { \\pi } { \\tilde { \\pmb v } } - { \\tilde { \\pmb v } } = \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ( { \\pmb r } _ { \\pi } + \\gamma P _ { \\pi } { \\pmb v } ^ { i } - { \\pmb v } ^ { i } ) } } \\\\ { { \\displaystyle ~ = \\sum _ { i = 1 } ^ { k } \\alpha _ { i } B _ { \\pi } ( { \\pmb v } ^ { i } ) = { \\bf 0 } } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            265,
+            683,
+            356
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This relation implies $\\tilde { v }$ can be viewed as an approximate solution to equation (1) provided the sampling estimations are accurate enough. However, this step needs to keep track of the previous values and recompute $\\Gamma _ { \\pi }$ on all of them. To reduce the huge memory usage and computation, we choose $v ^ { i }$ from the recent history, i.e., $\\pmb { v } ^ { i } = \\pmb { v } ^ { ( t - i ) } , i = 1 , 2 , . . . , \\bar { } { k }$ , and replace $B _ { \\pi ^ { ( t ) } } ( \\pmb { v } ^ { ( t - \\bar { i } ) } )$ with the previously computed values $B _ { \\pi ^ { ( t - i ) } } ( { \\pmb v } ^ { ( t - i ) } )$ . This modification is based on the observation that the recent successive policies do not change sharply and therefore $B _ { \\pi ^ { ( t - i ) } } ( \\pmb { v } ^ { ( t - i ) } ) \\approx B _ { \\pi ^ { ( t ) } } ( \\pmb { v } ^ { ( t - i ) } )$ . This modification approximately solves the policy evaluation problem without model estimation or extra function evaluations. ",
+        "bbox": [
+            147,
+            364,
+            852,
+            469
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Another critical issue is that we cannot guarantee the existence of $_ { \\pmb { \\alpha } }$ given that $k$ is small, because the dimension of $B _ { \\pi } ( \\pmb { v } )$ is usually much higher than $k$ . Inspired by the Anderson acceleration technique ega, $\\&$ Rheinboldt, 1970; Walker & Ni, 2011), we instead look for a combination of $\\{ B _ { \\pi ^ { ( t - i ) } } ( { \\pmb v } ^ { ( t - i ) } ) \\} _ { i = 1 } ^ { k }$ ",
+        "bbox": [
+            147,
+            474,
+            851,
+            532
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7559ce8169aad77d3821610000e2d6e2bb4654506d3cb485a292e62584cb7c2c.jpg",
+        "text": "$$\n\\pmb { \\alpha } ^ { ( t ) } = \\underset { \\pmb { \\alpha } \\in \\Omega \\cap \\Lambda } { \\mathrm { a r g m i n } } \\| \\boldsymbol { B } ^ { ( t ) } \\pmb { \\alpha } \\| ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            530,
+            583,
+            558
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $B ^ { ( t ) } = \\big ( B _ { \\pi ^ { ( t - 1 ) } } \\big ( \\pmb { v } ^ { ( t - 1 ) } \\big ) , B _ { \\pi ^ { ( t - 2 ) } } \\big ( \\pmb { v } ^ { ( t - 2 ) } \\big ) , \\dots , B _ { \\pi ^ { ( t - k ) } } \\big ( \\pmb { v } ^ { ( t - k ) } \\big ) \\big )$ , $\\Omega = \\{ \\pmb { \\alpha } | \\mathbf { 1 } ^ { T } \\pmb { \\alpha } = 1 \\}$ , $\\Lambda$ is an extra constraint on the values attainable by $_ { \\pmb { \\alpha } }$ . Typically, $\\Lambda$ can be chosen from the following forms: ",
+        "bbox": [
+            145,
+            560,
+            854,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Total space, $\\Lambda _ { \\mathrm { t o t } } = \\mathbb { R } ^ { k }$ ; • Boxing constraint, $\\Lambda _ { \\mathrm { b o x } } = \\{ { \\pmb \\alpha } | - m { \\bf 1 } \\le { \\pmb \\alpha } \\le m { \\bf 1 } \\}$ ; • Convex combination constraint, $\\Lambda _ { \\mathrm { c v x } } = \\{ \\alpha | \\mathbf { 0 } \\leq \\alpha \\leq 1 \\}$ ; • Extrapolation constraint, $\\Lambda _ { \\mathrm { e x p } } = \\{ \\alpha | \\alpha _ { 1 } \\geq 1 , \\alpha _ { i } \\leq 0 , i = 2 , 3 , \\ldots , k \\} .$ ",
+        "bbox": [
+            189,
+            602,
+            669,
+            675
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "When the $\\ell _ { 2 }$ norm is used and $\\begin{array} { r c l } { \\Lambda } & { = } & { \\Lambda _ { \\mathrm { t o t } } } \\end{array}$ , the solution can be written explicitly as $\\begin{array} { r l } { \\alpha ^ { ( t ) } } & { { } = } \\end{array}$ $[ ( B ^ { ( t ) } ) ^ { \\top } B ^ { ( t ) } ] ^ { - 1 } { \\bf 1 } / { \\bf 1 } ^ { \\top } [ ( B ^ { ( t ) } ) ^ { \\top } B ^ { ( t ) } ] ^ { - 1 } { \\bf 1 }$ , whose derivation is placed in the appendix. Note that if we simply set $\\begin{array} { r } { \\pmb { v } ^ { ( t ) } = \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } \\pmb { v } ^ { ( t - i ) } } \\end{array}$ , the values will always locate in the subspace expanded by historical values $\\pmb { v } ^ { ( t - 1 ) } , \\pmb { v } ^ { ( t - 2 ) } , \\pmb { \\dots } , \\pmb { v } ^ { ( t - k ) }$ . When the solution to equation (1) does not lie in such a subspace, there is no hope for convergence with application of such updating rule directly. To jump out of the subspace, we perform an extra value iteration step to this combination. Then we will get the updated value, ",
+        "bbox": [
+            147,
+            685,
+            852,
+            779
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/664e7d3585cd1782eb460f97bf39ff6a9ff55b2d08193056bdb2a194892e268b.jpg",
+        "text": "$$\n\\pmb { v } ^ { ( t ) } = \\operatorname* { m a x } _ { \\pi } \\bigg ( \\pmb { r } _ { \\pi } + \\gamma P _ { \\pi } \\bigg [ \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } \\pmb { v } ^ { ( t - i ) } \\bigg ] \\bigg ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            784,
+            640,
+            827
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Based on our previous discussion, we present the $k$ -step Anderson Accelerated Value Iteration (A2VI) in Algorithm 1. In the first $k$ steps, the value is updated according to the original VI. Otherwise, we perform an interpolation procedure, where the weights are attained from solving the problem (5). The original value iteration algorithm can be viewed as a special case of our algorithm with $k = 1$ . ",
+        "bbox": [
+            148,
+            146,
+            851,
+            203
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Anderson Accelerated Value Iteration (A2VI) ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            215,
+            535,
+            229
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Input: ${ \\pmb v } ^ { ( 0 ) } , P , { \\pmb r } , \\gamma , k , T$   \n1: for $t = 1 , 2 , \\dots , T$ do   \n2: $\\begin{array} { r l } & { ~ B _ { \\pi ^ { ( t - 1 ) } } \\big ( \\pmb { v } ^ { ( t - 1 ) } \\big ) = \\underset { \\pi } { \\operatorname* { m a x } } \\big ( \\pmb { r } _ { \\pi } + \\gamma P _ { \\pi } \\pmb { v } ^ { ( t - 1 ) } \\big ) - \\pmb { v } ^ { ( t - 1 ) } } \\\\ & { ~ \\mathbf { i f } t < k \\mathbf { t h e n } } \\\\ & { ~ \\pmb { v } ^ { ( t ) } = \\underset { \\pi } { \\operatorname* { m a x } } \\big ( \\pmb { r } _ { \\pi } + \\gamma P _ { \\pi } \\pmb { v } ^ { ( t - 1 ) } \\big ) } \\end{array}$   \n3:   \n4:   \n5: 6: els $( \\alpha _ { 1 } ^ { ( t ) } , \\alpha _ { 2 } ^ { ( t ) } , \\ldots , \\alpha _ { k } ^ { ( t ) } )$ optimization problem (5)   \n$\\begin{array} { r } { \\pmb { v } ^ { ( t ) } = \\underset { \\pi } { \\operatorname* { m a x } } \\left( \\pmb { r } _ { \\pi } + \\gamma P _ { \\pi } \\left[ \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } \\pmb { v } ^ { ( t - i ) } \\right] \\right) } \\end{array}$   \n8: end if   \n9: end for   \n10: $\\begin{array} { r } { \\pi ^ { ( T ) } = \\mathrm { a r g m a x } _ { \\pi } ( \\pmb { r } _ { \\pi } + \\gamma P _ { \\pi } \\pmb { v } ^ { ( T ) } ) } \\end{array}$   \n11: return v(T ), π(T ) ",
+        "bbox": [
+            150,
+            234,
+            642,
+            411
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Both Anderson Acceleration (AA) and A2VI have the same spirit of interpolating on historical data. However, A2VI does not straightforwardly apply AA to the Bellman optimality equation. Note that AA has the updating rule $\\begin{array} { r } { \\pmb { v } ^ { t } = \\sum \\alpha _ { i } B ( \\mathbf { \\bar { v } } ^ { t - i } ) } \\end{array}$ , while A2VI exchange the order of the operator sum and $B ( \\cdot )$ due to the motivation from equation (3). This exchange puts the nonsmooth operator max out of the affine combination, simplifying the theoretical analysis. ",
+        "bbox": [
+            147,
+            425,
+            851,
+            496
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We present a geometric explanation on the iterative steps of VI, PI, A2VI under 1-dimensional case in Figure 1. In value iteration, ${ \\pmb v } ^ { ( t ) }$ is attained by making a vertical line at $( \\pmb { v } ^ { ( t - 1 ) } , \\mathbf { 0 } )$ , finding its intersection with the function line at $( \\pmb { v } ^ { ( t - 1 ) } , \\boldsymbol { B } ( \\pmb { v } ^ { ( t - 1 ) } ) )$ , then drawing a line with slope $- 1$ through $( \\pmb { v } ^ { ( t - 1 ) } , \\boldsymbol { B } ( \\pmb { v } ^ { ( t - 1 ) } ) )$ and finding its intersection with the horizon axis at $( \\pmb { v } ^ { ( t ) } , \\mathbf { 0 } )$ ; In policy iteration, ${ \\pmb v } ^ { ( t ) }$ is attained by first getting $( \\pmb { v } ^ { ( t - 1 ) } , \\boldsymbol { B } ( \\pmb { v } ^ { ( t - 1 ) } ) )$ in the same way as value iteration, then calculating the tangent line through $( \\pmb { v } ^ { ( t - 1 ) } , \\boldsymbol { B } ( \\pmb { v } ^ { ( t - 1 ) } ) )$ and finding its intersection with the horizon axis. In Anderson accelerated value iteration, each step is first performed in a similar style to policy iteration except that the tangent line is replaced with a secant line. Then a value iteration step is performed to get ${ \\pmb v } ^ { ( t ) }$ . ",
+        "bbox": [
+            147,
+            502,
+            852,
+            625
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "From the figure, we can see that VI only utilizes the current value of the Bellman residual, while PI is similar to Newton’s method Puterman & Brumelle (1978), utilizing the gradient information to achieve a faster convergence rate. Our method serves as an intermediate between them, each step of which is composed of an ordinary value iteration step and a secant step. In specific, the replacement of the tangent line to a secant line can be viewed as a quasi-Newton’s method, which is shown computationally more efficient while keeping a fast convergence rate in several particular settings. Both PI and A2VI converge to the fixed point in a smaller number of steps than VI. Compared with PI, A2VI is more practical because it approximates the tangent line by a secant line, which circumvents the costly model estimation step. ",
+        "bbox": [
+            147,
+            630,
+            851,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 EXTENSION TO MODEL-FREE LEARNING ALGORITHM",
+        "text_level": 1,
+        "bbox": [
+            148,
+            750,
+            563,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We can rewrite our algorithm under $\\pmb q$ -notation, and get the Anderson Accelerated Q-Learning (A2Q) Algorithm shown in the appendix. Combined with the technique of deep learning, our method can be applied to end-to-end decision problems, resulting in the Deep Anderson Accelerated Q-Learning (DA2Q) Algorithm (Algorithm 2). ",
+        "bbox": [
+            148,
+            767,
+            851,
+            823
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/3d826ac40fe3871114092087e3a974454909cd376bd18804a2efe437f1f2ec83.jpg",
+        "image_caption": [
+            "Figure 1: Geometric interpolation of VI, PI and A2VI. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            150,
+            117,
+            844,
+            204
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Deep Anderson Accelerated Q-learning (DA2Q) ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            252,
+            555,
+            267
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/1d952ac1bdb31deb31258b5e93c39cd7bca306cb524d682416ce02a434fbd418.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Input:M,N,T,γ,b,B,ε,n,K,C</td><td>1: Initialize replay memory D to capacity N,initialize Q-value function Q with random weights θ 2:0-k=0,α1=1,αk=0 fork=2,...,K</td></tr><tr><td>3:s=0 4: for episode =1,2,..., M do</td><td></td></tr><tr><td>5:</td><td>Initialize s1 ~ p(s)</td></tr><tr><td>6:</td><td></td></tr><tr><td></td><td>for t=1,2,...,Tdo</td></tr><tr><td>7:</td><td>With probability ε select a random action at,otherwise select at = arg maxa Q(st, a; 0)</td></tr><tr><td>8:</td><td>Execute action at, observe reward rt and state St+1</td></tr><tr><td>9:</td><td>Store transition (St,at,rt,St+1) in D</td></tr><tr><td>10:</td><td>Sample a random minibatch of transitions {(sj,αj,rj,s&#x27;)}=1 from D</td></tr><tr><td>11:</td><td>forj=1,2,...,b do</td></tr><tr><td></td><td>rj for terminal state</td></tr><tr><td>12:</td><td>K</td></tr><tr><td></td><td>yj= M xQ（s,(_)) rj+ymax for non-terminal state a</td></tr><tr><td>13:</td><td>Ak=1 end for</td></tr><tr><td>14:</td><td>L(θ)= 1b j=1(yj -Q(sj,aj;0))²</td></tr><tr><td>15:</td><td>b j aL</td></tr><tr><td>16:</td><td>0=θ-n</td></tr><tr><td>17:</td><td>s=s+1</td></tr><tr><td></td><td>if s mod C= O then</td></tr><tr><td>18:</td><td>Assign0-k =0-(k-1) fork=K,K-1,...,2.Assign0-1=0.</td></tr><tr><td>19:</td><td>if s≥K(C-1) then</td></tr><tr><td>20:</td><td>Sample a random minibatch of transitions {(sj,αj,Tj,s&#x27;)}=1 from D</td></tr><tr><td>21:</td><td>for j=1,2,...,B do</td></tr><tr><td>22:</td><td>for k=1,2,...,K do</td></tr><tr><td></td><td></td></tr><tr><td>23:</td><td>rj-Q(sj,aj;0-k) d</td></tr><tr><td></td><td>𝑟j + γ maxQ(s&#x27;,α;0_k)- Q(sj,αj; 0-k)for non-terminal state</td></tr><tr><td>24:</td><td>α</td></tr><tr><td></td><td>end for</td></tr><tr><td>25:</td><td>end for</td></tr><tr><td>26:</td><td>end if</td></tr><tr><td>27:</td><td>(α1,2.,αk)= argmin(a2a)∑𝑗=1(∑=1kd)² s. ∑1a =1</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td>28:</td><td></td></tr><tr><td></td><td>end if</td></tr><tr><td>29:</td><td></td></tr><tr><td></td><td>end for</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td>30:</td><td></td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr><tr><td>end for</td><td></td></tr></table>",
+        "bbox": [
+            147,
+            270,
+            777,
+            734
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 THEORETICAL ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            761,
+            390,
+            776
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We first analyze of the local convergence of the A2VI algorithm under boxing constraint. Our result shows that in a small neighborhood of the optimal value, our algorithm enjoys an exponential convergence rate. ",
+        "bbox": [
+            147,
+            794,
+            848,
+            823
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. For any MDP with a unique optimal policy, there exists some $\\delta > 0$ , such that for any initial value ${ \\pmb v } ^ { ( 0 ) } \\in U _ { \\delta } ( { \\pmb v } ^ { * } ) = \\{ { \\pmb v } | \\| { \\pmb v } - { \\pmb v } ^ { * } \\| _ { \\infty } ^ { - } \\leq \\bar { \\delta } \\}$ , the A2VI algorithm under boxing constraint maintains the following properties: ",
+        "bbox": [
+            147,
+            119,
+            852,
+            162
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4046f7ea7e010b69e79c18bfd1346b4d014f9a164f0f7818aecefcbdb45c7db4.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\| \\Gamma ( \\pmb { v } ^ { ( t ) } ) - \\pmb { v } ^ { ( t ) } \\| _ { \\infty } \\leq \\gamma \\| \\Gamma ( \\pmb { v } ^ { ( t - 1 ) } ) - \\pmb { v } ^ { ( t - 1 ) } \\| _ { \\infty } , \\forall t = 1 , 2 , . . . ; } \\\\ & { \\| \\pmb { v } ^ { ( t ) } - \\pmb { v } ^ { * } \\| _ { \\infty } \\leq \\frac { \\gamma ^ { t } } { 1 - \\gamma } \\| \\Gamma ( \\pmb { v } ^ { ( 0 ) } ) - \\pmb { v } ^ { ( 0 ) } \\| _ { \\infty } , \\forall t = 1 , 2 , . . . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            204,
+            167,
+            624,
+            219
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Generally, it is difficult to obtain the global convergence rate of A2VI, since the operation max is nonsmooth. To guarantee the convergence, we introduce a rejection step to the original algorithm. We say $\\pmb { v }$ is monotonic improving if $\\Gamma ( v ) \\geq v$ , and denote the set of such values as $V _ { B }$ . We propose the A2VI algorithm with the rejection step, which only differs with Algorithm 1 at line 6. After calculating $\\mathbf { \\alpha } _ { \\alpha } ( t )$ , we test whether the affine combination an ordinary $\\scriptstyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } v ^ { t - i }$ lies in tep. W $V _ { B }$ . If the answer is negative, the interpolation step will be replaced withut the pseudocode of A2VI with the rejection step in Appendix. With this modification, we can have the following convergence properties. ",
+        "bbox": [
+            147,
+            224,
+            852,
+            328
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2. For the A2VI algorithm with the rejection step with $\\Lambda = \\Lambda _ { \\mathrm { c v x } }$ , $i f v ^ { ( 0 ) } \\in V _ { B }$ , then we have ",
+        "bbox": [
+            155,
+            330,
+            816,
+            347
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3. For the A2VI algorithm with $\\Lambda = \\Lambda _ { \\mathrm { e x p } }$ , $i f v ^ { 0 } \\geq \\mathbf { 0 }$ and ${ \\pmb v } ^ { ( 0 ) } \\in \\ d V _ { B }$ , then we have ",
+        "bbox": [
+            142,
+            366,
+            754,
+            383
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(a) Monotone improving values, ${ \\pmb v } ^ { ( t - 1 ) } \\le { \\pmb v } ^ { ( t ) } \\le { \\pmb v } ^ { * } , { \\pmb v } ^ { ( t ) } \\in V _ { B } , \\forall t = 1 , 2 , . . .$ (b) $\\gamma$ -linear convergence rate, $\\begin{array} { r } { \\| \\pmb { v } ^ { * } - \\pmb { v } ^ { ( t ) } \\| _ { \\infty } \\leq \\gamma \\| \\pmb { v } ^ { * } - \\pmb { v } ^ { ( t - 1 ) } \\| _ { \\infty } } \\end{array}$ . ",
+        "bbox": [
+            178,
+            391,
+            694,
+            433
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            450,
+            300,
+            467
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To validate the effectiveness of our method, we conduct several experiments. ",
+        "bbox": [
+            150,
+            481,
+            648,
+            496
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 EXPERIMENTS ON TOY MODELS ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            511,
+            413,
+            525
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We first test our method on three toy models. The first model is a randomly generated MDP with $\\vert { \\cal S } \\vert = 1 0 0$ and $| { \\cal A } | = 5 0$ . The transition probabilities of the MDP are generated from a uniform distribution on $[ 0 , 1 ]$ , and the rewards are generated from a standard normal distribution. The second model is the $N$ -Chain problem with $N = 1 0 0$ , where a reward of 0.1 is given at state 0 and a reward of 1 is given at state $N$ . At each state, the agent can either choose to move forward or backward, and will move to the selected direction with probability 0.9 and to the opposite direction with probability 0.1. The last model is a $2 0 \\times 2 0$ Gridworld model, where a reward of 1 is given at state (20, 20). At each state, the agent can choose one of the 4 directions and will move to that direction with probability 0.7, or move to one of the other directions with probability 0.1 for each. We perform the standard value iteration, policy iteration and Anderson accelerated value iteration with/without the rejection step on these models. In our experiment, each policy iteration step is approximately solved by the modified policy iteration method with 100 inner iterations. To compare our method with the averaged updating scheme (Anschel et al., 2016), we further construct and compare our algorithm with the averaged value iteration. The value of $\\lVert \\boldsymbol { v } ^ { t } - \\boldsymbol { v } ^ { * } \\rVert$ w.r.t. step $t$ is shown in Figure 2, where the results are averaged from 30 independent experiments. ",
+        "bbox": [
+            147,
+            536,
+            851,
+            732
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "From the results we can see that the policy iteration converges fastest for all of the three models, however, since each of its steps includes 100 inner iterations, the actual computation cost is very high. Among value iteration methods, the Anderson accelerated value iteration converges fastest. The acceleration effect is remarkable in randomly generated MDPs, but A2VI slows down at the first few steps in the latter two experiments. However, adding a rejection step solves the problem and attains a faster convergence rate. Another observation is that in the toy model case, the averaged value iteration cannot be used for acceleration. ",
+        "bbox": [
+            148,
+            738,
+            852,
+            823
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/017e0eb5a1424b7b9e919b1e1dd435cf6a48f19d2d12ec966e5213abcc742ec6.jpg",
+        "image_caption": [
+            "Figure 2: Experiment results on several toy models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            117,
+            805,
+            239
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 EXPERIMENTS ON ATARI GAMES WITH DEEP LEARNING BASED TECHNIQUES ",
+        "bbox": [
+            147,
+            292,
+            728,
+            308
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To figure out the performance of our method on complex environments, we apply our method to Atari games from Gym (Brockman et al., 2016), which is a Python API to Arcade Learning Environment (Bellemare et al., 2013). We compare DA2Q with DQN (Mnih et al., 2013) and Averaged-DQN (Anschel et al., 2016). Details of the experiment settings are given in Appendix D. ",
+        "bbox": [
+            148,
+            319,
+            852,
+            376
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As Figure 3 points out, our algorithm DA2Q obtains a significant improvement over both the original DQN algorithm and the Averaged DQN algorithm. When compared with other interpolation method such as Averaged-DQN, the overall performance of our method also tends to be stabler, always being superior than other methods among all of the three environments, while the performance of Averaged-DQN varies a lot. ",
+        "bbox": [
+            148,
+            382,
+            851,
+            439
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/4fe215b114bc3bb117d605d98e305992377703a24aeb1bd876d661d3dd8686b3.jpg",
+        "image_caption": [
+            "Figure 3: Training Performance on Atari games, score is smoothed with 250 windows while the shaded area is the 0.25 standard deviation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            450,
+            812,
+            571
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Compared with DQN, the extra computational cost is actually low, since the $\\alpha$ is updated only once every $C$ steps, which only involves an inversion on a very small-size matrix $( k \\times k )$ . The $k$ target values are computed parallelly in the TensorFlow (Abadi et al., 2016), which cost the same time as in DQN. Moreover, the extra runtime can be ignored when compared with the costly back propagations and interaction with environments. ",
+        "bbox": [
+            148,
+            631,
+            851,
+            688
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            707,
+            292,
+            723
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have proposed the Anderson accelerated value iteration method, which is a novel acceleration approach for reinforcement learning. We have proved the convergence property of our method under certain conditions. Our algorithm empirically achieves a superior performance on toy models and several Atari games. Despite the success of our algorithm, several questions remain open. The convergence analysis for the general case is lacking, and we only provide convergence guarantees but do not give a theoretical analysis of the acceleration effect of A2VI, which we leave for future work. ",
+        "bbox": [
+            148,
+            738,
+            852,
+            821
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            119,
+            261,
+            135
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. Tensorflow: a system for large-scale machine learning. In OSDI, volume 16, pp. 265–283, 2016.   \nAlessandro Alla, Maurizio Falcone, and Dante Kalise. An efficient policy iteration algorithm for dynamic programming equations. SIAM Journal on Scientific Computing, 37(1):A181–A200, 2015.   \nDonald G Anderson. Iterative procedures for nonlinear integral equations. Journal of the ACM (JACM), 12 (4):547–560, 1965.   \nOron Anschel, Nir Baram, and Nahum Shimkin. Averaged-dqn: Variance reduction and stabilization for deep reinforcement learning. arXiv preprint arXiv:1611.01929, 2016.   \nMarc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, 2013.   \nMarc G Bellemare, Will Dabney, and Rémi Munos. A distributional perspective on reinforcement learning. arXiv preprint arXiv:1707.06887, 2017.   \nRichard Bellman. A markovian decision process. Journal of Mathematics and Mechanics, pp. 679–684, 1957.   \nGreg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016.   \nSébastien Bubeck et al. Convex optimization: Algorithms and complexity. Foundations and Trends $\\textsuperscript { \\textregistered }$ in Machine Learning, 8(3-4):231–357, 2015.   \nRonald A Howard. Dynamic programming and markov processes. 1964.   \nLeslie Pack Kaelbling, Michael L Littman, and Andrew W Moore. Reinforcement learning: A survey. Journal of artificial intelligence research, 4:237–285, 1996.   \nMattia Laurini, Piero Micelli, Luca Consolini, and Marco Locatelli. A jacobi-like acceleration for dynamic programming. In Decision and Control (CDC), 2016 IEEE 55th Conference on, pp. 7371–7376. IEEE, 2016.   \nMattia Laurini, Luca Consolini, and Marco Locatelli. A consensus approach to dynamic programming. IFAC-PapersOnLine, 50(1):8435–8440, 2017.   \nVolodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013.   \nJames M Ortega and Werner C Rheinboldt. Iterative solution of nonlinear equations in several variables, volume 30. Siam, 1970.   \nMartin L Puterman. Markov decision processes. j. Wiley and Sons, 1994.   \nMartin L Puterman and Shelby L Brumelle. The analytic theory of policy iteration. In Dynamic Programming and its applications, pp. 91–113. Elsevier, 1978.   \nGavin A Rummery and Mahesan Niranjan. On-line Q-learning using connectionist systems, volume 37. University of Cambridge, Department of Engineering, 1994.   \nTom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. arXiv preprint arXiv:1511.05952, 2015.   \nDamien Scieur, Alexandre d’Aspremont, and Francis Bach. Regularized nonlinear acceleration. In Advances In Neural Information Processing Systems, pp. 712–720, 2016.   \nDamien Scieur, Francis Bach, and Alexandre d’Aspremont. Nonlinear acceleration of stochastic algorithms. In Advances in Neural Information Processing Systems, pp. 3982–3991, 2017.   \nRichard S Sutton and Andrew G Barto. Reinforcement learning: An introduction, volume 1. MIT press Cambridge, 1998.   \nRichard S Sutton, David A McAllester, Satinder P Singh, and Yishay Mansour. Policy gradient methods for reinforcement learning with function approximation. In Advances in neural information processing systems, pp. 1057–1063, 2000.   \nAlex Toth and CT Kelley. Convergence analysis for anderson acceleration. SIAM Journal on Numerical Analysis, 53(2):805–819, 2015.   \nHado Van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double q-learning. In AAAI, volume 16, pp. 2094–2100, 2016.   \nHomer F Walker and Peng Ni. Anderson acceleration for fixed-point iterations. SIAM Journal on Numerical Analysis, 49(4):1715–1735, 2011.   \nZiyu Wang, Tom Schaul, Matteo Hessel, Hado Van Hasselt, Marc Lanctot, and Nando De Freitas. Dueling network architectures for deep reinforcement learning. arXiv preprint arXiv:1511.06581, 2015.   \nChristopher JCH Watkins and Peter Dayan. Q-learning. Machine learning, 8(3-4):279–292, 1992.   \nGuangzeng Xie, Yitan Wang, Shuchang Zhou, and Zhihua Zhang. Interpolatron: Interpolation or extrapolation schemes to accelerate optimization for deep neural networks. arXiv preprint arXiv:1805.06753, 2018. ",
+        "bbox": [
+            142,
+            131,
+            856,
+            823
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            118,
+            854,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A. A2Q ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            150,
+            205,
+            165
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Here is the pseudocode of A2Q, which is A2VI in $\\pmb q$ -notation. ",
+        "bbox": [
+            148,
+            176,
+            552,
+            191
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 3 Anderson Accelerated Q-Learning (A2Q) ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            207,
+            511,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Input: $\\mathbf { \\Psi } _ { q } { } ^ { 0 } , P , r , \\gamma , k , T$ 1: for $t = 1 , 2 , \\dots , T$ do 2: $B _ { \\pi ^ { ( t - 1 ) } } ( { \\pmb q } ^ { t - 1 } ) = \\mathrm { v e c } ( { \\pmb r } ) + \\gamma P \\mathrm { m a x } _ { \\pi } { \\pmb q } _ { \\pi } ^ { t - 1 } - \\mathrm { v e c } ( { \\pmb q } ^ { t - 1 } )$ 3: if $t < k$ then 4: $\\begin{array} { r } { \\mathrm { v e c } ( \\pmb q ^ { t } ) = \\mathrm { v e c } ( \\pmb r ) + \\gamma P \\mathrm { m a x } _ { \\pi } \\pmb q _ { \\pi } ^ { t - 1 } } \\end{array}$ 5: else 6: Calculate $\\left( \\alpha _ { 1 } , \\alpha _ { 2 } , \\ldots , \\alpha _ { k } \\right)$ by solving the optimization problem (5) 7: $\\begin{array} { r } { \\mathrm { v e c } ( { \\pmb q } ^ { t } ) = \\mathrm { v e c } ( { \\pmb r } ) + \\gamma P \\mathrm { m a x } _ { \\pi } \\big ( \\sum _ { i = 1 } ^ { k } \\alpha _ { i } \\pmb q _ { \\pi } ^ { t - i } \\big ) } \\end{array}$ 8: end if   \n9: end for   \n10: πT = arg maxπ qTπ   \n11: return qT , πT ",
+        "bbox": [
+            150,
+            227,
+            619,
+            383
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B. A2VI WITH THE REJECTION STEP ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            417,
+            406,
+            433
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Here is the pseudocode of A2VI with the rejection step, the only difference between this algorithm with algorithm 1 is before the interpolation step, we first check whether the affine combination is in $V _ { B }$ . If the answer is negative, then this interpolation step is replaced with an ordinary value iteration step. ",
+        "bbox": [
+            148,
+            443,
+            851,
+            486
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 4 Anderson Accelerated Value Iteration with the Rejection Step ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            501,
+            640,
+            517
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Input: ${ \\pmb v } ^ { ( 0 ) } , P , { \\pmb r } , \\gamma , k , T$   \n1: for $t = 1 , 2 , \\cdots , T { \\bf d }$ o   \n2: $B _ { \\pi ^ { ( t - 1 ) } } ( \\pmb { v } ^ { ( t - 1 ) } ) = \\operatorname* { m a x } _ { \\pi } \\left( \\pmb { r } _ { \\pi } + \\gamma P _ { \\pi } \\pmb { v } ^ { ( t - 1 ) } \\right) - \\pmb { v } ^ { ( t - 1 ) }$   \n3: if $t < k$ then   \n4: ${ \\pmb v } ^ { ( t ) } = \\operatorname* { m a x } _ { \\pi } ( { \\pmb r } _ { \\pi } + \\gamma P _ { \\pi } { \\pmb v } ^ { ( t - 1 ) } )$   \n5: else   \n6: Calculate $( \\alpha _ { 1 } ^ { ( t ) } , \\alpha _ { 2 } ^ { ( t ) } , \\cdot \\cdot \\cdot , \\alpha _ { k } ^ { ( t ) } )$ by solving the optimization problem (5)   \n7: 8: v˜ = Pki=1 α(t)i v (t−i) $\\begin{array} { c } { { \\pmb v = \\sum _ { i = 1 } \\alpha _ { i } \\mathrm {  ~ \\pmb { \\sigma } ~ } ^ { \\ast } { \\pmb v } ^ { \\ast } } } \\\\ { { \\bf i f \\operatorname* { m a x } _ { \\pi } ( \\pmb r _ { \\pi } + \\gamma P _ { \\pi } \\tilde { \\pmb v } ) \\geq \\tilde { v } \\ t h e n } } \\\\ { { \\pmb v } ^ { ( t ) } = \\operatorname* { m a x } _ { \\pi } ( { \\pmb r _ { \\pi } + \\gamma P _ { \\pi } \\tilde { \\pmb v } } ) } \\end{array}$   \n9:   \n10: else   \n11: $\\mathbf { \\tilde { \\alpha } } _ { 1 } ^ { ( t ) } = 1 , \\alpha _ { i } ^ { ( t ) } = 0$ for i 6= 1   \n12: v(t) = max \u0000rπ + γPπv(t−1)\u0001   \n13: end if   \n14: end if   \n15: end for   \n16: $\\pi ^ { ( T ) } = \\mathrm { a r g m a x } _ { \\pi } ( \\pmb { r } _ { \\pi } + \\gamma P _ { \\pi } \\pmb { v } ^ { ( T ) } )$   \n17: return ${ \\pmb v } ^ { ( T ) } , \\pi ^ { ( T ) }$ ",
+        "bbox": [
+            150,
+            520,
+            696,
+            809
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C. PROOFS ",
+        "bbox": [
+            148,
+            119,
+            225,
+            135
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1. For any MDP whose optimal policy is unique, there exists a $\\delta > 0$ and a policy $\\pi ^ { * }$ such that for any ${ \\pmb v } \\in U _ { \\delta } ( { \\pmb v } ^ { * } ) = \\{ { \\pmb v } | \\| { \\pmb v } - { \\pmb v } ^ { * } \\| _ { \\infty } \\leq \\delta \\}$ , ",
+        "bbox": [
+            142,
+            145,
+            848,
+            176
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/acda63edfcf248958b937e933ceb09ecd3f45adb67eac0b566a6b8cc941c0d01.jpg",
+        "text": "$$\n\\Gamma ( v ) = r _ { \\pi ^ { * } } + \\gamma P _ { \\pi ^ { * } } v\n$$",
+        "text_format": "latex",
+        "bbox": [
+            424,
+            180,
+            571,
+            196
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Proof Because the optimal policy is unique, for any nonoptimal policy $\\pi$ , for any state $s$ such that $\\pi ( s ) \\neq$ $\\pi ^ { * } ( s )$ we have that $[ \\bar { \\Gamma _ { \\pi ^ { * } } } ( { \\pmb v } ^ { * } ) \\bar { \\bf \\bar { \\Big ] } } _ { s } > [ \\Gamma _ { \\pi } ( { \\pmb v } ^ { * } ) ] _ { s } , [ \\cdot ] _ { s }$ means executing operations on state $s$ . Denote $A ( \\pi ) =$ $\\{ s | \\dot { \\pi } ( s ) \\neq \\pi ^ { * } ( s ) \\}$ . ",
+        "bbox": [
+            147,
+            209,
+            852,
+            253
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Suppose the optimal policy is $\\pi ^ { * }$ , then there exists $\\varepsilon$ such that ",
+        "bbox": [
+            148,
+            258,
+            553,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dbb3547e941dd16645f014845e6e850c7b48253aeb3b459d89578894c5e220c6.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\pi \\neq \\pi ^ { * } } \\operatorname* { m i n } _ { s \\in A ( \\pi ) } ~ [ \\Gamma ( \\pmb { v } ^ { * } ) - \\Gamma _ { \\pi } ( \\pmb { v } ^ { * } ) ] _ { s } > \\varepsilon > 0 ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            279,
+            637,
+            304
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "since the optimal policy is unique and the state space and the action space are finite. We choose $\\begin{array} { r } { \\delta = \\frac { \\varepsilon } { 3 \\gamma } } \\end{array}$ , then for any policy $\\pi$ and any $\\pmb { v } \\in U _ { \\delta } ( \\pmb { v } ^ { * } )$ we have ",
+        "bbox": [
+            145,
+            309,
+            854,
+            342
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ba6e23b453f401e2f8c43d02ead4aaf23523c014b8b55e037f318aa4f6280e42.jpg",
+        "text": "$$\n\\| \\Gamma _ { \\pi } ( \\pmb { v } ^ { * } ) - \\Gamma _ { \\pi } ( \\pmb { v } ) \\| _ { \\infty } = \\| \\gamma P _ { \\pi } ( \\pmb { v } ^ { * } - \\pmb { v } ) \\| _ { \\infty } \\leq \\gamma \\| \\pmb { v } ^ { * } - \\pmb { v } \\| _ { \\infty } \\leq \\frac { \\varepsilon } { 3 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            364,
+            714,
+            392
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Then for any policy $\\pi$ , for any state $s \\in A ( \\pi )$ , we have that ",
+        "bbox": [
+            147,
+            405,
+            542,
+            420
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/592105a6c5c915a6d271c9d2d176dd907a1535f9002a8b53a34ad782e8707705.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\bigl [ \\Gamma _ { \\pi ^ { * } } ( \\pmb { v } ) - \\Gamma _ { \\pi } ( \\pmb { v } ) \\bigr ] _ { s } = \\bigl [ \\bigl ( \\Gamma _ { \\pi ^ { * } } ( \\pmb { v } ) - \\Gamma _ { \\pi ^ { * } } ( \\pmb { v } ^ { * } ) \\bigr ) + \\bigl ( \\Gamma _ { \\pi ^ { * } } ( \\pmb { v } ^ { * } ) - \\Gamma _ { \\pi } ( \\pmb { v } ^ { * } ) \\bigr ) + \\bigl ( \\Gamma _ { \\pi } ( \\pmb { v } ^ { * } ) - \\Gamma _ { \\pi } ( \\pmb { v } ) \\bigr ) \\bigr ] _ { s } } \\\\ & { \\qquad \\geq \\varepsilon - \\| \\Gamma _ { \\pi ^ { * } } ( \\pmb { v } ) - \\Gamma _ { \\pi ^ { * } } ( \\pmb { v } ^ { * } ) \\| _ { \\infty } - \\| \\Gamma _ { \\pi } ( \\pmb { v } ^ { * } ) - \\Gamma _ { \\pi } ( \\pmb { v } ) \\| _ { \\infty } } \\\\ & { \\qquad \\geq \\varepsilon - \\frac { \\varepsilon } { 3 } - \\frac { \\varepsilon } { 3 } } \\\\ & { \\qquad = \\frac { \\varepsilon } { 3 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            444,
+            802,
+            540
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "which means $\\pi$ does not choose the optimal action in state $s$ . Therefore, if $\\pi$ selects the optimal action in every state $s \\in S$ , then we must have $\\pi _ { s } = \\pi _ { s } ^ { * } , \\forall s \\in \\mathcal { S }$ , which implies $\\pi ^ { * } \\in \\arg \\operatorname* { m a x } _ { \\pi } \\Gamma _ { \\pi } ( \\pmb { v } )$ , i.e., $\\Gamma ( v ) = r _ { \\pi ^ { * } } + \\gamma P _ { \\pi ^ { * } } v$ . ",
+        "bbox": [
+            148,
+            549,
+            852,
+            592
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lemma 2. For any given MDP with optimal value $v ^ { * }$ and any value $\\textbf {  { v } }$ , we always have ",
+        "bbox": [
+            145,
+            594,
+            725,
+            611
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9f5d4a92c4510165fc5e324aa9c782e85823a5c9ccdd26736271f0aaf2ef8db1.jpg",
+        "text": "$$\n( 1 - \\gamma ) \\| \\pmb { v } - \\pmb { v } ^ { * } \\| _ { \\infty } \\leq \\| \\Gamma ( \\pmb { v } ) - \\pmb { v } \\| _ { \\infty } \\leq ( 1 + \\gamma ) \\| \\pmb { v } - \\pmb { v } ^ { * } \\| _ { \\infty } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            614,
+            697,
+            633
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Proof ",
+        "bbox": [
+            147,
+            645,
+            191,
+            660
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/94e450f0d43c3fca73a16699b02fa50c426af819e29a7d83ddf9568258f0b73d.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\| v - v ^ { * } \\| _ { \\infty } = } & { \\| v - \\Gamma ( v ) + \\Gamma ( v ) - \\Gamma ( v ^ { * } ) \\| _ { \\infty } } \\\\ & { \\leq \\| v - \\Gamma ( v ) \\| _ { \\infty } + \\| \\Gamma ( v ) - \\Gamma ( v ^ { * } ) \\| _ { \\infty } } \\\\ & { \\leq \\| v - \\Gamma ( v ) \\| _ { \\infty } + \\gamma \\| v - v ^ { * } \\| _ { \\infty } } \\\\ { \\Rightarrow ( 1 - \\gamma ) \\| _ { \\infty } v - v ^ { * } \\| _ { \\infty } \\leq \\| \\Gamma ( v ) - v \\| _ { \\infty } } \\\\ { \\| v - v ^ { * } \\| _ { \\infty } = } & { \\| v - \\Gamma ( v ) + \\Gamma ( v ) - \\Gamma ( v ^ { * } ) \\| _ { \\infty } } \\\\ & { \\geq \\| v - \\Gamma ( v ) \\| _ { \\infty } - \\| \\Gamma ( v ) - \\Gamma ( v ^ { * } ) \\| _ { \\infty } } \\\\ { \\geq \\| v - \\Gamma ( v ) \\| _ { \\infty } - \\gamma \\| v - v ^ { * } \\| _ { \\infty } } \\\\ { \\Rightarrow ( 1 + \\gamma ) \\| v - v ^ { * } \\| _ { \\infty } \\geq \\| \\Gamma ( v ) - v \\| _ { \\infty } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            664,
+            710,
+            810
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Proof of Theorem 1 From lemma 1 we know there exists a policy $\\pi$ and a $\\tilde { \\delta } > 0$ such that the optimal Bellman operator is a linear function on $U _ { \\tilde { \\delta } } ( \\boldsymbol { v } ^ { * } )$ . We now set $\\delta$ sufficiently small such that ",
+        "bbox": [
+            147,
+            118,
+            848,
+            150
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7882d5e2de223ca33132151a6366c23c46813478a0e09237901b63248866649c.jpg",
+        "text": "$$\n\\frac { k m ( 1 + \\gamma ) } { 1 - \\gamma } \\| \\pmb { v } ^ { ( 0 ) } - \\pmb { v } ^ { * } \\| _ { \\infty } < \\frac { k m ( 1 + \\gamma ) } { 1 - \\gamma } \\delta < \\widetilde { \\delta } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            154,
+            656,
+            189
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The result is trivial for the first $k - 1$ steps, which are performed exactly by standard value iteration. When $t > k$ , we prove the result by induction. Suppose the conclusion is correct for previous steps, then we have ",
+        "bbox": [
+            142,
+            199,
+            852,
+            229
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/51c72aeddae78fe39a17cc2c11c9cb9e314bbb5c76601b8ddbfc593b8e56407a.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\displaystyle \\| \\displaystyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } - v ^ { * } \\| _ { \\infty } \\leq \\displaystyle \\sum _ { i = 1 } ^ { k } | \\alpha _ { i } ^ { ( t ) } | \\| v ^ { ( t - i ) } - v ^ { * } \\| _ { \\infty } \\leq \\displaystyle \\sum _ { i = 1 } ^ { k } | \\alpha _ { i } ^ { ( t ) } | \\frac { 1 } { 1 - \\gamma } \\| B ( v ^ { ( t - i ) } ) \\| _ { \\infty } } & { } \\\\ { \\leq \\displaystyle \\sum _ { i = 1 } ^ { k } | \\alpha _ { i } ^ { ( t ) } | \\frac { 1 } { 1 - \\gamma } \\| B ( v ^ { ( 0 ) } ) \\| _ { \\infty } \\leq \\frac { k m } { 1 - \\gamma } \\| B ( v ^ { ( 0 ) } ) \\| _ { \\infty } } & { } \\\\ { \\leq \\frac { k m ( 1 + \\gamma ) } { 1 - \\gamma } \\| v ^ { ( 0 ) } - v ^ { * } \\| _ { \\infty } < \\frac { k m ( 1 + \\gamma ) } { 1 - \\gamma } \\delta < \\widetilde { \\delta } } & { } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            209,
+            251,
+            789,
+            377
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "It follows that ",
+        "bbox": [
+            147,
+            385,
+            243,
+            400
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2f3055d41963a48320088603bbf59a85b77453823f6f4dcd70737a7039feb5af.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\| { \\pmb v } ^ { ( t ) } - { \\pmb v } ^ { * } \\| _ { \\infty } = \\| \\Gamma ( \\displaystyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } { \\pmb v } ^ { t - i } ) - \\Gamma ( { \\pmb v } ^ { * } ) \\| _ { \\infty } \\leq \\gamma \\| \\displaystyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } { \\pmb v } ^ { ( t - i ) } - { \\pmb v } ^ { * } \\| _ { \\infty } } \\\\ & { \\qquad \\leq \\| \\displaystyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } { \\pmb v } ^ { ( t - i ) } - { \\pmb v } ^ { * } \\| _ { \\infty } < \\widetilde { \\delta } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            424,
+            753,
+            513
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Therefore, $\\textstyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } { \\pmb v } ^ { ( t - i ) } \\in U _ { \\tilde { \\delta } } ( { \\pmb v } ^ { * } ) , { \\pmb v } ^ { ( t ) } \\in U _ { \\tilde { \\delta } } ( { \\pmb v } ^ { * } )$ , which implies ",
+        "bbox": [
+            147,
+            525,
+            601,
+            545
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2962dce93a13e673cb290bd0785e3dff8c7a493b8b6b3d941734c2587c1e1a33.jpg",
+        "text": "$$\n\\Gamma ( \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } ) = r _ { \\pi ^ { * } } + \\gamma P _ { \\pi ^ { * } } \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } , \\Gamma ( v ^ { ( t ) } ) = r _ { \\pi ^ { * } } + \\gamma P _ { \\pi ^ { * } } v ^ { ( t ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            245,
+            549,
+            751,
+            592
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Then we can get ",
+        "bbox": [
+            147,
+            603,
+            258,
+            618
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ab142180bb724e3979bd8750d5e50545426beb66b8d08104f20972716691042e.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle B ( v ^ { t } ) = r _ { \\pi ^ { * } } + ( \\gamma P _ { \\pi ^ { * } } - I ) v ^ { ( t ) } } } \\\\ { { \\displaystyle \\quad = r _ { s ^ { * } } + ( \\gamma P _ { \\pi ^ { * } } - I ) ( r _ { s ^ { * } } + \\gamma P _ { \\pi ^ { * } } \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } ) } } \\\\ { ~ } \\\\ { { \\displaystyle \\quad = \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } \\left( r _ { \\pi ^ { * } } + ( \\gamma P _ { \\pi ^ { * } } - I ) ( r _ { \\pi ^ { * } } + \\gamma P _ { \\pi ^ { * } } \\pi ^ { ( t - i ) } ) \\right) } } \\\\ { { \\displaystyle \\quad = \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } \\gamma P _ { \\pi ^ { * } } \\left( r _ { \\pi ^ { * } } + \\gamma P _ { \\pi ^ { * } } v ^ { ( t - i ) } - v ^ { ( t - i ) } \\right) } } \\\\ { { \\displaystyle \\quad = \\gamma P _ { \\pi ^ { * } } \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } B ( v ^ { ( t - i ) } ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            621,
+            696,
+            821
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Taking norm on both side of the equation and utilizing the definition of $\\alpha _ { i } ^ { ( t ) } , i = 1 , 2 , \\cdots , k$ , we get ",
+        "bbox": [
+            147,
+            117,
+            802,
+            137
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dcf886311ca52867cc92ec1d69ba51d26fcba999ef8eb6e3a1b17a7041478863.jpg",
+        "text": "$$\n| \\Gamma ( \\pmb { v } ^ { ( t ) } ) - \\pmb { v } ^ { ( t ) } \\| _ { \\infty } \\leq \\gamma \\| P _ { \\pi ^ { * } } \\| _ { \\infty } \\| \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } B ( \\pmb { v } ^ { ( t - i ) } ) \\| _ { \\infty } \\leq \\gamma \\| B ( \\pmb { v } ^ { ( t - 1 ) } ) \\| _ { \\infty } = \\gamma \\| \\Gamma ( \\pmb { v } ^ { ( t - 1 ) } ) - \\pmb { v } ^ { ( t - 1 ) } \\| _ { \\infty } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            158,
+            141,
+            816,
+            185
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Therefore, we justify property (i). Property (ii) then follows directly from Lemma 2. ",
+        "bbox": [
+            147,
+            195,
+            696,
+            212
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Lemma 3. For any MDP, suppose the values $\\textbf { \\em u }$ and $\\textbf {  { v } }$ satisfy $\\textbf { \\em u } \\geq v$ , then ",
+        "bbox": [
+            147,
+            214,
+            633,
+            231
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e919f4162f0109e6238de6d3da28743b6f86049f73c8adc8aaf8a1dc13464c91.jpg",
+        "text": "$$\n\\Gamma ( \\boldsymbol { \\mathbf { u } } ) \\geq \\Gamma ( \\boldsymbol { \\mathbf { v } } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            450,
+            234,
+            547,
+            252
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Proof As stated in section 2, $\\textbf { \\em u } \\geq \\textbf { \\em v }$ means that $\\pmb { u } ( s ) \\geq \\pmb { v } ( s )$ for any state $s$ . Suppose $\\tilde { \\pi } = \\arg \\operatorname* { m a x } _ { \\pi } \\boldsymbol { r } _ { \\pi } +$ $\\gamma { P _ { \\pi } } v$ , therefore for any $s$ we have that ",
+        "bbox": [
+            147,
+            263,
+            852,
+            294
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d88dea8cb3b7e4c69e179831d3114b14e0102418c432f016ec754296fce61b0a.jpg",
+        "text": "$$\n\\Gamma ( \\pmb { u } ) ( s ) \\geq \\Gamma _ { \\widetilde { \\pi } } ( \\pmb { u } ) ( s ) \\geq \\Gamma _ { \\widetilde { \\pi } } ( \\pmb { v } ) ( s ) = \\Gamma ( \\pmb { v } ) ( s ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            299,
+            650,
+            316
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Proof of Theorem 2 On the one hand, ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            328,
+            413,
+            344
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7d3964ee1151662470eedc3e0b28eca0ba48221a7f6a1c46fb0e3dc0a07944e5.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\Gamma ( \\mathbf { v } ^ { ( t ) } ) - \\mathbf { v } ^ { ( t ) } = } & { \\underset { \\mathbf { n } = 1 } { \\operatorname* { m a x } } ( r _ { \\mathbf { x } } + \\gamma P _ { \\mathbf { x } } \\mathbf { v } ^ { ( t ) } ) - \\underset { \\mathbf { n } = 1 } { \\operatorname* { m a x } } ( r _ { \\mathbf { x } } + \\gamma P _ { \\mathbf { x } } \\mathbf { \\Lambda } _ { \\leq } ^ { k } \\alpha _ { i } ^ { ( t ) } \\mathbf { v } ^ { ( t - i \\setminus j ) } ) } \\\\ & { \\leq r _ { \\mathbf { x } } ( \\epsilon ) + \\gamma P _ { \\mathbf { x } ^ { ( t ) } } \\mathbf { v } ^ { ( t ) } - r _ { \\mathbf { x } ^ { ( t ) } } \\lambda ^ { ( t ) } - \\gamma P _ { \\mathbf { x } ^ { ( t ) } } \\underset { \\mathbf { i = 1 } } { \\overset { k } { \\sum } } \\alpha _ { i } ^ { ( t ) } \\mathbf { v } ^ { ( t - i ) } } \\\\ & { = \\gamma P _ { \\mathbf { n } } ( \\epsilon ) \\underset { \\mathbf { n } = 1 } { \\operatorname* { m a x } } ( r _ { \\mathbf { x } } + \\gamma P _ { \\mathbf { x } } \\underset { \\mathbf { i = 1 } } { \\overset { k } { \\sum } } \\alpha _ { i } ^ { ( t ) } \\mathbf { v } ^ { ( t - i ) } ) - \\underset { \\mathbf { n } = 1 } { \\overset { k } { \\sum } } \\alpha _ { i } ^ { ( t ) } \\mathbf { v } ^ { ( t - i ) } , } \\\\ & { \\leq \\gamma P _ { \\mathbf { n } ^ { ( t ) } } \\underset { \\mathbf { n } = 1 } { \\overset { k } { \\sum } } \\alpha _ { i } ^ { ( t ) } \\underset { \\mathbf { n } } { \\operatorname* { m a x } } ( r _ { \\mathbf { n } } + \\gamma P _ { \\mathbf { x } } \\mathbf { v } ^ { ( t - i ) } ) - \\mathbf { v } ^ { ( t - i ) } , } \\\\ & { = \\gamma P _ { \\mathbf { n } ^ { ( t ) } } \\underset { \\mathbf { n } = 1 } { \\overset { k } { \\sum } } \\alpha _ { i } ^ { ( t ) } B ( \\mathbf { v } ^ { ( t - i ) } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            367,
+            745,
+            590
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, we denote $\\begin{array} { r } { \\tilde { \\pi } = \\mathrm { a r g m a x } _ { \\pi } ( { r } _ { \\pi } + \\gamma P _ { \\pi } \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } { \\pmb v } ^ { { ( t - i ) } } ) } \\end{array}$ ",
+        "bbox": [
+            143,
+            601,
+            666,
+            621
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ecb80069d86867ee03e530abca09426cc4ca7824c0b5a7be1cc9d232015b135c.jpg",
+        "text": "$$\n\\begin{array} { r l } { v ^ { ( t ) } - \\Gamma ( v ^ { ( t ) } ) = \\displaystyle \\operatorname* { m a x } _ { \\pi } ( r _ { \\pi } + \\gamma P _ { \\pi } \\displaystyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } ) - \\operatorname* { m a x } _ { \\pi } ( r _ { \\pi } + \\gamma P _ { \\pi } v ^ { ( t ) } ) } & { } \\\\ { \\le r _ { \\pi } + \\gamma P _ { \\pi } \\displaystyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } - r _ { \\pi } - \\gamma P _ { \\pi } v ^ { ( t ) } } & { } \\\\ { = \\gamma P _ { \\pi } \\displaystyle ( \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } - \\operatorname* { m a x } _ { \\pi } ( r _ { \\pi } + \\gamma P _ { \\pi } \\displaystyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } ) ) } & { } \\\\ { = - \\gamma P _ { \\pi } B \\displaystyle ( \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } ) } & { } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            643,
+            738,
+            821
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The above two results shows ",
+        "bbox": [
+            147,
+            121,
+            338,
+            135
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bef7958442606e4aaedeaf31a0bbb9ecfe6fb6d13581deeaa7e90595c6601c72.jpg",
+        "text": "$$\n\\gamma P _ { \\tilde { \\pi } } B ( \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } \\pmb { v } ^ { ( t - i ) } ) \\le B ( \\pmb { v } ^ { ( t ) } ) \\le \\gamma P _ { \\pi ^ { ( t ) } } \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } B ( \\pmb { v } ^ { ( t - i ) } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            137,
+            707,
+            181
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Now, consider the rejection step. First we show that if $v \\in V _ { B }$ then $\\Gamma ( \\pmb { v } ) \\in V _ { B }$ . If $v \\in V _ { B }$ , then $\\Gamma ( v ) \\geq v$ .   \nWith Lemma 3, we have that $\\Gamma ( \\Gamma ( \\pmb { v } ) ) \\geq \\Gamma ( \\pmb { v } )$ , i.e. $\\Gamma ( \\pmb { v } ) \\in V _ { B }$ . ",
+        "bbox": [
+            143,
+            193,
+            852,
+            224
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Next we show that if $\\pmb { v } ^ { ( i ) } \\in V _ { B }$ for $i < t$ , then ${ \\pmb v } ^ { ( t ) } \\in V _ { B }$ . According to the rejection algorithm, we have $\\begin{array} { r } { \\pmb { v } ^ { ( t ) } = \\Gamma ( \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } \\pmb { v } ^ { ( t - i ) } ) } \\end{array}$ . If $\\begin{array} { r } { \\Gamma ( \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } \\pmb { v } ^ { ( t - i ) } ) \\ge \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } \\pmb { v } ^ { ( t - i ) } } \\end{array}$ α(t)i v(t−i), then Pki=1 α(t)i v(t−i) ∈ VB and v(t) ∈ VB . If Γ(Pki=1 α(t)i $\\begin{array} { r } { \\Gamma ( \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } \\pmb { v } ^ { ( t - i ) } ) < \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } \\pmb { v } ^ { ( t - i ) } } \\end{array}$ α(t)i v(t−i), then v(t) = Γ(v(t−1)) due to the rejection step. Since $\\pmb { v } ^ { ( t - 1 ) } \\in V _ { B }$ , we have that ${ \\pmb v } ^ { ( t ) } \\in V _ { B }$ 1 . Therefore, we also have that ${ \\cal B } ( \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( k ) } v ^ { ( t - i ) } ) \\geq 0$ α(k)i v(t−i)) ≥ 0. We have that ",
+        "bbox": [
+            148,
+            229,
+            852,
+            314
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b2692f0e59bc7fe853d27c1ddb70c5cd730386e155a0ec9bc724edb74220e54d.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\| \\Gamma ( \\pmb { v } ^ { ( t ) } ) - \\pmb { v } ^ { t } \\| = \\| B ( \\pmb { v } ^ { ( t ) } ) \\| \\leq \\gamma \\| P _ { \\pi ^ { ( t ) } } \\| \\| \\displaystyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } B ( \\pmb { v } ^ { ( t - i ) } ) \\| } & { } \\\\ { \\leq \\gamma \\| B ( \\pmb { v } ^ { ( t - 1 ) } ) \\| = \\gamma \\| \\Gamma ( \\pmb { v } ^ { ( t - 1 ) } ) - \\pmb { v } ^ { ( t - 1 ) } \\| } & { } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            315,
+            705,
+            382
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The second inequality is due to the definition of $\\alpha _ { i } ^ { ( t ) }$ , $i = 1 , 2 , . . . , k$ ",
+        "bbox": [
+            147,
+            387,
+            591,
+            405
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Proof of Theorem 3 We prove the conclusion by induction. It is evident that the conclusion holds for the first $k - 1$ steps. Suppose the conclusion holds for the first $t - 1$ steps, then ",
+        "bbox": [
+            145,
+            417,
+            852,
+            449
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ba7b2038dda51c7a076d1a48ef06cb5fed3ecea9d32174b6b2a1e58cc7f4a23f.jpg",
+        "text": "$$\n\\begin{array} { r l } & { v ^ { ( t ) } = \\displaystyle \\operatorname* { m a x } _ { \\pi } ( r _ { \\pi } + \\gamma P _ { \\pi } \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } { \\pmb v } ^ { ( t - i ) } ) } \\\\ & { \\quad \\ge r _ { \\tilde { \\pi } } + \\gamma P _ { \\tilde { \\pi } } ( \\displaystyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } { \\pmb v } ^ { ( t - i ) } ) } \\\\ & { \\quad \\ge r _ { \\tilde { \\pi } } + \\gamma P _ { \\tilde { \\pi } } { \\pmb v } ^ { ( t - 1 ) } } \\\\ & { \\quad \\ge { \\pmb v } ^ { ( t - 1 ) } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            453,
+            627,
+            583
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\tilde { \\pi } = \\arg \\operatorname* { m a x } _ { \\pi } \\pmb { r } _ { \\pi } + \\gamma P _ { \\pi } \\pmb { v } ^ { ( t - 1 ) } } \\end{array}$ . The second inequality comes from the extrapolation restriction. The Third inequality is due to that if $v \\in V _ { B }$ then $\\Gamma ( \\pmb { v } ) \\in \\bar { V _ { B } }$ , which is shown in Theorem 2. ",
+        "bbox": [
+            143,
+            589,
+            852,
+            619
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "As shown in Theorem 2, we have that ${ \\pmb v } ^ { ( t ) } \\in V _ { B }$ and ${ \\textstyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } } { \\pmb v } ^ { ( t - i ) } \\in V _ { B }$ . Therefore, ${ \\pmb v } ^ { ( t ) } \\le { \\pmb v } ^ { * }$ ",
+        "bbox": [
+            148,
+            625,
+            799,
+            646
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0699c7e20d6507371e7ebdb35c3a0c76e57eda3a1bc4a70b4651cf60f7f9d2bf.jpg",
+        "text": "$$\n\\begin{array} { r l } & { v ^ { * } - v ^ { ( t ) } = v ^ { * } - \\displaystyle \\operatorname* { m a x } _ { \\pi } ( r _ { \\pi } + \\gamma P _ { \\pi } \\displaystyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } ) } \\\\ & { \\qquad \\le v ^ { * } - ( r _ { \\pi ^ { * } } + \\gamma P _ { \\pi ^ { * } } \\displaystyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } v ^ { ( t - i ) } ) } \\\\ & { \\qquad = \\gamma P _ { \\pi ^ { * } } \\displaystyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } ^ { ( t ) } ( v ^ { * } - v ^ { ( t - i ) } ) } \\\\ & { \\qquad \\le \\gamma P _ { \\pi ^ { * } } ( v ^ { * } - v ^ { ( t - 1 ) } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            667,
+            661,
+            821
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Taking the infinite norm on both sides, we get ",
+        "bbox": [
+            148,
+            119,
+            449,
+            136
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d93114bed3dd1593601d340e7c3d0b535dbcc01c3bef4b2d3c31dfb51118f597.jpg",
+        "text": "$$\n\\| \\pmb { v } ^ { * } - \\pmb { v } ^ { ( t ) } \\| _ { \\infty } \\leq \\gamma \\| P _ { \\pi ^ { * } } \\| _ { \\infty } \\| \\pmb { v } ^ { * } - \\pmb { v } ^ { ( t - 1 ) } \\| _ { \\infty } \\leq \\gamma \\| \\pmb { v } ^ { * } - \\pmb { v } ^ { ( t - 1 ) } \\| _ { \\infty } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            141,
+            717,
+            161
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "which completes the proof. ",
+        "bbox": [
+            148,
+            167,
+            326,
+            183
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "D. EXPERIMENT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            198,
+            328,
+            213
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "D.1 MODEL ARCHITECTURE AND HYPER-PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            224,
+            535,
+            239
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "For our experiments, we used the DQN(Mnih et al., 2013) architecture, where the $\\mathbf { Q }$ -value network is composed of 3 convolutional layers, 1 fully connected layer, and 1 output fully connected layer. Each layer except the final layer is followed with a rectified linear activation(ReLU). The first convolutional layer use 32 $8 \\times 8$ filters with stride 4, the second has $6 4 4 \\times 4$ filters with stride 2, and the third convolutional layer has 64 $3 \\times 3$ filters with stride 1. The fully connected layer consists of 512 units and the final layer outputs a single value for each action. We used the Adam optimizer with learning rate 0.0001 and $\\epsilon = 0 . 0 0 1 5$ . The discount was set to $\\gamma = 0 . 9 9$ . Training is done over 20M or 40M frames. We updated the target networks every 10000 steps. The size of experience replay buffer is 100000 tuples, where $3 2 \\mathrm { { m i n i } }$ batches were sampled every 4 steps to update the network. The exploration policy is $\\varepsilon$ -greedy policy with fixed $\\varepsilon = 0 . 0 1$ . ",
+        "bbox": [
+            147,
+            248,
+            852,
+            375
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "D.2 PREPROCESSING OF ENVIRONMENTS ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            390,
+            434,
+            404
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We preprocess the environment in the same way as the original DQN paper (Mnih et al., 2013) does. We utilize the action repeat technique, i.e., each action is repeated for the next four consecutive frames. The frames are firstly grey-scaled and then rescaled to the size of $8 4 \\times 8 4$ pixels. Each state is represented by a concatenation of 4 consecutive frames. We fix all positive rewards to be 1 and all negative rewards to be -1, leaving 0 rewards unchanged. Transitions associated with the loss of a life are considered terminal. ",
+        "bbox": [
+            148,
+            414,
+            852,
+            484
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "E. SOLVING (5) WHEN USING THE $\\ell _ { 2 }$ NORM AND TOTAL SPACE CONSTRAINT ",
+        "bbox": [
+            143,
+            500,
+            687,
+            516
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Under the given setting, we may rewrite the original problem in the following form, ",
+        "bbox": [
+            147,
+            526,
+            694,
+            542
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5d390c60106028f81402197c58347e1442ebb711ec596d6133067a67f812b419.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathrm { m i n i m i z e } \\ \\pmb { \\alpha } ^ { \\top } ( \\hat { B } ^ { ( t ) } ) ^ { \\top } \\hat { B } ^ { ( t ) } \\pmb { \\alpha } } \\\\ & { \\mathrm { s u b j e c t } \\ \\mathrm { t o \\ } \\mathbf { 1 } ^ { \\top } \\pmb { \\alpha } = 1 . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            546,
+            594,
+            588
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "This problem can be directly solved with an application of Lagrange multiplier method, namely, let $\\lambda$ be the Lagrange multiplier, then we solve the problem ",
+        "bbox": [
+            143,
+            594,
+            852,
+            623
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "equation",
+        "img_path": "images/acb083bb6070805d51777c5c5501ed9ef3fec46bef26a0425781bbff10f415e1.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\alpha } \\alpha ^ { \\top } ( \\hat { B } ^ { ( t ) } ) ^ { \\top } \\hat { B } ^ { ( t ) } \\alpha + \\lambda ( \\mathbf { 1 } ^ { \\top } \\alpha - 1 )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            628,
+            629,
+            655
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "whose solution can be written explicitly as $\\begin{array} { r } { \\pmb { \\alpha } = - \\frac { \\lambda } { 2 } [ ( \\hat { B } ^ { ( t ) } ) ^ { \\top } \\hat { B } ^ { ( t ) } ] ^ { - 1 } \\mathbf { 1 } } \\end{array}$ . Combine this result with the constraint, we can get $- \\textstyle { \\frac { \\lambda } { 2 } } = \\frac { 1 } { \\textstyle { \\frac { 1 ^ { \\top } [ ( \\hat { B } ^ { ( t ) } ) ^ { \\top } \\hat { B } ^ { ( t ) } ] ^ { - 1 } { \\bf 1 } } } }$ , which implies $\\begin{array} { r } { \\pmb { \\alpha } = \\frac { [ ( \\hat { B } ^ { ( t ) } ) ^ { \\top } \\hat { B } ^ { ( t ) } ] ^ { - 1 } \\mathbf { 1 } } { \\mathbf { 1 } ^ { \\top } [ ( \\hat { B } ^ { ( t ) } ) ^ { \\top } \\hat { B } ^ { ( t ) } ] ^ { - 1 } \\mathbf { 1 } } } \\end{array}$ . ",
+        "bbox": [
+            147,
+            661,
+            852,
+            705
+        ],
+        "page_idx": 15
+    }
+]

parse/train/SyxZOsA9tX/SyxZOsA9tX_middle.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/SyxZOsA9tX/SyxZOsA9tX_model.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/c8P9NQVtmnO/c8P9NQVtmnO_middle.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/rJlHIo09KQ/rJlHIo09KQ.md ADDED Viewed

	@@ -0,0 +1,348 @@

+# GRADIENT-BASED TRAINING OF SLOW FEATUREANALYSIS BY DIFFERENTIABLE APPROXIMATEWHITENING
+Anonymous authors Paper under double-blind review
+# ABSTRACT
+We propose Power Slow Feature Analysis, a gradient-based method to extract temporally slow features from a high-dimensional input stream that varies on a faster time-scale, as a variant of Slow Feature Analysis (SFA). While displaying performance comparable to hierarchical extensions to the SFA algorithm, such as Hierarchical Slow Feature Analysis, for a small number of output-features, our algorithm allows fully differentiable end-to-end training of arbitrary differentiable approximators (e.g., deep neural networks). We provide experimental evidence that PowerSFA is able to extract meaningful and informative low-dimensional features in the case of (a) synthetic low-dimensional data, (b) visual data, and also for (c) a general dataset for which symmetric non-temporal relations between points can be defined.
+# 1 INTRODUCTION
+Finding meaningful representations in data is a core challenge in modern machine learning as the performance in many goal-directed frameworks, such as reinforcement learning or supervised learning, is strongly influenced by the quality of the former. Usually, features are either domain specific or acquired through learning. Most currently successful approaches for either deep supervised learning (Goodfellow et al. (2016)) or reinforcement learning (Sutton & Barto (1998)) rely on a training signal, i.e., a classification label or reward, to provide sufficient indication which features of the input data should be extracted to increase performance. However, in most real-world scenarios labels have to be provided by expert knowledge and reward signals are sparse. In unsupervised representation learning, one tries to find and apply a principle by which to extract meaning from data without assuming the availability of any goal-driven metrics.
+Examples for such principles are based on reconstruction error in principal component analysis or autoencoder networks (Bourlard & Kamp (1988)), statistical dependence of extracted features in independent component analysis (Comon (1994)), indistinguishability of synthetically generated data from samples of the input distribution in generative adversarial nets (Goodfellow et al. (2014)). Further examples include: fitting the probability distribution of input data with variational autoencoders (Kingma & Welling (2013)), neighborhood preservation used in locally linear embedding (LLE, Roweis & Saul (2000)), Laplacian eigenmaps (LEM, Belkin & Niyogi (2003)), as well as temporal coherence as used in slow feature analysis, (SFA, Wiskott & Sejnowski (2002)) or regularized slowness optimization (Bengio & Bergstra (2009)). Temporal coherence is the focus of this work and has been shown to provide a useful proxy for extracting underlying causes from time-series data such as position, head direction, identity of spatial view similar to those observed in rodent brains (Franzius et al. (2007)) from ego-visual data. The principle has also been successfully applied to determining object configuration (identity, position, angle) from a tabletop view of moving objects (Franzius et al. (2011)) in the form of SFA. A graph-based generalization of SFA has been used to achieve (at that time) state-of-the-art age estimation results on the MORPH dataset in Escalante-B. (2017).
+We propose a variant of SFA that approximately enforces the same constraints while being differentiable and thus allows training by gradient-descent-derived methods. This makes it possible to leverage the representational power of complex models, such as deep neural networks, and useful ideas from that domain (dropout, batch normalization, activation regularization) to extract slow and informative features from data. To demonstrate the applicability of this approach, we provide three distinct experimental evaluations.
+# 2 RELATED WORK
+# 2.1 SLOWNESS-BASED METHODS
+While the original proposal of SFA by Wiskott & Sejnowski (2002) uses non-linear basis functions as a method to introduce non-linearity to the otherwise linear model, this classical approach has two limitations: (a) The basis functions are fixed and thus have to be chosen beforehand by expert knowledge or trial-and-error, and $\mathbf { ( b ) }$ as the resulting model is shallow, its expressivity tends to scale unfavorably in the dimension of the expansion (Raghu et al. (2016)) compared to hierarchical extensions discussed later. In the case of polynomial expansion, expanding to degree $d$ on $e$ -dimensional input data results in $\textstyle { \binom { d + e } { d } }$ -dimensional expanded data, e.g., quadratically expanding grayscale images of $1 8 0 \times 9 0$ pixels results in an output dimension $> 1 3 1 \cdot 1 0 ^ { 6 }$ . Extracting a single feature with a linear model would thus require 5.7-times more parameters than the modern and powerful Xception network (Chollet (2016)).
+An alternative approach to increase expressivity using expansions is to apply low-degree nonlinearities repeatedly in a receptive-field fashion, interlacing them with projection steps. This has been done in Hierarchical SFA (HSFA, Franzius et al. (2007) and Escalante-B. & Wiskott (2016)) and deep architectures in general. But while the latter are typically trained in an end-to-end fashion by variants of stochastic gradient-descent, HSFA is trained in a layer-wise procedure, solving the linear SFA problem consecutively for each layer as closed-form solution and thereby assuming that globally slow features can be composed of decreasingly local slow features. Escalante-B. & Wiskott (2016) shows that this assumption can be partially relaxed by adding information by-passes to the model. Compared to HSFA, our method allows directly modifying parameters in different layers to optimize a global slowness objective.
+Our algorithm is in line with recent work harnessing the temporal coherence prior by Bengio et al. (2013) in deep, self-supervised feature learning. This can be done by having a slowness term in the loss function. To avoid the trivial, constant solution, another term is usually added. For example, a reconstruction loss in an auto-encoder (Goroshin et al. (2015a)) or one-step latent code prediction (Goroshin et al. (2015b)). Deep temporal coherence has also been considered via the lens of similarity metric learning, for example by optimizing a contrastive loss (Jayaraman & Grauman (2016), Mobahi et al. (2009)) or a triplet loss (Jansen et al. (2017), Wang & Gupta (2015)). These metric learning approaches manage to avoid degenerate solutions by pushing points away from each other (in feature space) that are not temporal neighbors. Our work differs from these approaches as we seek to directly approximate the optimization problem as originally stated by Wiskott & Sejnowski (2002) in a deep learning setting, automatically handling the constant solution and ensuring that different features code for different information.
+# 2.2 GRAPH-BASED METHODS
+SFA has been generalized to graph-based SFA (GSFA, Escalante-B. & Wiskott (2013)) and generalized SFA (Sprekeler (2011)). The former adapts only the objective function, while the latter additionally generalizes the constraints to D-orthogonality $\mathbf { D }$ being the degree matrix of an underlying graph). Following generalized SFA, standard SFA can be shown to be a special case of Laplacian Eigenmaps.
+Spectral Inference Networks (SpIN, Pfau et al. (2018)) utilize this connection to successfully derive a gradient-based SFA training as a special case. They are based on correcting a biased gradient when directly optimizing the Rayleigh-Quotient with respect to the model’s parameters. The constraints are implicitly enforced through the loss function as opposed to directly whitening the output. Similar to our work, SpINs allow for employing any architecture to find these embeddings. However, the whitening proposed in this paper is applicable to any loss function as it is part of the model architecture and not inherently a part of the optimized objective.
+The generalization of PowerSFA proposed in section 6.3 is close to GSFA, assuming regularity (or rather: ignoring non-regularity) in the graph for the orthogonality constraint.
+SpectralNets (SN, Shaham et al. (2018)) are another closely related approach in which a differentiable approximator is trained to learn spectral embeddings used in subsequent $k$ -means clustering. Opposed to PowerSFA and SpINs, they split a single optimization step into two parts: an ortho-normalization step based on explicitly calculating the Cholesky decomposition of the batch covariance matrix to set and freeze the weights of a linear output layer, followed by a stochastic optimization step. While this can be considered end-to-end depending on the paradigm, Shaham et al. (2018) do not indicate if and how this can be implemented as fully differentiable architecture.
+# 2.3 OTHER RELATED APPROACHES
+In section 6.3 we consider a generalization of PowerSFA’s loss similar to GSFA and apply it to the NORB dataset (LeCun et al. (2004)). We thereby loosely follow the experimental procedure in Hadsell et al. (2006). The authors use a siamese neural network architecture (Bromley et al. (1993)) for optimizing pair-wise distances of embedded points to reflect similarity and dissimilarity structure of the data. In particular, they do not enforce orthogonality of the embeddings but rely on the optimization procedure to maximize informativeness.
+# 3 SLOW FEATURE ANALYSIS
+Slow Feature Analysis (SFA) is based on the hypothesis that interesting high-dimensional streams of data that vary quickly in time, are typically caused by a low number of underlying factors that vary comparably slow. Therefore, slowness can be used as a proxy criterion by which to extract meaningful representations of these low-dimensional underlying causes, even in the absence of labels.
+There is strong evidence in favor of this hypothesis, as it has been shown that features extracted by SFA tend to encode highly relevant information about the data-generating environments, e.g., slow features encode and disentangle object identity, rotation, and position in visual tasks (Franzius et al. (2011)) as well as agent position and orientation from visual first-person recordings of random movement similar to place cells in rodents, or head-direction cells in primates (Franzius et al. (2007)).
+The notion of extracting slow features from a time-series dataset has been formalized as a sequential optimization problem. Given a time-series $\{ x _ { t } \} _ { t = 0 \ldots \tau }$ with $\boldsymbol { x } _ { t } \in \mathbb { R } ^ { d }$ , sequentially find continuous functions $g _ { i } : \dot { \mathbb { R } ^ { d } }  \mathbb { R }$ with:
+$$
+\begin{array} { r l } { \underset { g _ { i } } { \operatorname* { m i n } } } & { \left. ( g _ { i } ( x _ { t + 1 } ) - g _ { i } ( x _ { t } ) ) ^ { 2 } \right. _ { t } } \\ { \mathrm { s . t . } } & { \left. g _ { i } ( x _ { t } ) \right. _ { t } = 0 , } \\ & { \left. g _ { i } ( x _ { t } ) ^ { 2 } \right. _ { t } = 1 , } \\ & { \left. g _ { i } ( x _ { t } ) g _ { j } ( x _ { t } ) \right. _ { t } = 0 , \forall j < i } \end{array}
+$$
+where $\langle \cdot \rangle _ { t }$ is the time-average. The constraints ensure that each of the extracted features is informative (decorrelated to all others, equation (1d)) and non-trivial (unit variance, equation (1c)). Originally, solutions to SFA directly were only proposed for the space of affine functions $g _ { i } \in \mathcal G$ , for which a closed-form solution exists, and in a kernelized version that requires strong regularization.
+# 4 (APPROXIMATE) WHITENING
+The standard implementation of linear SFA (Zito et al. (2008)) is based on computing the closedform solution to a generalized eigenvalue problem (Berkes & Wiskott (2005)). Another approach is to first whiten the time-series data, followed by a projection onto the minor components of the difference time-series {x˙ t = xt+1 − xt}t=0...τ−1.
+Whitened data has three important properties: (a) it is mean-free (constraint (1b)), (b) has unit variance if projected onto an arbitrary unit vector (constraint (1c)), and (c) projections onto orthonormal vectors are decorrelated (constraint (1d)).
+For a dataset $\tilde { \mathbf { X } } \in \mathbb { R } ^ { d \times N }$ with $N$ and $d$ being size and dimension of the dataset, respectively, the corresponding whitened dataset is defined as
+$$
+\begin{array} { r } { \mathbf { X } = \mathbf { W } \tilde { \mathbf { X } } } \end{array}
+$$
+with $\mathbf { W } = \mathbf { D } ^ { - \frac { 1 } { 2 } } \mathbf { U } ^ { T }$ and $\mathbf { C } = { \mathbf { U } } { \mathbf { D } } { \mathbf { U } } ^ { T } \in \mathbb { R } ^ { d \times d }$ being the whitening matrix and the canonical eigendecomposition of the covariance matrix, respectively. U’s columns contain the eigenvectors of $\mathbf { C }$ and $\mathbf { D }$ contains the corresponding eigenvalues on its diagonal. As $\mathbf { C }$ is typically assumed to be positive definite, $\mathbf { D } ^ { - \frac { 1 } { 2 } }$ is well-defined.
+One widely used method to extract eigenvector/-value pairs is power iteration. Starting from a random vector $u _ { 0 } \in _ { R } \mathbb { R } ^ { d }$ , repeatedly applying:
+$$
+u _ { i + 1 } = \frac { \mathbf { C } \mathbf { u } _ { i } } { \| \mathbf { C } \mathbf { u } _ { i } \| }
+$$
+converges to the eigenvector $u$ corresponding to the largest (absolute) eigenvalue $\lambda$ . The eigenvalue can then be extracted as
+$$
+\lambda = \| \mathbf C \mathbf u \|
+$$
+and the spectral component corresponding to this eigenvector can be removed as
+$$
+\mathbf { C } \gets \mathbf { C } - \lambda \mathbf { u } \mathbf { u } ^ { T } .
+$$
+Repeating the procedure converges to the eigenvector corresponding to the next largest eigenvalue and so on. We use a previously fixed number of iterations for this method as experiments have shown that approximate whitening is enough to take meaningful optimization steps. In practice, a relatively small number of iterations results in acceptable whitening for most non-degenerate cases.
+Data: covariance matrix $\mathbf { C }$ , number of iterations $N _ { \mathrm { i t e r } }$ , data dimension $d$
+Result: whitening matrix W
+$\mathbf { W } \gets \{ 0 \} ^ { d \times d }$
+for $i = 0 ; i < d ; i + + { \bf d o }$ Sample $\mathbf { r } \sim U [ - 1 , 1 ] ^ { d }$ for $j = 0 ; j < N _ { i t e r } ; j + + { \bf d o }$ r ← CrkCrk end $\begin{array} { r l } & { \lambda  \Vert \mathbf { C r } \Vert } \\ & { \mathbf { C }  \mathbf { C } - \lambda \mathbf { r r } ^ { T } } \\ & { \mathbf { w } _ { i \cdot } = \frac { 1 } { \sqrt { \lambda } } \mathbf { r } ^ { T } } \end{array}$
+end
+return W Algorithm 1: Constructing W by power iteration
+Note that in algorithm 1 each operation is differentiable with respect to C.
+# 5 GRADIENT-BASED SLOW FEATURE ANALYSIS
+The key idea for gradient-based SFA is that a whitening layer can be applied to any differentiable architecture (such as deep neural networks) to enforce outputs that approximately obey the SFA constraints while the architecture stays differentiable. As such, it can be trained using gradientdescent-like training procedures, allowing for hierarchical architectures, where every parameter is modified iteratively towards optimizing a global slowness objective, as opposed to assuming a localto-global slowness as in HSFA. To formalize, if
+$$
+\begin{array} { r l } { \tilde { g } _ { \theta } : \ } & { { } \mathbb { R } ^ { N \times d }  \mathbb { R } ^ { N \times e } } \end{array}
+$$
+is a differentiable function approximator, such as a neural network, parameterized by $\theta$ and
+$$
+\begin{array} { r l } { \mathcal { W } : } & { { } \mathbb { R } ^ { N \times e }  \mathbb { R } ^ { N \times e } } \end{array}
+$$
+denotes the approximate whitening procedure, then
+$$
+g _ { \theta } = \mathcal { W } \circ \tilde { g } _ { \theta } : \quad \mathbb { R } ^ { N \times d } \to \mathbb { R } ^ { N \times e }
+$$
+is an approximator whose outputs approximately obey the SFA constraints.
+It is straightforward to define a general loss function as
+$$
+L _ { \theta } ( { \bf X } ) = \frac { 1 } { N } \sum _ { i } \sum _ { j } w _ { i j } \| g _ { i } - g _ { j } \| ^ { 2 }
+$$
+with $g _ { i }$ being the $i$ -th row of $g _ { \boldsymbol { \theta } } ( \mathbf { X } )$ and $w _ { i j }$ being the strength of the connection between two points $x _ { i }$ and $x _ { j }$ similar to weights in spectral graph embeddings (cf. Sprekeler (2011) and Escalante-B. & Wiskott (2013)).
+For optimizing slowness, we define the weight as
+$$
+w _ { i j } = \delta _ { i , j + 1 }
+$$
+with $\delta$ being the Kronecker delta. This connects consecutive steps in the time-series and disconnects the others 1.
+The approximator can then be trained to minimize eq. 2 by following the negative gradient estimate of $L$ with respect to $\theta$ , $- \nabla _ { \theta } L$ for (mini-)batches of data, as common in a common in gradientbased training. In our experiments, we used the ADAM optimizer (Kingma & Ba (2014)) with Nesterov-accelerated momentum (Dozat (2015)) to train the approximator. Learning rate and additional hyperparameters were left at default values as implemented in the popular Keras-package (Chollet et al. (2015)).
+# 6 EXPERIMENTS
+# 6.1 SYNTHETIC TRIGONOMETRIC DATA
+To show the general feasibility of this approach, we first show that PowerSFA finds near-optimal solutions in the linear case for synthetic data. Standard SFA is a linear method that relies on (a) non-linear basis function expansion and $\mathbf { ( b ) }$ hierarchical processing to induce non-linearity. This means that PowerSFA could hypothetically be used a similar fashion (even though a gradient-based approach allows for more complex models in a natural way).
+The data is generated by trigonometric polynomials of degree $N$ as:
+$$
+\mathbf { x } ( t ) = \varepsilon _ { t } + \sum _ { n = 1 } ^ { N } \alpha _ { n } \cos \left( n t \right) + \beta _ { n } \sin \left( n t \right)
+$$
+with $\mathbf { x } , \pmb { \varepsilon } , \pmb { \alpha } , \pmb { \beta } \in \mathbb { R } ^ { D }$ , coefficients $\alpha _ { i n } , \beta _ { i n } \sim \mathcal { N } ( 0 , 1 )$ . A noise term $\varepsilon _ { i t } \sim \mathcal { N } ( 0 , 0 . 0 1 )$ is added to avoid numerical instabilities in the implementation of closed-form SFA, as singular covariance matrices can cause the underlying eigendecomposition to break.
+emented a temand dimension -size of . The da $\frac { 2 \pi } { 1 0 0 }$ , and generate s whitened wit $T = 5 0 0 0$ teps with maximum degree. $N = 3 0$ $D = 1 0 0$ $N _ { \mathrm { i t e r } } = 6 0$
+Figure 1 shows the extracted features for different variants of SFA. If the slowness loss is optimized without any constraints on the output features, the optimal solution is to collapse all signals to a constant $\Delta = 0 ,$ ), while if unit variance is enforced, only the features with slowness very close to the smallest $\Delta$ are extracted multiple times and thus the representation becomes highly redundant. When using the approximate whitening, the quality of the solutions is comparable to the closed form solution gained by solving a generalized eigenvalue problem. The ordering was achieved for representational purposes by weighting the output features with a monotonically decreasing weight. In Figure 2, the covariance matrices of the extracted signals are visualized.
+![](images/9f2661dd1afe4966f7dc640ab9badb69420052b00e0a570dfc7c2f83a480bbe1.jpg)
+Figure 1: First five features (100 steps) learned by a linear model in different settings. From left to right: (1) only slowness loss optimized, no constraints, (2) slowness loss with enforced unit variance, (3) slowness loss with enforced whitening, (4) closed form solution. The $\Delta$ -values indicate slowness (lower is slower).
+![](images/30be3dcafc3e6ab5c7cc36305fa480eec5326c24dd14654683d8ecf9154f981b.jpg)
+Figure 2: Covariance matrices for five outputs in different settings. (1) slowness loss without constraints leads to nearly constant signals with (co)variances close to zero, (2) unit variance enforced leads to highly correlated output signals, (3) & (4) (approximate) whitening and the closed form solution show fully decorrelated output signals (identity covariance).
+Note that it is not a sensible approach to use PowerSFA to optimize a linear model for such lowdimensional data as the closed-form solution is easily attainable. For this reason, this experiment should be understood as a proof-of-concept and a general demonstration of applicability rather than a recommendation for a use-case.
+A very low number of iterations will render the optimization unstable resulting in fast output signals. There seems to be no continuous trade-off between correlation and slowness mediated by the number of iterations. Thus, it is recommended to find a setting for $N _ { \mathrm { i t e r } }$ that allows for stable optimization. Appendix A contains a small hyper-parameter study, illustrating that behavior for the linear case.
+To provide evidence on how gradient-based SFA can improve on solutions found by closed-form SFA, we encapsulate the original signal in a non-linear distortion:
+$$
+\mathbf { u } ( t ) = \cos ( e ^ { \mathbf { x } ( t ) } )
+$$
+This makes it impossible to extract slow signals by linearly unmixing the original components. To make the extraction more difficult, the maximum degree was increased to $N = 3 0 0$ and the temporal step-size was decreased to $\frac { 2 \pi } { 1 0 ^ { 5 } }$ to reduce temporal aliasing of very fast input components. Consequently, we increased $T$ to $1 0 ^ { 5 }$ and $N _ { \mathrm { i t e r } }$ to 100.
+When applying closed-form SFA to non-linear problems, it is common to apply multiple low-degree polynomial expansions interlaced with linear SFA steps, to reduce the dimensionality, in a greedy layer-wise training. We use an architecture with three quadratic expansion layers (normalized to unit norm to avoid exploding gradients), and compare (a) closed-form training and (b) gradientbased training. We repeat the comparison for a multi-layer perceptron with tanh activation, since polynomial expansion functions are uncommon in gradient-trained models. Both architectures are provided in Appendix B. Table 1 shows the average output slowness, once for the raw output from the network (with small residue correlations possible due to whitening approximation error) and once with closed-form whitening applied to precisely enforce the constraints for the most meaningful comparison.
+<table><tr><td rowspan=1 colspan=1>Quadratic expansion</td><td rowspan=1 colspan=1>Closed-form</td><td rowspan=1 colspan=1>Gradient-based</td></tr><tr><td rowspan=1 colspan=1>Slowness</td><td rowspan=1 colspan=1>3.435:10-1 ±3.54:10-3</td><td rowspan=1 colspan=1>9.744·10-2 ± 1.67:10-2</td></tr><tr><td rowspan=1 colspan=1>Slowness (additional whitening)</td><td rowspan=1 colspan=1>3.435:10-1 ±3.54:10-3</td><td rowspan=1 colspan=1>9.743·10-2 ± 1.67: 10-2</td></tr></table>
+Table 1: Average slowness of 5 output features over 5 runs extracted by greedy layer-wise training and gradient-based training from non-linearly distorted trigonometric polynomials. Results for three-layer quadratic expansion network and neural network with tanh activation.
+<table><tr><td rowspan=1 colspan=1>Neural network (tanh)</td><td rowspan=1 colspan=1>Closed-form</td><td rowspan=1 colspan=1>Gradient-based</td></tr><tr><td rowspan=1 colspan=1>Slowness</td><td rowspan=1 colspan=1>8.562:10-1 ±6.79:10-3</td><td rowspan=1 colspan=1>2.755·10-1 ±9.891·10-2</td></tr><tr><td rowspan=1 colspan=1>Slowness (additional whitening)</td><td rowspan=1 colspan=1>8.562:10-1 ±6.79:10-3</td><td rowspan=1 colspan=1>2.755·10-1 ±9.891·10-2</td></tr></table>
+The results show that gradient-based training can improve slowness in multi-layer architectures compared to greedy layer-wise SFA. Note that increasing the output dimension of the dimensionality reduction steps (or dropping them altogether) in the quadratic expansion network will, unsurprisingly, lead to improved performance and ultimately to convergence to similar minima in both networks. However, this performance increase comes at the cost of high memory requirements and is usually not applicable in high-dimensional non-synthetic problems.
+# 6.2 POSE ESTIMATION FROM VISUAL DATA
+![](images/fa09e067b5a17e430324090ac424a299817b4cb8f9b1e53c25be49193321a7c2.jpg)
+Figure 3: Three samples from the anvil-dataset in different $x , y$ positions and rotational angle $\Phi$
+SFA can be used to extract slowly varying underlying causes from high-dimensional data, such as object position, identity, and rotation from visual simulations. In Franzius et al. (2011), textured three-dimensional fish-objects that change in $x$ - and $y$ -position as well as in-depth rotation $\phi$ have been used and it has been shown that HSFA features encode position and angle well. Since the code used to generate the stimulus data was outdated and could not be executed anymore, we reimplemented a similar scenario with a 3D model of an anvil (Figure 3, Pino4et (2016)) using the random walk procedure described in Franzius et al. (2011) to generate the configurations.
+![](images/c40a1421e2f49e02d53f211f91ae113888e6e307334294f5e48a8d7d9849ed25.jpg)
+Figure 4: Spread of the predicted $x$ - and $y$ -position of the anvil-dataset for a trained network (4a) and a randomly initialized network (4b). RMSE for the trained network on unseen data are $9 \%$ and $8 \%$ for $x \cdot$ - and $y$ - position respectively. RMSE for the random network on unseen data are $2 1 \%$ and $2 1 \%$ .
+A current limitation of our model (cf. section 7) is that it does not scale well in the number of output features, rendering the relatively high number of 512 output features used by Franzius et al. (2011) infeasible. We used an output dimension of 10 with a comparable architecture that replaces quadratic expansion by ELU-nonlinearities (a Keras-summary is given in Appendix C). Due to the low number of output features, we were not able to successfully extract the rotational angle $\Phi$ .
+In line with the original publication, we computed linear regression to predict $c o s ( \pi x )$ and $c o s ( \pi y )$ and used the inverse transformation to extract the object position. The results are shown in Figure 4 and are comparable to those presented by Franzius et al. (2011) as they were able to achieve a RMSE of $9 \%$ for $x$ -position and $7 \%$ for $y$ -position.
+# 6.3 NORB
+While gradient-based SFA is the main contribution of this work, previous work on generalizing SFA (Sprekeler (2011)) has shown that the SFA optimization problem is strongly related to a special case of the problem solved by a more general spectral embedding method, i.e., Laplacian Eigenmaps (Belkin & Niyogi (2003)), or, with small differences, graph-based SFA (Escalante-B. & Wiskott (2013)). For this reason, we defined a more general loss function in equation 2.
+![](images/0ad6898c7bb85f39d6a06c714e07964d99b7cd068df375f094560633db02485b.jpg)
+Figure 5: The embedded object from the NORB dataset. Samples differ in azimuth, elevation and lighting.
+In fact, weights $w _ { i j }$ can be defined between any two points $x _ { i }$ and $x _ { j }$ of a given dataset, not just consecutive ones, thus allowing to optimize neighborhood-respecting embeddings for general graphs. This is similar (but not fully equivalent) to spectral embeddings on graph data, as used in algorithms such as Laplacian eigenmaps. Our approach exhibits four significant differences:
+1. It does not find ordered features, but a rotation of an optimal embedding,
+2. the found solution should be assumed to be only locally optimal (or a saddle point),
+3. it does ignore the graph (ir)regularity when enforcing the orthogonality constraint, and
+4. it allows a natural and scalable way to embed unseen points.
+Computing an out-of-sample embedding requires the same forward-pass through the differentiable architecture as the training embeddings. In particular, its complexity does not scale with the number of observed points used for training as is usually the case in other approximations, such as Nyström approximation (Williams & Seeger (2001)).
+We demonstrate the usefulness of such an approach by embedding an object of the NORB dataset, a collection of photographs of toys taken at different elevations, azimuths, and under different lighting conditions with the MobileNet architecture (Sandler et al. (2018)) scaled with $\alpha = 0 . 5$ and a depth multiplier of 2 in the Keras implementation. Following Hadsell et al. (2006), we embedded photographs of a toy plane (Figure 5) in 972 configurations (18 azimuths $\times ~ 6$ lighting conditions $\times ~ 9$ elevations angles) that were randomly split into a train- and test-set of sizes 660 and 312 respectively and the connection weights $w _ { i j }$ were chosen as 1 if $x _ { i }$ and $x _ { j }$ differed only in one step either in rotation (i.e., one azimuth) or elevation (i.e., one level) and 0 otherwise. The weights were independent of lighting condition.
+![](images/02e852d3071d26f8c1d6cbc54992611d6e89af767c6a4ea5e80c600876107f49.jpg)
+Figure 6: Cylindrical embedding of NORB plane with azimuth colored. 6a and 6b show the embedded training data from the front and the side of the cylinder respectively, while 6c and 6d show the test data for the same configuration. Circumference of the cylinder encodes the rotation of the plane.
+![](images/06ae454a58f922984f33d82e1e529b70b8004286f14ed3968b209de6bbf65c55.jpg)
+Figure 7: Cylindrical embedding of NORB plane with elevation colored. 7a and 7b show the embedded training data from the front and the side of the cylinder respectively, while 7c and 7d show the test data for the same configuration. Height on the cylinder encodes the photograph’s elevation angle.
+Figures 6 and 7 show the three-dimensional embedding that was found in this setting. The data was embedded in a cylindrical shape in which the circumference encodes the rotation angle of the embedded object, and the length along the cylinder encodes the elevation configuration of the object for the train-set and in the out-of-sample case of the test-set. Hadsell et al. (2006) found a similar cylindrical encoding, however, their results exhibit a more clean-cut embedding. We assume that this is due to DrLIM’s maximization of distance for dissimilar samples that our model does not implement.
+# 7 DISCUSSION
+We propose a new way of extracting informative slow features from quickly varying inputs based on differentiable whitening of processed batches of the input data. To experimentally show the feasibility of the method, we trained a linear and two non-linear models to extract slowly varying output signals from synthetic time-series by gradient-descent, and find that the differentiable whitening ensures informativeness of the extracted features when optimizing a slowness loss function. Furthermore, the features corresponded to those found by closed-form SFA. 2
+To show applicability to visual time-series data, we trained a convolutional neural network on an input stream of an object randomly rotating in-depth and moving in a 2-dimensional plane. Gradientbased SFA preserves the position of the object in a low-dimensional representation, as does a hierarchical version of closed-form SFA. The rotation was not extracted successfully due to computational constraints in the naive implementation for a large number of output features (cf. 7).
+One experiment was conducted on a non-time-series image dataset on which symmetric similarity relations between the data are defined. We show that a generalization of gradient-based SFA in the spirit of graph-based SFA is able to extract a low-dimensional representation that preserves and disentangles the configuration parameters used to define the similarity, in this case, azimuth and elevation of a photographed toy. This representation generalizes well to previously unseen configurations of the object.
+While the algorithm is still in a prototypical state, the proof-of-concept results presented in this paper show promise for gradient-based SFA by differentiable whitening to extract meaningful representations for goal-oriented learning while leveraging the expressive power of modern architectures, such as convolutional neural networks. In particular, differentiable whitening ensures non-redundancy of the output features.
+More research has to be dedicated to explore the computational limitations of this method and possibly lower the complexity for a larger number of output features. Furthermore, closed-form SFA has a strong theoretical framework describing the optimal responses in an idealized setting. At this point, we are unclear how well this framework translates to the proposed method of slowness extraction as the used models typically suffer from local optima when being iteratively trained.
+One limitation of PowerSFA is that it currently does not scale favorably in the number of output features $e$ . We see two main reasons for this: the necessary batch size to get a meaningful estimate of the batch-covariance estimate and its calculation. The latter is due to the complexity of a naive $\mathbb { R } ^ { e \times N _ { \mathrm { b a t c h } } }$ · $\mathbb { R } ^ { N _ { \mathrm { b a t c h } } \times e }$ matrix-multiplication being $\mathcal { O } ( N _ { \mathrm { b a t c h } } e ^ { 2 } )$ , while the former is due to the whitening procedure expecting a covariance matrix of full rank and thus $N _ { \mathrm { b a t c h } } \ge e$ samples.
+To reduce the lower bound on the batch-size at batch $t$ , a convex mixture with the covariance matrix of the previous batch might be applicable:
+$$
+\mathbf { C } _ { t } = ( 1 - \gamma ) \mathbf { C } _ { \theta } + \gamma \mathbf { C } _ { t - 1 }
+$$
+Note, that only the current batch’s covariance matrix $\mathbf { C } _ { \theta }$ is considered parameter-dependent and allows to propagate a gradient for training. Thus, large values for $\gamma$ might cause a significant bias in the gradient-estimate. This has not been used to generate the proof-of-concept results for this paper.
+# REFERENCES
+Mikhail Belkin and Partha Niyogi. Laplacian eigenmaps for dimensionality reduction and data representation. Neural Comput., 15(6):1373–1396, June 2003. ISSN 0899-7667. doi: 10.1162/ 089976603321780317.
+Yoshua Bengio and James S. Bergstra. Slow, decorrelated features for pretraining complex celllike networks. In Y. Bengio, D. Schuurmans, J. D. Lafferty, C. K. I. Williams, and A. Culotta (eds.), Advances in Neural Information Processing Systems 22, pp. 99–107. Curran Associates, Inc., 2009.
+Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. IEEE transactions on pattern analysis and machine intelligence, 35(8):1798–1828, 2013.
+Pietro Berkes and Laurenz Wiskott. Slow feature analysis yields a rich repertoire of complex cell properties. Journal of Vision, 5(6), 2005.
+H. Bourlard and Y. Kamp. Auto-association by multilayer perceptrons and singular value decomposition. Biological Cybernetics, 59(4):291–294, Sep 1988. ISSN 1432-0770. doi: 10.1007/BF00332918.
+Jane Bromley, Isabelle Guyon, Yann LeCun, Eduard Säckinger, and Roopak Shah. Signature verification using a "siamese" time delay neural network. In Proceedings of the 6th International Conference on Neural Information Processing Systems, NIPS’93, pp. 737–744, San Francisco, CA, USA, 1993. Morgan Kaufmann Publishers Inc.
+Francois Chollet. Xception: Deep learning with depthwise separable convolutions. CoRR, abs/1610.02357, 2016.
+Francois Chollet et al. Keras. https://github.com/fchollet/keras, 2015.
+Pierre Comon. Independent component analysis, a new concept? Signal Processing, 36(3):287 – 314, 1994. ISSN 0165-1684. doi: https://doi.org/10.1016/0165-1684(94)90029-9. Higher Order Statistics.
+Timothy Dozat. Incorporating nesterov momentum into adam. http://cs229.stanford.edu/proj2015/054_report.pdf, 2015.
+Alberto N. Escalante-B. Extensions of Hierarchical Slow Feature Analysis for Efficient Classification and Regression on High-Dimensional Data. PhD thesis, Ruhr-University Bochum, 2017.
+Alberto N. Escalante-B. and Laurenz Wiskott. How to solve classification and regression problems on high-dimensional data with a supervised extension of slow feature analysis. J. Mach. Learn. Res., 14(1):3683–3719, December 2013. ISSN 1532-4435.
+Alberto N. Escalante-B. and Laurenz Wiskott. Improved graph-based SFA: information preservation complements the slowness principle. CoRR, abs/1601.03945, 2016.
+Mathias Franzius, Henning Sprekeler, and Laurenz Wiskott. Slowness and sparseness lead to place, head-direction, and spatial-view cells. PLOS Computational Biology, 3(8):1–18, 08 2007. doi: 10.1371/journal.pcbi.0030166.
+Mathias Franzius, Niko Wilbert, and Laurenz Wiskott. Invariant object recognition and pose estimation with slow feature analysis. Neural Computation, 23(9):2289–2323, 2011. doi: 10.1162/NECO\_a\_00171. PMID: 21671784.
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Z. Ghahramani, M. Welling, C. Cortes, N. D. Lawrence, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 27, pp. 2672–2680. Curran Associates, Inc., 2014.
+Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016. http://www.deeplearningbook.org.
+Ross Goroshin, Joan Bruna, Jonathan Tompson, David Eigen, and Yann LeCun. Unsupervised feature learning from temporal data. arXiv preprint arXiv:1504.02518, 2015a.
+Ross Goroshin, Michael F Mathieu, and Yann LeCun. Learning to linearize under uncertainty. In Advances in Neural Information Processing Systems, pp. 1234–1242, 2015b.
+Raia Hadsell, Sumit Chopra, and Yann Lecun. Dimensionality reduction by learning an invariant mapping. In In Proc. Computer Vision and Pattern Recognition Conference (CVPR’06. IEEE Press, 2006.
+Aren Jansen, Manoj Plakal, Ratheet Pandya, Daniel PW Ellis, Shawn Hershey, Jiayang Liu, R Channing Moore, and Rif A Saurous. Unsupervised learning of semantic audio representations. arXiv preprint arXiv:1711.02209, 2017.
+Dinesh Jayaraman and Kristen Grauman. Slow and steady feature analysis: higher order temporal coherence in video. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3852–3861, 2016.
+D. P Kingma and M. Welling. Auto-Encoding Variational Bayes. ArXiv e-prints, December 2013.
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014.
+Yann LeCun, Fu Jie Huang, and Léon Bottou. Learning methods for generic object recognition with invariance to pose and lighting. In Proceedings of the 2004 IEEE Computer Society Conference on Computer Vision and Pattern Recognition, CVPR’04, pp. 97–104, Washington, DC, USA, 2004. IEEE Computer Society.
+Hossein Mobahi, Ronan Collobert, and Jason Weston. Deep learning from temporal coherence in video. In Proceedings of the 26th Annual International Conference on Machine Learning, pp. 737–744. ACM, 2009.
+D. Pfau, S. Petersen, A. Agarwal, D. Barrett, and K. Stachenfeld. Spectral Inference Networks: Unifying Spectral Methods With Deep Learning. ArXiv e-prints, June 2018.
+Pino4et. Anvil lowpoly. https://www.turbosquid.com/FullPreview/Index.cfm/ID/1067450, 2016. [Online, Royalty Free 3D Object].
+M. Raghu, B. Poole, J. Kleinberg, S. Ganguli, and J. Sohl-Dickstein. On the Expressive Power of Deep Neural Networks. ArXiv e-prints, June 2016.
+Sam T. Roweis and Lawrence K. Saul. Nonlinear dimensionality reduction by locally linear embedding. SCIENCE, 290:2323–2326, 2000.
+Mark Sandler, Andrew G. Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Inverted residuals and linear bottlenecks: Mobile networks for classification, detection and segmentation. CoRR, abs/1801.04381, 2018.
+Uri Shaham, Kelly Stanton, Henry Li, Ronen Basri, Boaz Nadler, and Yuval Kluger. Spectralnet: Spectral clustering using deep neural networks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } }$ HJ_aoCyRZ.
+Henning Sprekeler. On the Relation of Slow Feature Analysis and Laplacian Eigenmaps. Neural Computation, 23(12):3287–3302, December 2011. ISSN 0899-7667. doi: 10.1162/neco\_a\ _00214.
+Richard S. Sutton and Andrew Barto. Reinforcement Learning: An Introduction. MIT Press, 1998.
+Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2794–2802, 2015.
+Christopher K. I. Williams and Matthias Seeger. Using the Nyström method to speed up kernel machines. In T. K. Leen, T. G. Dietterich, and V. Tresp (eds.), Advances in Neural Information Processing Systems 13, pp. 682–688. MIT Press, 2001.
+Laurenz Wiskott and Terrence Sejnowski. Slow feature analysis: unsupervised learning of invariances. Neural Computation, 14(4):715–770, 2002. doi: http://doi.org/10.1162/ 089976602317318938.
+T. Zito, N. Wilbert, L. Wiskott, and P. Berkes. Modular toolkit for data processing (mdp): a python data processing framework. Frontiers in Neuroinformatics, 2:8, 2008. doi: 10.3389/neuro.11. 008.2008.
+# Appendices
+![](images/5d1d7731e9cc6bf8ac7c8f7e86d1b0365d359caf8b11e5f94980192d3aeaf3dc.jpg)
+Figure 8: The mean squared velocity (unnormalized $\Delta$ value) per feature for an increasing number of power iterations, averaged over 10 trials. For no power iterations, the velocity is close to 0, but for a too small positive number of power iterations the optimization becomes unstable and results in sub-optimal performance.
+![](images/33607e4352d46a86e29f2857a79825b015d9d8abcb85ea3fe150cadd9ed10d11.jpg)
+Figure 9: The average covariance (auto-variances not included) for an increasing number of power iterations, averaged over 10 trials. Without whitening, the covariance is close to 1, but the features quickly become decorrelated when the number of iterations is increased.
+# B COMPARISON ARCHITECTURES (SYNTHETIC DATA)
+This appendix presents the architectures used for comparing greedy layer-wise with gradient-based end-to-end training of SFA. Both networks have been trained with both training methods. In the gradient-based setting, the Keras’s Nadam optimizer has been used with default hyperparameters and a whitening layer has been applied to the network output.
+<table><tr><td rowspan=1 colspan=2>Quadratic expansion network</td></tr><tr><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>Output dimension</td></tr><tr><td rowspan=1 colspan=1>Input Layer</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>Linear LayerQuadratic Expansion</td><td rowspan=1 colspan=1>33594</td></tr><tr><td rowspan=1 colspan=1>Linear LayerQuadratic Expansion</td><td rowspan=1 colspan=1>33594</td></tr><tr><td rowspan=1 colspan=1>Linear LayerQuadratic Expansion</td><td rowspan=1 colspan=1>33594</td></tr><tr><td rowspan=1 colspan=1>Linear Layer</td><td rowspan=1 colspan=1>5</td></tr></table>
+Table 2: A network with multiple quadratic expansions, each preceded by linear dimensionalityreduction. These kind of networks are typically used in closed-form SFA as they trade-off model expressivity with memory requirements.
+<table><tr><td rowspan=1 colspan=2>Neural network(tanh)</td></tr><tr><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>Output dimension</td></tr><tr><td rowspan=1 colspan=1>Input Layer</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>Linear LayerPointwise tanh</td><td rowspan=1 colspan=1>100100</td></tr><tr><td rowspan=1 colspan=1>Linear LayerPointwise tanh</td><td rowspan=1 colspan=1>100100</td></tr><tr><td rowspan=1 colspan=1>Linear LayerPointwise tanh</td><td rowspan=1 colspan=1>100100</td></tr><tr><td rowspan=1 colspan=1>Linear Layer</td><td rowspan=1 colspan=1>5</td></tr></table>
+Table 3: A simple multi-layer neural network using a tanh activation function to induce non-linearity.
+C KERAS DESCRIPTION (HSFA-LIKE ARCHITECTURE)
+<table><tr><td>Layer (type)</td><td></td><td>Output Shape</td><td></td><td>Param #</td></tr><tr><td>input_1</td><td>(InputLayer)</td><td>(None, 156，</td><td>156，1)</td><td>0</td></tr><tr><td>conv2d_1</td><td>(Conv2D)</td><td>(None, 147，</td><td>147， 32）</td><td>3232</td></tr><tr><td>activation_1</td><td>(Activation)</td><td>(None， 147，</td><td>147， 32)</td><td>0</td></tr><tr><td>dropout_1</td><td>（Dropout)</td><td>(None， 147，</td><td>147， 32）</td><td>0</td></tr><tr><td>conv2d_2</td><td>(Conv2D)</td><td>(None， 28，</td><td>28， 32）</td><td>102432</td></tr><tr><td>activation_2</td><td>(Activation)</td><td>(None, 28，</td><td>28， 32）</td><td>0</td></tr><tr><td>dropout_2</td><td>(Dropout)</td><td>(None， 28，</td><td>28， 32）</td><td>0</td></tr><tr><td>conv2d_3</td><td>(Conv2D)</td><td>(None， 25，</td><td>25， 32）</td><td>16416</td></tr><tr><td>activation_3</td><td>(Activation)</td><td>(None, 25，</td><td>25， 32）</td><td>0</td></tr><tr><td>dropout_3</td><td>(Dropout)</td><td>(None， 25，</td><td>25， 32）</td><td>0</td></tr><tr><td>conv2d_4 (Conv2D)</td><td></td><td>(None, 11，</td><td>11， 32）</td><td>16416</td></tr><tr><td>activation_4</td><td>(Activation)</td><td>(None， 11，</td><td>11， 32）</td><td>0</td></tr><tr><td>dropout_4 (Dropout)</td><td></td><td>(None，</td><td>11，11， 32）</td><td>0</td></tr><tr><td>conv2d_5</td><td>(Conv2D)</td><td>(None， 8，</td><td>8，32)</td><td>16416</td></tr><tr><td>activation_5</td><td>(Activation)</td><td>(None， 8，</td><td>8， 32）</td><td>0</td></tr><tr><td>dropout_5</td><td>(Dropout)</td><td>(None, 8，</td><td>8， 32）</td><td>0</td></tr><tr><td>conv2d_6 (Conv2D)</td><td></td><td>(None，3，3，32)</td><td></td><td>16416</td></tr><tr><td>activation_6</td><td>(Activation)</td><td>(None，</td><td>3，3，32)</td><td>0</td></tr><tr><td>dropout_6 （Dropout)</td><td></td><td>(None， 3，3，</td><td>32)</td><td>0</td></tr><tr><td>flatten_ 1 (Flatten)</td><td></td><td>(None， 288）</td><td></td><td>0</td></tr><tr><td>dense_1 (Dense)</td><td></td><td>(None， 10）</td><td></td><td>2890</td></tr><tr><td>power_whitening_1</td><td>(PowerWhit</td><td>(None， 10）</td><td></td><td>0</td></tr><tr><td colspan="5">Total params: 174,218 Trainable params: 174,218 Non-trainable params:0</td></tr></table>

parse/train/rJlHIo09KQ/rJlHIo09KQ_content_list.json ADDED Viewed

	@@ -0,0 +1,1795 @@

+[
+    {
+        "type": "text",
+        "text": "GRADIENT-BASED TRAINING OF SLOW FEATUREANALYSIS BY DIFFERENTIABLE APPROXIMATEWHITENING",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            170
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            195,
+            398,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            261,
+            544,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose Power Slow Feature Analysis, a gradient-based method to extract temporally slow features from a high-dimensional input stream that varies on a faster time-scale, as a variant of Slow Feature Analysis (SFA). While displaying performance comparable to hierarchical extensions to the SFA algorithm, such as Hierarchical Slow Feature Analysis, for a small number of output-features, our algorithm allows fully differentiable end-to-end training of arbitrary differentiable approximators (e.g., deep neural networks). We provide experimental evidence that PowerSFA is able to extract meaningful and informative low-dimensional features in the case of (a) synthetic low-dimensional data, (b) visual data, and also for (c) a general dataset for which symmetric non-temporal relations between points can be defined. ",
+        "bbox": [
+            233,
+            292,
+            764,
+            445
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            474,
+            336,
+            489
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Finding meaningful representations in data is a core challenge in modern machine learning as the performance in many goal-directed frameworks, such as reinforcement learning or supervised learning, is strongly influenced by the quality of the former. Usually, features are either domain specific or acquired through learning. Most currently successful approaches for either deep supervised learning (Goodfellow et al. (2016)) or reinforcement learning (Sutton & Barto (1998)) rely on a training signal, i.e., a classification label or reward, to provide sufficient indication which features of the input data should be extracted to increase performance. However, in most real-world scenarios labels have to be provided by expert knowledge and reward signals are sparse. In unsupervised representation learning, one tries to find and apply a principle by which to extract meaning from data without assuming the availability of any goal-driven metrics. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            645
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Examples for such principles are based on reconstruction error in principal component analysis or autoencoder networks (Bourlard & Kamp (1988)), statistical dependence of extracted features in independent component analysis (Comon (1994)), indistinguishability of synthetically generated data from samples of the input distribution in generative adversarial nets (Goodfellow et al. (2014)). Further examples include: fitting the probability distribution of input data with variational autoencoders (Kingma & Welling (2013)), neighborhood preservation used in locally linear embedding (LLE, Roweis & Saul (2000)), Laplacian eigenmaps (LEM, Belkin & Niyogi (2003)), as well as temporal coherence as used in slow feature analysis, (SFA, Wiskott & Sejnowski (2002)) or regularized slowness optimization (Bengio & Bergstra (2009)). Temporal coherence is the focus of this work and has been shown to provide a useful proxy for extracting underlying causes from time-series data such as position, head direction, identity of spatial view similar to those observed in rodent brains (Franzius et al. (2007)) from ego-visual data. The principle has also been successfully applied to determining object configuration (identity, position, angle) from a tabletop view of moving objects (Franzius et al. (2011)) in the form of SFA. A graph-based generalization of SFA has been used to achieve (at that time) state-of-the-art age estimation results on the MORPH dataset in Escalante-B. (2017). ",
+        "bbox": [
+            174,
+            654,
+            825,
+            873
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a variant of SFA that approximately enforces the same constraints while being differentiable and thus allows training by gradient-descent-derived methods. This makes it possible to leverage the representational power of complex models, such as deep neural networks, and useful ideas from that domain (dropout, batch normalization, activation regularization) to extract slow and informative features from data. To demonstrate the applicability of this approach, we provide three distinct experimental evaluations. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            171,
+            339,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 SLOWNESS-BASED METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            207,
+            418,
+            222
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While the original proposal of SFA by Wiskott & Sejnowski (2002) uses non-linear basis functions as a method to introduce non-linearity to the otherwise linear model, this classical approach has two limitations: (a) The basis functions are fixed and thus have to be chosen beforehand by expert knowledge or trial-and-error, and $\\mathbf { ( b ) }$ as the resulting model is shallow, its expressivity tends to scale unfavorably in the dimension of the expansion (Raghu et al. (2016)) compared to hierarchical extensions discussed later. In the case of polynomial expansion, expanding to degree $d$ on $e$ -dimensional input data results in $\\textstyle { \\binom { d + e } { d } }$ -dimensional expanded data, e.g., quadratically expanding grayscale images of $1 8 0 \\times 9 0$ pixels results in an output dimension $> 1 3 1 \\cdot 1 0 ^ { 6 }$ . Extracting a single feature with a linear model would thus require 5.7-times more parameters than the modern and powerful Xception network (Chollet (2016)). ",
+        "bbox": [
+            174,
+            234,
+            825,
+            378
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "An alternative approach to increase expressivity using expansions is to apply low-degree nonlinearities repeatedly in a receptive-field fashion, interlacing them with projection steps. This has been done in Hierarchical SFA (HSFA, Franzius et al. (2007) and Escalante-B. & Wiskott (2016)) and deep architectures in general. But while the latter are typically trained in an end-to-end fashion by variants of stochastic gradient-descent, HSFA is trained in a layer-wise procedure, solving the linear SFA problem consecutively for each layer as closed-form solution and thereby assuming that globally slow features can be composed of decreasingly local slow features. Escalante-B. & Wiskott (2016) shows that this assumption can be partially relaxed by adding information by-passes to the model. Compared to HSFA, our method allows directly modifying parameters in different layers to optimize a global slowness objective. ",
+        "bbox": [
+            174,
+            386,
+            825,
+            525
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our algorithm is in line with recent work harnessing the temporal coherence prior by Bengio et al. (2013) in deep, self-supervised feature learning. This can be done by having a slowness term in the loss function. To avoid the trivial, constant solution, another term is usually added. For example, a reconstruction loss in an auto-encoder (Goroshin et al. (2015a)) or one-step latent code prediction (Goroshin et al. (2015b)). Deep temporal coherence has also been considered via the lens of similarity metric learning, for example by optimizing a contrastive loss (Jayaraman & Grauman (2016), Mobahi et al. (2009)) or a triplet loss (Jansen et al. (2017), Wang & Gupta (2015)). These metric learning approaches manage to avoid degenerate solutions by pushing points away from each other (in feature space) that are not temporal neighbors. Our work differs from these approaches as we seek to directly approximate the optimization problem as originally stated by Wiskott & Sejnowski (2002) in a deep learning setting, automatically handling the constant solution and ensuring that different features code for different information. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            698
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 GRAPH-BASED METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            722,
+            393,
+            734
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "SFA has been generalized to graph-based SFA (GSFA, Escalante-B. & Wiskott (2013)) and generalized SFA (Sprekeler (2011)). The former adapts only the objective function, while the latter additionally generalizes the constraints to D-orthogonality $\\mathbf { D }$ being the degree matrix of an underlying graph). Following generalized SFA, standard SFA can be shown to be a special case of Laplacian Eigenmaps. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            819
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Spectral Inference Networks (SpIN, Pfau et al. (2018)) utilize this connection to successfully derive a gradient-based SFA training as a special case. They are based on correcting a biased gradient when directly optimizing the Rayleigh-Quotient with respect to the model’s parameters. The constraints are implicitly enforced through the loss function as opposed to directly whitening the output. Similar to our work, SpINs allow for employing any architecture to find these embeddings. However, the whitening proposed in this paper is applicable to any loss function as it is part of the model architecture and not inherently a part of the optimized objective. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The generalization of PowerSFA proposed in section 6.3 is close to GSFA, assuming regularity (or rather: ignoring non-regularity) in the graph for the orthogonality constraint. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "SpectralNets (SN, Shaham et al. (2018)) are another closely related approach in which a differentiable approximator is trained to learn spectral embeddings used in subsequent $k$ -means clustering. Opposed to PowerSFA and SpINs, they split a single optimization step into two parts: an ortho-normalization step based on explicitly calculating the Cholesky decomposition of the batch covariance matrix to set and freeze the weights of a linear output layer, followed by a stochastic optimization step. While this can be considered end-to-end depending on the paradigm, Shaham et al. (2018) do not indicate if and how this can be implemented as fully differentiable architecture. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            236
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 OTHER RELATED APPROACHES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            252,
+            431,
+            267
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In section 6.3 we consider a generalization of PowerSFA’s loss similar to GSFA and apply it to the NORB dataset (LeCun et al. (2004)). We thereby loosely follow the experimental procedure in Hadsell et al. (2006). The authors use a siamese neural network architecture (Bromley et al. (1993)) for optimizing pair-wise distances of embedded points to reflect similarity and dissimilarity structure of the data. In particular, they do not enforce orthogonality of the embeddings but rely on the optimization procedure to maximize informativeness. ",
+        "bbox": [
+            174,
+            277,
+            825,
+            362
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 SLOW FEATURE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            381,
+            428,
+            397
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Slow Feature Analysis (SFA) is based on the hypothesis that interesting high-dimensional streams of data that vary quickly in time, are typically caused by a low number of underlying factors that vary comparably slow. Therefore, slowness can be used as a proxy criterion by which to extract meaningful representations of these low-dimensional underlying causes, even in the absence of labels. ",
+        "bbox": [
+            174,
+            411,
+            823,
+            482
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There is strong evidence in favor of this hypothesis, as it has been shown that features extracted by SFA tend to encode highly relevant information about the data-generating environments, e.g., slow features encode and disentangle object identity, rotation, and position in visual tasks (Franzius et al. (2011)) as well as agent position and orientation from visual first-person recordings of random movement similar to place cells in rodents, or head-direction cells in primates (Franzius et al. (2007)). ",
+        "bbox": [
+            174,
+            488,
+            825,
+            573
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The notion of extracting slow features from a time-series dataset has been formalized as a sequential optimization problem. Given a time-series $\\{ x _ { t } \\} _ { t = 0 \\ldots \\tau }$ with $\\boldsymbol { x } _ { t } \\in \\mathbb { R } ^ { d }$ , sequentially find continuous functions $g _ { i } : \\dot { \\mathbb { R } ^ { d } }  \\mathbb { R }$ with: ",
+        "bbox": [
+            176,
+            579,
+            821,
+            621
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/259298dfdfdacd788288edb11ebcdedff11398cf879c032ef262a9cdf37f1657.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\underset { g _ { i } } { \\operatorname* { m i n } } } & { \\left. ( g _ { i } ( x _ { t + 1 } ) - g _ { i } ( x _ { t } ) ) ^ { 2 } \\right. _ { t } } \\\\ { \\mathrm { s . t . } } & { \\left. g _ { i } ( x _ { t } ) \\right. _ { t } = 0 , } \\\\ & { \\left. g _ { i } ( x _ { t } ) ^ { 2 } \\right. _ { t } = 1 , } \\\\ & { \\left. g _ { i } ( x _ { t } ) g _ { j } ( x _ { t } ) \\right. _ { t } = 0 , \\forall j < i } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            641,
+            622,
+            734
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\langle \\cdot \\rangle _ { t }$ is the time-average. The constraints ensure that each of the extracted features is informative (decorrelated to all others, equation (1d)) and non-trivial (unit variance, equation (1c)). Originally, solutions to SFA directly were only proposed for the space of affine functions $g _ { i } \\in \\mathcal G$ , for which a closed-form solution exists, and in a kernelized version that requires strong regularization. ",
+        "bbox": [
+            174,
+            761,
+            825,
+            818
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 (APPROXIMATE) WHITENING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            837,
+            449,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The standard implementation of linear SFA (Zito et al. (2008)) is based on computing the closedform solution to a generalized eigenvalue problem (Berkes & Wiskott (2005)). Another approach is to first whiten the time-series data, followed by a projection onto the minor components of the difference time-series {x˙ t = xt+1 − xt}t=0...τ−1. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Whitened data has three important properties: (a) it is mean-free (constraint (1b)), (b) has unit variance if projected onto an arbitrary unit vector (constraint (1c)), and (c) projections onto orthonormal vectors are decorrelated (constraint (1d)). ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For a dataset $\\tilde { \\mathbf { X } } \\in \\mathbb { R } ^ { d \\times N }$ with $N$ and $d$ being size and dimension of the dataset, respectively, the corresponding whitened dataset is defined as ",
+        "bbox": [
+            171,
+            154,
+            825,
+            181
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6e0ccfee919bf63cc618ca9afecc62816faa12e30458f9a52f1159912b6a6984.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { X } = \\mathbf { W } \\tilde { \\mathbf { X } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            460,
+            188,
+            537,
+            205
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "with $\\mathbf { W } = \\mathbf { D } ^ { - \\frac { 1 } { 2 } } \\mathbf { U } ^ { T }$ and $\\mathbf { C } = { \\mathbf { U } } { \\mathbf { D } } { \\mathbf { U } } ^ { T } \\in \\mathbb { R } ^ { d \\times d }$ being the whitening matrix and the canonical eigendecomposition of the covariance matrix, respectively. U’s columns contain the eigenvectors of $\\mathbf { C }$ and $\\mathbf { D }$ contains the corresponding eigenvalues on its diagonal. As $\\mathbf { C }$ is typically assumed to be positive definite, $\\mathbf { D } ^ { - \\frac { 1 } { 2 } }$ is well-defined. ",
+        "bbox": [
+            174,
+            209,
+            825,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One widely used method to extract eigenvector/-value pairs is power iteration. Starting from a random vector $u _ { 0 } \\in _ { R } \\mathbb { R } ^ { d }$ , repeatedly applying: ",
+        "bbox": [
+            173,
+            276,
+            823,
+            306
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/72442641f9930e11f578b7b62e03de80ab86148bf11c61c012dccb2a5688a69f.jpg",
+        "text": "$$\nu _ { i + 1 } = \\frac { \\mathbf { C } \\mathbf { u } _ { i } } { \\| \\mathbf { C } \\mathbf { u } _ { i } \\| }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            310,
+            552,
+            344
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "converges to the eigenvector $u$ corresponding to the largest (absolute) eigenvalue $\\lambda$ . The eigenvalue can then be extracted as ",
+        "bbox": [
+            173,
+            348,
+            825,
+            376
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/62c624e872d3bf994326632d99c1aa836ff3235ff686ccd317b57af949854fb3.jpg",
+        "text": "$$\n\\lambda = \\| \\mathbf C \\mathbf u \\|\n$$",
+        "text_format": "latex",
+        "bbox": [
+            460,
+            375,
+            535,
+            392
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and the spectral component corresponding to this eigenvector can be removed as ",
+        "bbox": [
+            171,
+            401,
+            700,
+            416
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7835be8de2ebd991c2f0fea6c0792a0b8b0725fd1b64d281b86c70fe5ec922c9.jpg",
+        "text": "$$\n\\mathbf { C } \\gets \\mathbf { C } - \\lambda \\mathbf { u } \\mathbf { u } ^ { T } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            437,
+            421,
+            560,
+            439
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Repeating the procedure converges to the eigenvector corresponding to the next largest eigenvalue and so on. We use a previously fixed number of iterations for this method as experiments have shown that approximate whitening is enough to take meaningful optimization steps. In practice, a relatively small number of iterations results in acceptable whitening for most non-degenerate cases. ",
+        "bbox": [
+            173,
+            445,
+            826,
+            502
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Data: covariance matrix $\\mathbf { C }$ , number of iterations $N _ { \\mathrm { i t e r } }$ , data dimension $d$   \nResult: whitening matrix W   \n$\\mathbf { W } \\gets \\{ 0 \\} ^ { d \\times d }$   \nfor $i = 0 ; i < d ; i + + { \\bf d o }$ Sample $\\mathbf { r } \\sim U [ - 1 , 1 ] ^ { d }$ for $j = 0 ; j < N _ { i t e r } ; j + + { \\bf d o }$ r ← CrkCrk end $\\begin{array} { r l } & { \\lambda  \\Vert \\mathbf { C r } \\Vert } \\\\ & { \\mathbf { C }  \\mathbf { C } - \\lambda \\mathbf { r r } ^ { T } } \\\\ & { \\mathbf { w } _ { i \\cdot } = \\frac { 1 } { \\sqrt { \\lambda } } \\mathbf { r } ^ { T } } \\end{array}$   \nend   \nreturn W Algorithm 1: Constructing W by power iteration ",
+        "bbox": [
+            178,
+            530,
+            665,
+            741
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that in algorithm 1 each operation is differentiable with respect to C. ",
+        "bbox": [
+            174,
+            751,
+            661,
+            767
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5 GRADIENT-BASED SLOW FEATURE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            785,
+            586,
+            803
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The key idea for gradient-based SFA is that a whitening layer can be applied to any differentiable architecture (such as deep neural networks) to enforce outputs that approximately obey the SFA constraints while the architecture stays differentiable. As such, it can be trained using gradientdescent-like training procedures, allowing for hierarchical architectures, where every parameter is modified iteratively towards optimizing a global slowness objective, as opposed to assuming a localto-global slowness as in HSFA. To formalize, if ",
+        "bbox": [
+            173,
+            816,
+            826,
+            901
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f44a5a3ebdf9699d6e8848e57791e95d7280276667888197c431549da27d3ae8.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\tilde { g } _ { \\theta } : \\ } & { { } \\mathbb { R } ^ { N \\times d }  \\mathbb { R } ^ { N \\times e } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            906,
+            576,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "is a differentiable function approximator, such as a neural network, parameterized by $\\theta$ and ",
+        "bbox": [
+            168,
+            103,
+            769,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f9fdd1fcd85c9e6cb9a29dbf5fd7bdbe3a05218021da1828c0309255c483ef49.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\mathcal { W } : } & { { } \\mathbb { R } ^ { N \\times e }  \\mathbb { R } ^ { N \\times e } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            123,
+            576,
+            141
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "denotes the approximate whitening procedure, then ",
+        "bbox": [
+            173,
+            148,
+            511,
+            165
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c8be0ae0322cc044463736ea9bfc870dfaa0f5f2f5abb02b62f7abfdf2ebf5b9.jpg",
+        "text": "$$\ng _ { \\theta } = \\mathcal { W } \\circ \\tilde { g } _ { \\theta } : \\quad \\mathbb { R } ^ { N \\times d } \\to \\mathbb { R } ^ { N \\times e }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            170,
+            611,
+            189
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "is an approximator whose outputs approximately obey the SFA constraints. ",
+        "bbox": [
+            174,
+            195,
+            665,
+            210
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It is straightforward to define a general loss function as ",
+        "bbox": [
+            178,
+            217,
+            534,
+            231
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f9b4916a5440232f156946448fb25c3107c60f733d69d3a122aa8381a0922b59.jpg",
+        "text": "$$\nL _ { \\theta } ( { \\bf X } ) = \\frac { 1 } { N } \\sum _ { i } \\sum _ { j } w _ { i j } \\| g _ { i } - g _ { j } \\| ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            237,
+            619,
+            276
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "with $g _ { i }$ being the $i$ -th row of $g _ { \\boldsymbol { \\theta } } ( \\mathbf { X } )$ and $w _ { i j }$ being the strength of the connection between two points $x _ { i }$ and $x _ { j }$ similar to weights in spectral graph embeddings (cf. Sprekeler (2011) and Escalante-B. & Wiskott (2013)). ",
+        "bbox": [
+            174,
+            281,
+            825,
+            325
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For optimizing slowness, we define the weight as ",
+        "bbox": [
+            173,
+            332,
+            498,
+            347
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/71508bb82487e6c1f4938f9af995d1a333a2cb2dc2ac60446fb48be6766e52a6.jpg",
+        "text": "$$\nw _ { i j } = \\delta _ { i , j + 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            455,
+            353,
+            542,
+            369
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "with $\\delta$ being the Kronecker delta. This connects consecutive steps in the time-series and disconnects the others 1. ",
+        "bbox": [
+            171,
+            376,
+            825,
+            404
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The approximator can then be trained to minimize eq. 2 by following the negative gradient estimate of $L$ with respect to $\\theta$ , $- \\nabla _ { \\theta } L$ for (mini-)batches of data, as common in a common in gradientbased training. In our experiments, we used the ADAM optimizer (Kingma & Ba (2014)) with Nesterov-accelerated momentum (Dozat (2015)) to train the approximator. Learning rate and additional hyperparameters were left at default values as implemented in the popular Keras-package (Chollet et al. (2015)). ",
+        "bbox": [
+            173,
+            410,
+            825,
+            494
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            515,
+            326,
+            531
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "6.1 SYNTHETIC TRIGONOMETRIC DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            546,
+            464,
+            560
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To show the general feasibility of this approach, we first show that PowerSFA finds near-optimal solutions in the linear case for synthetic data. Standard SFA is a linear method that relies on (a) non-linear basis function expansion and $\\mathbf { ( b ) }$ hierarchical processing to induce non-linearity. This means that PowerSFA could hypothetically be used a similar fashion (even though a gradient-based approach allows for more complex models in a natural way). ",
+        "bbox": [
+            174,
+            571,
+            825,
+            642
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The data is generated by trigonometric polynomials of degree $N$ as: ",
+        "bbox": [
+            173,
+            648,
+            620,
+            664
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b83c5a2915221f21d174efebbf446f5d3d16e16f4cb83f741529a390b1f5a7ef.jpg",
+        "text": "$$\n\\mathbf { x } ( t ) = \\varepsilon _ { t } + \\sum _ { n = 1 } ^ { N } \\alpha _ { n } \\cos \\left( n t \\right) + \\beta _ { n } \\sin \\left( n t \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            670,
+            643,
+            713
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "with $\\mathbf { x } , \\pmb { \\varepsilon } , \\pmb { \\alpha } , \\pmb { \\beta } \\in \\mathbb { R } ^ { D }$ , coefficients $\\alpha _ { i n } , \\beta _ { i n } \\sim \\mathcal { N } ( 0 , 1 )$ . A noise term $\\varepsilon _ { i t } \\sim \\mathcal { N } ( 0 , 0 . 0 1 )$ is added to avoid numerical instabilities in the implementation of closed-form SFA, as singular covariance matrices can cause the underlying eigendecomposition to break. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "emented a temand dimension -size of . The da $\\frac { 2 \\pi } { 1 0 0 }$ , and generate s whitened wit $T = 5 0 0 0$ teps with maximum degree. $N = 3 0$ $D = 1 0 0$ $N _ { \\mathrm { i t e r } } = 6 0$ ",
+        "bbox": [
+            174,
+            768,
+            821,
+            799
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 shows the extracted features for different variants of SFA. If the slowness loss is optimized without any constraints on the output features, the optimal solution is to collapse all signals to a constant $\\Delta = 0 ,$ ), while if unit variance is enforced, only the features with slowness very close to the smallest $\\Delta$ are extracted multiple times and thus the representation becomes highly redundant. When using the approximate whitening, the quality of the solutions is comparable to the closed form solution gained by solving a generalized eigenvalue problem. The ordering was achieved for representational purposes by weighting the output features with a monotonically decreasing weight. In Figure 2, the covariance matrices of the extracted signals are visualized. ",
+        "bbox": [
+            173,
+            804,
+            825,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/9f2661dd1afe4966f7dc640ab9badb69420052b00e0a570dfc7c2f83a480bbe1.jpg",
+        "image_caption": [
+            "Figure 1: First five features (100 steps) learned by a linear model in different settings. From left to right: (1) only slowness loss optimized, no constraints, (2) slowness loss with enforced unit variance, (3) slowness loss with enforced whitening, (4) closed form solution. The $\\Delta$ -values indicate slowness (lower is slower). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            103,
+            720,
+            366
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/30be3dcafc3e6ab5c7cc36305fa480eec5326c24dd14654683d8ecf9154f981b.jpg",
+        "image_caption": [
+            "Figure 2: Covariance matrices for five outputs in different settings. (1) slowness loss without constraints leads to nearly constant signals with (co)variances close to zero, (2) unit variance enforced leads to highly correlated output signals, (3) & (4) (approximate) whitening and the closed form solution show fully decorrelated output signals (identity covariance). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            282,
+            457,
+            720,
+            585
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            689,
+            821,
+            732
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that it is not a sensible approach to use PowerSFA to optimize a linear model for such lowdimensional data as the closed-form solution is easily attainable. For this reason, this experiment should be understood as a proof-of-concept and a general demonstration of applicability rather than a recommendation for a use-case. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            795
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A very low number of iterations will render the optimization unstable resulting in fast output signals. There seems to be no continuous trade-off between correlation and slowness mediated by the number of iterations. Thus, it is recommended to find a setting for $N _ { \\mathrm { i t e r } }$ that allows for stable optimization. Appendix A contains a small hyper-parameter study, illustrating that behavior for the linear case. ",
+        "bbox": [
+            174,
+            801,
+            825,
+            858
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To provide evidence on how gradient-based SFA can improve on solutions found by closed-form SFA, we encapsulate the original signal in a non-linear distortion: ",
+        "bbox": [
+            171,
+            864,
+            823,
+            893
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f411183438629c7bd75d6a70cd942c309eb2602f0f7fef8ee94ed449904d9c5d.jpg",
+        "text": "$$\n\\mathbf { u } ( t ) = \\cos ( e ^ { \\mathbf { x } ( t ) } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            439,
+            905,
+            558,
+            925
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This makes it impossible to extract slow signals by linearly unmixing the original components. To make the extraction more difficult, the maximum degree was increased to $N = 3 0 0$ and the temporal step-size was decreased to $\\frac { 2 \\pi } { 1 0 ^ { 5 } }$ to reduce temporal aliasing of very fast input components. Consequently, we increased $T$ to $1 0 ^ { 5 }$ and $N _ { \\mathrm { i t e r } }$ to 100. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            161
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "When applying closed-form SFA to non-linear problems, it is common to apply multiple low-degree polynomial expansions interlaced with linear SFA steps, to reduce the dimensionality, in a greedy layer-wise training. We use an architecture with three quadratic expansion layers (normalized to unit norm to avoid exploding gradients), and compare (a) closed-form training and (b) gradientbased training. We repeat the comparison for a multi-layer perceptron with tanh activation, since polynomial expansion functions are uncommon in gradient-trained models. Both architectures are provided in Appendix B. Table 1 shows the average output slowness, once for the raw output from the network (with small residue correlations possible due to whitening approximation error) and once with closed-form whitening applied to precisely enforce the constraints for the most meaningful comparison. ",
+        "bbox": [
+            173,
+            167,
+            825,
+            308
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/00da07fbf23099b91c8c4299e02d26249a709e04975b8d3870abb4f9e2778991.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Quadratic expansion</td><td rowspan=1 colspan=1>Closed-form</td><td rowspan=1 colspan=1>Gradient-based</td></tr><tr><td rowspan=1 colspan=1>Slowness</td><td rowspan=1 colspan=1>3.435:10-1 ±3.54:10-3</td><td rowspan=1 colspan=1>9.744·10-2 ± 1.67:10-2</td></tr><tr><td rowspan=1 colspan=1>Slowness (additional whitening)</td><td rowspan=1 colspan=1>3.435:10-1 ±3.54:10-3</td><td rowspan=1 colspan=1>9.743·10-2 ± 1.67: 10-2</td></tr></table>",
+        "bbox": [
+            181,
+            323,
+            818,
+            372
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/fd89d72fd068cc5d3d83e18baf620eacdf5150340931fe1ccefdd33d3f18ddf8.jpg",
+        "table_caption": [
+            "Table 1: Average slowness of 5 output features over 5 runs extracted by greedy layer-wise training and gradient-based training from non-linearly distorted trigonometric polynomials. Results for three-layer quadratic expansion network and neural network with tanh activation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Neural network (tanh)</td><td rowspan=1 colspan=1>Closed-form</td><td rowspan=1 colspan=1>Gradient-based</td></tr><tr><td rowspan=1 colspan=1>Slowness</td><td rowspan=1 colspan=1>8.562:10-1 ±6.79:10-3</td><td rowspan=1 colspan=1>2.755·10-1 ±9.891·10-2</td></tr><tr><td rowspan=1 colspan=1>Slowness (additional whitening)</td><td rowspan=1 colspan=1>8.562:10-1 ±6.79:10-3</td><td rowspan=1 colspan=1>2.755·10-1 ±9.891·10-2</td></tr></table>",
+        "bbox": [
+            179,
+            392,
+            818,
+            441
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results show that gradient-based training can improve slowness in multi-layer architectures compared to greedy layer-wise SFA. Note that increasing the output dimension of the dimensionality reduction steps (or dropping them altogether) in the quadratic expansion network will, unsurprisingly, lead to improved performance and ultimately to convergence to similar minima in both networks. However, this performance increase comes at the cost of high memory requirements and is usually not applicable in high-dimensional non-synthetic problems. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            595
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.2 POSE ESTIMATION FROM VISUAL DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            616,
+            488,
+            631
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/fa09e067b5a17e430324090ac424a299817b4cb8f9b1e53c25be49193321a7c2.jpg",
+        "image_caption": [
+            "Figure 3: Three samples from the anvil-dataset in different $x , y$ positions and rotational angle $\\Phi$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            648,
+            790,
+            780
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "SFA can be used to extract slowly varying underlying causes from high-dimensional data, such as object position, identity, and rotation from visual simulations. In Franzius et al. (2011), textured three-dimensional fish-objects that change in $x$ - and $y$ -position as well as in-depth rotation $\\phi$ have been used and it has been shown that HSFA features encode position and angle well. Since the code used to generate the stimulus data was outdated and could not be executed anymore, we reimplemented a similar scenario with a 3D model of an anvil (Figure 3, Pino4et (2016)) using the random walk procedure described in Franzius et al. (2011) to generate the configurations. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c40a1421e2f49e02d53f211f91ae113888e6e307334294f5e48a8d7d9849ed25.jpg",
+        "image_caption": [
+            "Figure 4: Spread of the predicted $x$ - and $y$ -position of the anvil-dataset for a trained network (4a) and a randomly initialized network (4b). RMSE for the trained network on unseen data are $9 \\%$ and $8 \\%$ for $x \\cdot$ - and $y$ - position respectively. RMSE for the random network on unseen data are $2 1 \\%$ and $2 1 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            102,
+            787,
+            273
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A current limitation of our model (cf. section 7) is that it does not scale well in the number of output features, rendering the relatively high number of 512 output features used by Franzius et al. (2011) infeasible. We used an output dimension of 10 with a comparable architecture that replaces quadratic expansion by ELU-nonlinearities (a Keras-summary is given in Appendix C). Due to the low number of output features, we were not able to successfully extract the rotational angle $\\Phi$ . ",
+        "bbox": [
+            174,
+            371,
+            825,
+            440
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In line with the original publication, we computed linear regression to predict $c o s ( \\pi x )$ and $c o s ( \\pi y )$ and used the inverse transformation to extract the object position. The results are shown in Figure 4 and are comparable to those presented by Franzius et al. (2011) as they were able to achieve a RMSE of $9 \\%$ for $x$ -position and $7 \\%$ for $y$ -position. ",
+        "bbox": [
+            173,
+            448,
+            825,
+            505
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.3 NORB ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            522,
+            263,
+            536
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While gradient-based SFA is the main contribution of this work, previous work on generalizing SFA (Sprekeler (2011)) has shown that the SFA optimization problem is strongly related to a special case of the problem solved by a more general spectral embedding method, i.e., Laplacian Eigenmaps (Belkin & Niyogi (2003)), or, with small differences, graph-based SFA (Escalante-B. & Wiskott (2013)). For this reason, we defined a more general loss function in equation 2. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            619
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0ad6898c7bb85f39d6a06c714e07964d99b7cd068df375f094560633db02485b.jpg",
+        "image_caption": [
+            "Figure 5: The embedded object from the NORB dataset. Samples differ in azimuth, elevation and lighting. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            633,
+            774,
+            763
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In fact, weights $w _ { i j }$ can be defined between any two points $x _ { i }$ and $x _ { j }$ of a given dataset, not just consecutive ones, thus allowing to optimize neighborhood-respecting embeddings for general graphs. This is similar (but not fully equivalent) to spectral embeddings on graph data, as used in algorithms such as Laplacian eigenmaps. Our approach exhibits four significant differences: ",
+        "bbox": [
+            176,
+            820,
+            823,
+            877
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "1. It does not find ordered features, but a rotation of an optimal embedding,   \n2. the found solution should be assumed to be only locally optimal (or a saddle point), ",
+        "bbox": [
+            210,
+            888,
+            781,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3. it does ignore the graph (ir)regularity when enforcing the orthogonality constraint, and ",
+        "bbox": [
+            205,
+            103,
+            799,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4. it allows a natural and scalable way to embed unseen points. ",
+        "bbox": [
+            212,
+            133,
+            627,
+            148
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Computing an out-of-sample embedding requires the same forward-pass through the differentiable architecture as the training embeddings. In particular, its complexity does not scale with the number of observed points used for training as is usually the case in other approximations, such as Nyström approximation (Williams & Seeger (2001)). ",
+        "bbox": [
+            174,
+            165,
+            825,
+            222
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate the usefulness of such an approach by embedding an object of the NORB dataset, a collection of photographs of toys taken at different elevations, azimuths, and under different lighting conditions with the MobileNet architecture (Sandler et al. (2018)) scaled with $\\alpha = 0 . 5$ and a depth multiplier of 2 in the Keras implementation. Following Hadsell et al. (2006), we embedded photographs of a toy plane (Figure 5) in 972 configurations (18 azimuths $\\times ~ 6$ lighting conditions $\\times ~ 9$ elevations angles) that were randomly split into a train- and test-set of sizes 660 and 312 respectively and the connection weights $w _ { i j }$ were chosen as 1 if $x _ { i }$ and $x _ { j }$ differed only in one step either in rotation (i.e., one azimuth) or elevation (i.e., one level) and 0 otherwise. The weights were independent of lighting condition. ",
+        "bbox": [
+            173,
+            228,
+            825,
+            354
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/02e852d3071d26f8c1d6cbc54992611d6e89af767c6a4ea5e80c600876107f49.jpg",
+        "image_caption": [
+            "Figure 6: Cylindrical embedding of NORB plane with azimuth colored. 6a and 6b show the embedded training data from the front and the side of the cylinder respectively, while 6c and 6d show the test data for the same configuration. Circumference of the cylinder encodes the rotation of the plane. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            380,
+            784,
+            507
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/06ae454a58f922984f33d82e1e529b70b8004286f14ed3968b209de6bbf65c55.jpg",
+        "image_caption": [
+            "Figure 7: Cylindrical embedding of NORB plane with elevation colored. 7a and 7b show the embedded training data from the front and the side of the cylinder respectively, while 7c and 7d show the test data for the same configuration. Height on the cylinder encodes the photograph’s elevation angle. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            604,
+            784,
+            733
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figures 6 and 7 show the three-dimensional embedding that was found in this setting. The data was embedded in a cylindrical shape in which the circumference encodes the rotation angle of the embedded object, and the length along the cylinder encodes the elevation configuration of the object for the train-set and in the out-of-sample case of the test-set. Hadsell et al. (2006) found a similar cylindrical encoding, however, their results exhibit a more clean-cut embedding. We assume that this is due to DrLIM’s maximization of distance for dissimilar samples that our model does not implement. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            310,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We propose a new way of extracting informative slow features from quickly varying inputs based on differentiable whitening of processed batches of the input data. To experimentally show the feasibility of the method, we trained a linear and two non-linear models to extract slowly varying output signals from synthetic time-series by gradient-descent, and find that the differentiable whitening ensures informativeness of the extracted features when optimizing a slowness loss function. Furthermore, the features corresponded to those found by closed-form SFA. 2 ",
+        "bbox": [
+            174,
+            133,
+            823,
+            217
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To show applicability to visual time-series data, we trained a convolutional neural network on an input stream of an object randomly rotating in-depth and moving in a 2-dimensional plane. Gradientbased SFA preserves the position of the object in a low-dimensional representation, as does a hierarchical version of closed-form SFA. The rotation was not extracted successfully due to computational constraints in the naive implementation for a large number of output features (cf. 7). ",
+        "bbox": [
+            174,
+            223,
+            825,
+            294
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "One experiment was conducted on a non-time-series image dataset on which symmetric similarity relations between the data are defined. We show that a generalization of gradient-based SFA in the spirit of graph-based SFA is able to extract a low-dimensional representation that preserves and disentangles the configuration parameters used to define the similarity, in this case, azimuth and elevation of a photographed toy. This representation generalizes well to previously unseen configurations of the object. ",
+        "bbox": [
+            174,
+            301,
+            825,
+            385
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "While the algorithm is still in a prototypical state, the proof-of-concept results presented in this paper show promise for gradient-based SFA by differentiable whitening to extract meaningful representations for goal-oriented learning while leveraging the expressive power of modern architectures, such as convolutional neural networks. In particular, differentiable whitening ensures non-redundancy of the output features. ",
+        "bbox": [
+            174,
+            391,
+            825,
+            462
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "More research has to be dedicated to explore the computational limitations of this method and possibly lower the complexity for a larger number of output features. Furthermore, closed-form SFA has a strong theoretical framework describing the optimal responses in an idealized setting. At this point, we are unclear how well this framework translates to the proposed method of slowness extraction as the used models typically suffer from local optima when being iteratively trained. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            537
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "One limitation of PowerSFA is that it currently does not scale favorably in the number of output features $e$ . We see two main reasons for this: the necessary batch size to get a meaningful estimate of the batch-covariance estimate and its calculation. The latter is due to the complexity of a naive $\\mathbb { R } ^ { e \\times N _ { \\mathrm { b a t c h } } }$ · $\\mathbb { R } ^ { N _ { \\mathrm { b a t c h } } \\times e }$ matrix-multiplication being $\\mathcal { O } ( N _ { \\mathrm { b a t c h } } e ^ { 2 } )$ , while the former is due to the whitening procedure expecting a covariance matrix of full rank and thus $N _ { \\mathrm { b a t c h } } \\ge e$ samples. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            616
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To reduce the lower bound on the batch-size at batch $t$ , a convex mixture with the covariance matrix of the previous batch might be applicable: ",
+        "bbox": [
+            174,
+            621,
+            821,
+            650
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d5e7d62d06abb81e6aac5116a31727216f6aaeb7ca3b1b56c8f00fcffc84de03.jpg",
+        "text": "$$\n\\mathbf { C } _ { t } = ( 1 - \\gamma ) \\mathbf { C } _ { \\theta } + \\gamma \\mathbf { C } _ { t - 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            656,
+            589,
+            674
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Note, that only the current batch’s covariance matrix $\\mathbf { C } _ { \\theta }$ is considered parameter-dependent and allows to propagate a gradient for training. Thus, large values for $\\gamma$ might cause a significant bias in the gradient-estimate. This has not been used to generate the proof-of-concept results for this paper. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            723
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            743,
+            287,
+            758
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mikhail Belkin and Partha Niyogi. Laplacian eigenmaps for dimensionality reduction and data representation. Neural Comput., 15(6):1373–1396, June 2003. ISSN 0899-7667. doi: 10.1162/ 089976603321780317. ",
+        "bbox": [
+            174,
+            767,
+            823,
+            809
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio and James S. Bergstra. Slow, decorrelated features for pretraining complex celllike networks. In Y. Bengio, D. Schuurmans, J. D. Lafferty, C. K. I. Williams, and A. Culotta (eds.), Advances in Neural Information Processing Systems 22, pp. 99–107. Curran Associates, Inc., 2009. ",
+        "bbox": [
+            176,
+            819,
+            825,
+            875
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. IEEE transactions on pattern analysis and machine intelligence, 35(8):1798–1828, 2013. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pietro Berkes and Laurenz Wiskott. Slow feature analysis yields a rich repertoire of complex cell properties. Journal of Vision, 5(6), 2005. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            185
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "H. Bourlard and Y. Kamp. Auto-association by multilayer perceptrons and singular value decomposition. Biological Cybernetics, 59(4):291–294, Sep 1988. ISSN 1432-0770. doi: 10.1007/BF00332918. ",
+        "bbox": [
+            173,
+            194,
+            825,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jane Bromley, Isabelle Guyon, Yann LeCun, Eduard Säckinger, and Roopak Shah. Signature verification using a \"siamese\" time delay neural network. In Proceedings of the 6th International Conference on Neural Information Processing Systems, NIPS’93, pp. 737–744, San Francisco, CA, USA, 1993. Morgan Kaufmann Publishers Inc. ",
+        "bbox": [
+            173,
+            246,
+            825,
+            303
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Francois Chollet. Xception: Deep learning with depthwise separable convolutions. CoRR, abs/1610.02357, 2016. ",
+        "bbox": [
+            173,
+            313,
+            821,
+            342
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Francois Chollet et al. Keras. https://github.com/fchollet/keras, 2015. ",
+        "bbox": [
+            173,
+            351,
+            629,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pierre Comon. Independent component analysis, a new concept? Signal Processing, 36(3):287 – 314, 1994. ISSN 0165-1684. doi: https://doi.org/10.1016/0165-1684(94)90029-9. Higher Order Statistics. ",
+        "bbox": [
+            176,
+            376,
+            823,
+            417
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Timothy Dozat. Incorporating nesterov momentum into adam. http://cs229.stanford.edu/proj2015/054_report.pdf, 2015. ",
+        "bbox": [
+            173,
+            428,
+            821,
+            457
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alberto N. Escalante-B. Extensions of Hierarchical Slow Feature Analysis for Efficient Classification and Regression on High-Dimensional Data. PhD thesis, Ruhr-University Bochum, 2017. ",
+        "bbox": [
+            173,
+            465,
+            823,
+            496
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alberto N. Escalante-B. and Laurenz Wiskott. How to solve classification and regression problems on high-dimensional data with a supervised extension of slow feature analysis. J. Mach. Learn. Res., 14(1):3683–3719, December 2013. ISSN 1532-4435. ",
+        "bbox": [
+            176,
+            505,
+            823,
+            547
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alberto N. Escalante-B. and Laurenz Wiskott. Improved graph-based SFA: information preservation complements the slowness principle. CoRR, abs/1601.03945, 2016. ",
+        "bbox": [
+            173,
+            556,
+            823,
+            585
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mathias Franzius, Henning Sprekeler, and Laurenz Wiskott. Slowness and sparseness lead to place, head-direction, and spatial-view cells. PLOS Computational Biology, 3(8):1–18, 08 2007. doi: 10.1371/journal.pcbi.0030166. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            637
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mathias Franzius, Niko Wilbert, and Laurenz Wiskott. Invariant object recognition and pose estimation with slow feature analysis. Neural Computation, 23(9):2289–2323, 2011. doi: 10.1162/NECO\\_a\\_00171. PMID: 21671784. ",
+        "bbox": [
+            173,
+            647,
+            825,
+            690
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Z. Ghahramani, M. Welling, C. Cortes, N. D. Lawrence, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 27, pp. 2672–2680. Curran Associates, Inc., 2014. ",
+        "bbox": [
+            173,
+            699,
+            825,
+            757
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016. http://www.deeplearningbook.org. ",
+        "bbox": [
+            166,
+            765,
+            823,
+            795
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ross Goroshin, Joan Bruna, Jonathan Tompson, David Eigen, and Yann LeCun. Unsupervised feature learning from temporal data. arXiv preprint arXiv:1504.02518, 2015a. ",
+        "bbox": [
+            171,
+            804,
+            823,
+            834
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ross Goroshin, Michael F Mathieu, and Yann LeCun. Learning to linearize under uncertainty. In Advances in Neural Information Processing Systems, pp. 1234–1242, 2015b. ",
+        "bbox": [
+            171,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Raia Hadsell, Sumit Chopra, and Yann Lecun. Dimensionality reduction by learning an invariant mapping. In In Proc. Computer Vision and Pattern Recognition Conference (CVPR’06. IEEE Press, 2006. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aren Jansen, Manoj Plakal, Ratheet Pandya, Daniel PW Ellis, Shawn Hershey, Jiayang Liu, R Channing Moore, and Rif A Saurous. Unsupervised learning of semantic audio representations. arXiv preprint arXiv:1711.02209, 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dinesh Jayaraman and Kristen Grauman. Slow and steady feature analysis: higher order temporal coherence in video. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3852–3861, 2016. ",
+        "bbox": [
+            176,
+            155,
+            821,
+            198
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D. P Kingma and M. Welling. Auto-Encoding Variational Bayes. ArXiv e-prints, December 2013. ",
+        "bbox": [
+            171,
+            205,
+            813,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014. ",
+        "bbox": [
+            173,
+            231,
+            823,
+            258
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Fu Jie Huang, and Léon Bottou. Learning methods for generic object recognition with invariance to pose and lighting. In Proceedings of the 2004 IEEE Computer Society Conference on Computer Vision and Pattern Recognition, CVPR’04, pp. 97–104, Washington, DC, USA, 2004. IEEE Computer Society. ",
+        "bbox": [
+            174,
+            268,
+            826,
+            324
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hossein Mobahi, Ronan Collobert, and Jason Weston. Deep learning from temporal coherence in video. In Proceedings of the 26th Annual International Conference on Machine Learning, pp. 737–744. ACM, 2009. ",
+        "bbox": [
+            173,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D. Pfau, S. Petersen, A. Agarwal, D. Barrett, and K. Stachenfeld. Spectral Inference Networks: Unifying Spectral Methods With Deep Learning. ArXiv e-prints, June 2018. ",
+        "bbox": [
+            173,
+            385,
+            823,
+            414
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pino4et. Anvil lowpoly. https://www.turbosquid.com/FullPreview/Index.cfm/ID/1067450, 2016. [Online, Royalty Free 3D Object]. ",
+        "bbox": [
+            174,
+            422,
+            823,
+            452
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "M. Raghu, B. Poole, J. Kleinberg, S. Ganguli, and J. Sohl-Dickstein. On the Expressive Power of Deep Neural Networks. ArXiv e-prints, June 2016. ",
+        "bbox": [
+            174,
+            460,
+            823,
+            489
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sam T. Roweis and Lawrence K. Saul. Nonlinear dimensionality reduction by locally linear embedding. SCIENCE, 290:2323–2326, 2000. ",
+        "bbox": [
+            173,
+            497,
+            823,
+            526
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mark Sandler, Andrew G. Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Inverted residuals and linear bottlenecks: Mobile networks for classification, detection and segmentation. CoRR, abs/1801.04381, 2018. ",
+        "bbox": [
+            173,
+            535,
+            825,
+            579
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Uri Shaham, Kelly Stanton, Henry Li, Ronen Basri, Boaz Nadler, and Yuval Kluger. Spectralnet: Spectral clustering using deep neural networks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } }$ HJ_aoCyRZ. ",
+        "bbox": [
+            174,
+            588,
+            823,
+            631
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Henning Sprekeler. On the Relation of Slow Feature Analysis and Laplacian Eigenmaps. Neural Computation, 23(12):3287–3302, December 2011. ISSN 0899-7667. doi: 10.1162/neco\\_a\\ _00214. ",
+        "bbox": [
+            173,
+            638,
+            825,
+            681
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard S. Sutton and Andrew Barto. Reinforcement Learning: An Introduction. MIT Press, 1998. ",
+        "bbox": [
+            169,
+            690,
+            823,
+            707
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2794–2802, 2015. ",
+        "bbox": [
+            171,
+            714,
+            821,
+            744
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christopher K. I. Williams and Matthias Seeger. Using the Nyström method to speed up kernel machines. In T. K. Leen, T. G. Dietterich, and V. Tresp (eds.), Advances in Neural Information Processing Systems 13, pp. 682–688. MIT Press, 2001. ",
+        "bbox": [
+            174,
+            752,
+            823,
+            795
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Laurenz Wiskott and Terrence Sejnowski. Slow feature analysis: unsupervised learning of invariances. Neural Computation, 14(4):715–770, 2002. doi: http://doi.org/10.1162/ 089976602317318938. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "T. Zito, N. Wilbert, L. Wiskott, and P. Berkes. Modular toolkit for data processing (mdp): a python data processing framework. Frontiers in Neuroinformatics, 2:8, 2008. doi: 10.3389/neuro.11. 008.2008. ",
+        "bbox": [
+            176,
+            856,
+            825,
+            897
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Appendices ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            343,
+            127
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/5d1d7731e9cc6bf8ac7c8f7e86d1b0365d359caf8b11e5f94980192d3aeaf3dc.jpg",
+        "image_caption": [
+            "Figure 8: The mean squared velocity (unnormalized $\\Delta$ value) per feature for an increasing number of power iterations, averaged over 10 trials. For no power iterations, the velocity is close to 0, but for a too small positive number of power iterations the optimization becomes unstable and results in sub-optimal performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            279,
+            193,
+            715,
+            440
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/33607e4352d46a86e29f2857a79825b015d9d8abcb85ea3fe150cadd9ed10d11.jpg",
+        "image_caption": [
+            "Figure 9: The average covariance (auto-variances not included) for an increasing number of power iterations, averaged over 10 trials. Without whitening, the covariance is close to 1, but the features quickly become decorrelated when the number of iterations is increased. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            281,
+            546,
+            715,
+            794
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B COMPARISON ARCHITECTURES (SYNTHETIC DATA) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            632,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "This appendix presents the architectures used for comparing greedy layer-wise with gradient-based end-to-end training of SFA. Both networks have been trained with both training methods. In the gradient-based setting, the Keras’s Nadam optimizer has been used with default hyperparameters and a whitening layer has been applied to the network output. ",
+        "bbox": [
+            174,
+            133,
+            826,
+            190
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/16e1e0b22506669c6e09888d111e3e9afa06464bd29155d41f54d58a884f9633.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=2>Quadratic expansion network</td></tr><tr><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>Output dimension</td></tr><tr><td rowspan=1 colspan=1>Input Layer</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>Linear LayerQuadratic Expansion</td><td rowspan=1 colspan=1>33594</td></tr><tr><td rowspan=1 colspan=1>Linear LayerQuadratic Expansion</td><td rowspan=1 colspan=1>33594</td></tr><tr><td rowspan=1 colspan=1>Linear LayerQuadratic Expansion</td><td rowspan=1 colspan=1>33594</td></tr><tr><td rowspan=1 colspan=1>Linear Layer</td><td rowspan=1 colspan=1>5</td></tr></table>",
+        "bbox": [
+            349,
+            203,
+            647,
+            349
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 2: A network with multiple quadratic expansions, each preceded by linear dimensionalityreduction. These kind of networks are typically used in closed-form SFA as they trade-off model expressivity with memory requirements. ",
+        "bbox": [
+            173,
+            359,
+            825,
+            402
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/532e04a70c1e3ae64ee6cf426c6d49c96814e610290538709ebeb323073bcf88.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=2>Neural network(tanh)</td></tr><tr><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>Output dimension</td></tr><tr><td rowspan=1 colspan=1>Input Layer</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>Linear LayerPointwise tanh</td><td rowspan=1 colspan=1>100100</td></tr><tr><td rowspan=1 colspan=1>Linear LayerPointwise tanh</td><td rowspan=1 colspan=1>100100</td></tr><tr><td rowspan=1 colspan=1>Linear LayerPointwise tanh</td><td rowspan=1 colspan=1>100100</td></tr><tr><td rowspan=1 colspan=1>Linear Layer</td><td rowspan=1 colspan=1>5</td></tr></table>",
+        "bbox": [
+            370,
+            424,
+            625,
+            571
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 3: A simple multi-layer neural network using a tanh activation function to induce non-linearity. ",
+        "bbox": [
+            169,
+            582,
+            823,
+            597
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/5777b824fab2522fb30afee542a7745950ec78ffde6d0653c0e0a05c065c7ec1.jpg",
+        "table_caption": [
+            "C KERAS DESCRIPTION (HSFA-LIKE ARCHITECTURE) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer (type)</td><td></td><td>Output Shape</td><td></td><td>Param #</td></tr><tr><td>input_1</td><td>(InputLayer)</td><td>(None, 156，</td><td>156，1)</td><td>0</td></tr><tr><td>conv2d_1</td><td>(Conv2D)</td><td>(None, 147，</td><td>147， 32）</td><td>3232</td></tr><tr><td>activation_1</td><td>(Activation)</td><td>(None， 147，</td><td>147， 32)</td><td>0</td></tr><tr><td>dropout_1</td><td>（Dropout)</td><td>(None， 147，</td><td>147， 32）</td><td>0</td></tr><tr><td>conv2d_2</td><td>(Conv2D)</td><td>(None， 28，</td><td>28， 32）</td><td>102432</td></tr><tr><td>activation_2</td><td>(Activation)</td><td>(None, 28，</td><td>28， 32）</td><td>0</td></tr><tr><td>dropout_2</td><td>(Dropout)</td><td>(None， 28，</td><td>28， 32）</td><td>0</td></tr><tr><td>conv2d_3</td><td>(Conv2D)</td><td>(None， 25，</td><td>25， 32）</td><td>16416</td></tr><tr><td>activation_3</td><td>(Activation)</td><td>(None, 25，</td><td>25， 32）</td><td>0</td></tr><tr><td>dropout_3</td><td>(Dropout)</td><td>(None， 25，</td><td>25， 32）</td><td>0</td></tr><tr><td>conv2d_4 (Conv2D)</td><td></td><td>(None, 11，</td><td>11， 32）</td><td>16416</td></tr><tr><td>activation_4</td><td>(Activation)</td><td>(None， 11，</td><td>11， 32）</td><td>0</td></tr><tr><td>dropout_4 (Dropout)</td><td></td><td>(None，</td><td>11，11， 32）</td><td>0</td></tr><tr><td>conv2d_5</td><td>(Conv2D)</td><td>(None， 8，</td><td>8，32)</td><td>16416</td></tr><tr><td>activation_5</td><td>(Activation)</td><td>(None， 8，</td><td>8， 32）</td><td>0</td></tr><tr><td>dropout_5</td><td>(Dropout)</td><td>(None, 8，</td><td>8， 32）</td><td>0</td></tr><tr><td>conv2d_6 (Conv2D)</td><td></td><td>(None，3，3，32)</td><td></td><td>16416</td></tr><tr><td>activation_6</td><td>(Activation)</td><td>(None，</td><td>3，3，32)</td><td>0</td></tr><tr><td>dropout_6 （Dropout)</td><td></td><td>(None， 3，3，</td><td>32)</td><td>0</td></tr><tr><td>flatten_ 1 (Flatten)</td><td></td><td>(None， 288）</td><td></td><td>0</td></tr><tr><td>dense_1 (Dense)</td><td></td><td>(None， 10）</td><td></td><td>2890</td></tr><tr><td>power_whitening_1</td><td>(PowerWhit</td><td>(None， 10）</td><td></td><td>0</td></tr><tr><td colspan=\"5\">Total params: 174,218 Trainable params: 174,218 Non-trainable params:0</td></tr></table>",
+        "bbox": [
+            210,
+            123,
+            787,
+            752
+        ],
+        "page_idx": 14
+    }
+]

parse/train/rJlHIo09KQ/rJlHIo09KQ_middle.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/rJlHIo09KQ/rJlHIo09KQ_model.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/rket4i0qtX/rket4i0qtX.md ADDED Viewed

	@@ -0,0 +1,245 @@

+# THE MEANING OF “MOST” FOR VISUAL QUESTION ANSWERING MODELS
+Anonymous authors Paper under double-blind review
+# ABSTRACT
+The correct interpretation of quantifier statements in the context of a visual scene requires non-trivial inference mechanisms. For the example of “most”, we discuss two strategies which rely on fundamentally different cognitive concepts. Our aim is to identify what strategy deep learning models for visual question answering learn when trained on such questions. To this end, we carefully design data to replicate experiments from psycholinguistics where the same question was investigated for humans. Focusing on the FiLM visual question answering model, our experiments indicate that a form of approximate number system emerges whose performance declines with more difficult scenes as predicted by Weber’s law. Moreover, we identify confounding factors, like spatial arrangement of the scene, which impede the effectiveness of this system.
+# 1 INTRODUCTION
+Deep learning methods have been very successful in many natural language processing tasks, ranging from syntactic parsing to machine translation to image captioning. However, despite significantly raised performance scores on benchmark datasets, researchers increasingly worry about interpretability and indeed quality of model decisions. We see two distinct research endeavors here, one being more pragmatic, forward-oriented, and guided by the question “Can a system solve this task?”, the other being more analytic, reflective, and motivated by the question “How does a system solve this task?”. In other words, the former aspires to improve performance, while the latter aims to increase our understanding of deep learning models.
+By ‘understanding’ here we mean observing a reasoning mechanism that, if not resembling human behavior, at least is cognitively plausible. This is by no means necessary for practically solving a task, however, we highlight two reasons why being able to explain model behavior is nonetheless important: On the one hand, cognitive plausibility increases confidence in the abilities of a system – one is generally more willing to rely on a reasonable than an incomprehensible mechanism. On the other hand, pointing out systematic shortcomings inspires systematic improvements and hence can guide progress. Moreover, particularly in the case of a human-centered domain like natural language, ultimately, some degree of comparability to human performance is indispensable.
+In this paper we are inspired by experimental practice in psycholinguistics to shed light on the question of how deep learning models for visual question answering (VQA) learn to interpret statements involving the quantifier “most”. We follow Pietroski et al. (2009) in designing abstract visual scenes where we control the ratio of the objects quantified over and their spatial arrangement, to identify whether VQA models exhibit a preferred strategy of verifying whether “most” applies. Figure 1 illustrates how visual scenes can be configured to favor one over another mechanism.
+We want to emphasize the experimental approach and its difference to mainstream machine learning practice. For different interpretation strategies, conditions are identified that should or should not affect their performance, and test instances are designed accordingly. By comparing the accuracy of subjects on various instance types, predictions about a subject’s performance for these mechanisms can be verified and the most likely explanation identified. Note that our advocated evaluation methodology is entirely extrinsic and does not constrain the system in any way (like requiring attention maps) or require a specific framework (like being probabilistic).
+![](images/519cf8a0fd13367b45764328c0b9ce1dfae2b8c20a6d3c20b024044e747311e7.jpg)
+“More than half the shapes are red shapes?”
+Figure 1: Three spatial arrangements of objects which may or may not affect the performance of a mechanism for interpreting “most” statements. Going from left to right, a strategy based on pairing entities of each set and identifying the remainder gets more difficult, while a strategy based on comparing cardinalities does not.
+Psychology as a discipline has focused entirely on questions around how humans process situations and arrive at decisions, and consequently has the potential to inspire a lot of experiments (like ours) for investigating the same questions in the context of machine learning. Similar to psychology, we advocate the preference of an artificial experimentation environment which can be controlled in detail, over the importance of data originating from the real world, to arrive at more convincing and thus meaningful results.
+Artificial data has a history in deep learning of establishing new techniques – most prominently, LSTMs were introduced by showing their ability to handle various formal grammars (Gers & Schmidhuber, 2001) – and our higher-level goal with this paper is to demonstrate the potential for more informative evaluation of machine learning models in general. This is motivated by our belief that, in the long term, true progress can only be made if we do not just rely on the narrative of neural networks “learning to understand/solve” a task, but can actually confirm our theories experimentally. Taking inspiration from psychology seems particularly appropriate in the context of powerful deep learning models, which recently are not infrequently described by anthropomorphizing words like “understanding”, and compared to “human-level” performance.
+# 2 THE MEANING OF “MOST”
+In this section we will introduce the two mechanisms of interpreting “most”, discuss cognitive differences and implications, and introduce relevant cognitive concepts.
+# 2.1 GENERALIZED QUANTIFIERS AND “MOST”
+“Most” has a special status in linguistics due to the fact that it is the most prominent example of a quantifier whose semantics cannot be expressed in first-order logic, while other simple natural language quantifiers like “some”, “every” or $" n o '$ directly correspond to the quantifier primitives $\exists$ and $\forall$ (plus logical operators $\wedge$ , ∨ and $\neg$ ). This situation is not just a matter of introducing further appropriate primitives, but requires a fundamental extension of the logic system and its expressivity.
+In the following, by $x$ we denote an entity, $\pmb { A }$ and $\textbf {  { B } }$ denote predicates (“square”, “red”), $A ( x )$ is true if and only if $x$ satisfies $\pmb { A }$ , and $\mathbb { S } _ { A } \stackrel { \cdot } { = } \{ x : A ( x ) \}$ is the corresponding set of entities satisfying this predicate (“squares”). Thus we can define the semantics of “some” and “every”:
+$$
+\operatorname { s o m e } / \mathrm { e v e r y } ( A , B ) \Leftrightarrow \exists / \forall x : A ( x ) \Rightarrow B ( x )
+$$
+Importantly, these definitions do not involve the concept of set cardinality and indeed can be formulated without involving sets. This is not possible for “most”, which is commonly defined in one of the following ways:
+$$
+\begin{array} { r } { \operatorname* { m o s t } ( A , B ) \Leftrightarrow \vert \mathbb { S } _ { A \wedge B } \vert > 1 / 2 \cdot \vert A \vert } \\ { \Leftrightarrow \vert \mathbb { S } _ { A \wedge B } \vert > \vert \mathbb { S } _ { A \wedge - B } \vert } \end{array}
+$$
+This makes “most” an example of a generalized quantifier, and in fact all generalized quantifiers can be defined in terms of cardinalities, indicating the apparent importance of a cardinality concept to human cognition.
+# 2.2 ALTERNATIVE CHARACTERIZATION
+There is another way to define “most” which uses the fact that whether two sets are equinumerous can be determined without a concept of cardinality, based on the idea of a bijection:
+$$
+\begin{array} { c } { A  B : \Leftrightarrow \forall x : [ A ( x ) \Leftrightarrow B ( x ) ] } \\ { \Leftrightarrow | \mathbb { S } _ { A } | = | \mathbb { S } _ { B } | } \end{array}
+$$
+The definition of equinumerosity can be generalized to “more than” (and, correspondingly, “less than”), which lets us define “most” as follows:
+$$
+\operatorname { m o s t } ( A , B ) \Leftrightarrow \exists \mathbb { S } \subset \mathbb { S } _ { A \land B } : \mathbb { S }  \mathbb { S } _ { A \land \neg B }
+$$
+Although, at a first glance, this definition looks similar to the one above, it can be seen as suggesting a different algorithmic approach to interpreting “most”, as we will discuss below.
+# 2.3 TWO INTERPRETATION STRATEGIES
+The two characterizations of “most” are of course truth-conditionally equivalent, that is, every situation in which one of them holds, the other holds, and vice versa. In particular, if we are just interested in solving a task involving “most” statements, we can be agnostic about which definition our system prefers. Nevertheless, the subtle differences between these two characterizations suggest different algorithmic mechanisms of verifying or falsifying such statements, meaning that a system processes a visual scene differently to come to the (same) conclusion about a statement’s truth.
+# Characterization (2) represents the cardinality-based strategy of interpreting “most”:
+1. Estimate the number of entities satisfying both predicates (“red squares”) and the number satisfying one predicate but not the other (“non-red squares”). 2. Compare these number estimates and check whether the former is greater than the latter.
+We want to add that, actually, the two definitions in (2) already suggest a minor variation of this mechanism – see Hackl (2009) for a discussion on “most” versus “more than half”. However, we do not focus on this detail here, and assume the second variant in (2) to be ‘strictly’ simpler in the sense that both involve estimating and comparing cardinalities, but the first variant additionally involves the rather complex operation of halving one number estimate.
+Characterization (5) utilizes the concept of a bijection, which is a comparatively simple pairing mechanism and as such could be imagined to be a primitive cognitive operation. This gives us the pairing-based strategy of interpreting “most”:
+1. Successively match entities satisfying both predicates (“red squares”) uniquely with entities satisfying one predicate but not the other (“non-red squares”). 2. The remaining entities are all of one type, so pick one and check whether it is of the first type (“red square”).
+# 2.4 COGNITIVE IMPLICATIONS
+Finding evidence for one strategy over the other has substantial implications with respect to the ‘cognitive abilities’ of a neural network model. In particular, evidence for a cardinality-based processing of “most” suggests the existence of an approximate number system (ANS), which is able to simultaneously estimate the number of objects in two sets, and perform higher-level operations on the resulting number representations themselves, like the comparison operation here. Explicit counting would be an even more accurate mechanism here, but neither available to the subjects in the experiments of Pietroski et al. (2009) due to very short scene display time, nor likely to be learned by the ‘one-glance’ feed-forward-style neural network we evaluate in this work1.
+The ANS (see appendix in Lidz et al. (2011) for a summary) is an evolutionary comparatively old mechanism which is shared between many different species throughout the animal world. It emerges without explicit training and produces approximate representations of the number of objects of some type. They are approximate in the sense that their number judgment is not ‘sharp’, but resulting behavior exhibits variance – like interpreting “most” statements with a cardinality-based strategy, as described above. This variance follows Weber’s law which states that the discriminability of two quantities is a function of their ratio2. The precision of the ANS is thus usually indicated by a characteristic value called Weber fraction which relates quantity and variance. The ANS of a typical adult human is often reported to have a Weber fraction of 1.14 or, more tangibly, it can distinguish a ratio of 7:8 with $7 5 \%$ accuracy. Finding evidence for the emergence of a similar system in deep neural networks indicates that these models can indeed learn and utilize more abstract concepts (approximate numbers) than mere superficial pattern matching (“red squares” etc).
+Both mechanisms to interpret “most” suggest conditions in which they should perform well or badly. For the cardinality-based one, the difference in numbers of the two sets in question is expected to be essential: smaller differences, or greater numbers for the same absolute difference, require more accurate number estimations and hence make this comparison harder, according to Weber’s law. The pairing-based mechanism, on the other hand, is likely affected by the spatial arrangement of the objects in question: if the objects are more clustered within one set, pairing them with objects from the other set becomes harder. Importantly, these conditions are orthogonal, so each mechanism should not substantially be affected by the other condition, respectively. By constructing (artificial) scenes where one of the conditions dominates the configuration, and measuring the accuracy of being able to correctly interpret propositions involving “most”, the expected difficulties can be confirmed (or refuted) and thus indicate which mechanism is actually at work.
+Using this methodology, Pietroski et al. (2009) show that humans exhibit a default strategy of interpreting “most”, at least when only given $2 0 0 \mathrm { m s }$ to look at the scene and hence having to rely on an immediate subconscious judgment. This strategy is based on the approximate number system and the cardinality-based mechanism. Moreover, the behavior is shown to be sub-optimal in some situations where humans would, in principle, be able to perform better if deviating from their default strategy. Since machine learning models are trained by optimizing parameters for the task at hand, it is far from obvious whether they learn a similarly stable default mechanism, or instead follow a potentially superior adaptive strategy depending on the situation. While the latter is likely more efficient in solving at least a narrowly defined task, the former would instead suggest that the system is able to acquire and utilize core concepts like an approximate number system.
+We may speculate about the innate preference of modern network architectures for either of the strategies: Most of the visual processing is based on convolutions which, being an inherently local computation, we assume would favor the pairing-based strategy via locally matching and ‘cancelling out’ entities of the two predicates. On the other hand, the tensors resulting from the sequence of convolution operations are globally fused into a final embedding vector, which in turn would support the more globally aggregating cardinality-based strategy. However, the type of computations and representations learned by deep neural networks are poorly understood, making such speculations fallacious. We thus emphasize again that the higher-level motivation for this paper is to demonstrate how we need not rely on such speculative ‘narratives’, but can experimentally substantiate our claims.
+# 3 EXPERIMENTAL SETUP
+The setup in this paper closely resembles the psychological experiments conducted by Pietroski et al. (2009), but aimed at a state-of-the-art VQA model and its interpretation of “most”.
+• Exactly two squares are yellow.
+• Exactly no square is red.
+More than half the red shapes are squares.
+• More than a third of the shapes are cyan.
+• Less than half the shapes are green.
+• Exactly all magenta shapes are squares.
+• At most five shapes are magenta.
+• At least one triangle is gray.
+![](images/b7831eb3292ea0d291005dfe3cd6dea5b33ab6904aa03d8e75b8d3d39e98c08b.jpg)
+![](images/53d50c1372a6d57ab37ab67c617cc4c17737075607b09eca25ab94c0e2fb8b22.jpg)
+Figure 2: Two example images with four in-/correct captions each, taken from the Q-full dataset (all quantifier and number captions).
+# 3.1 TRAINING AND EVALUATION DATA
+We use the ShapeWorld framework (Kuhnle & Copestake, 2017) as starting point to generate appropriate data. ShapeWorld is a configurable generation system for abstract, visually grounded language data. A data point consists of an image, an accompanying caption, and an agreement value indicating whether the caption is true given the image. The underlying task, image caption agreement, essentially corresponds to yes/no questions and as such is a type of visual question answering. Internally, the system samples an abstract world description from which a semantic caption representation is extracted. Both are then turned into ‘natural’ (but still abstract) representations as image and natural language statement, respectively. The latter transformation is based on a semantic grammar formalism (see their paper for details).
+We use the pre-implemented quantifier captioner component, both in its unrestricted version and one with available quantifiers restricted to “more than half” and “less than half”3. The former contains various additional (generalized) quantifiers (“no”, “a/three quarter(s)”, “a/two third(s)”, “all”) and numbers (ranging from “zero” to “five”), each in combination with a comparing modifier (“less than”, “at most”, “exactly”, “at least”, “more than”, “not”). We refer to the unrestricted version as Q-full, the other one as Q-half. Figure 2 shows two images together with potential Q-full captions.
+We also use the default world generator to produce training data (up to 15 randomly positioned objects, as seen in figure 2). However, all of the pre-implemented generator modules are too generic for our evaluation purposes, since they do not allow to control attributes and positioning of objects to the desired degree. We thus implemented our own custom generator module with the following functionality to produce test data.
+Attribute contrast: For each instance, either the attribute ‘shape’ or ‘color’ is picked4, and subsequently two values for this attribute and one value for the other is randomly chosen. This means that the only relevant difference between objects in every image is either one of two shape or color values (for instance, red vs blue squares, or red squares vs circles).
+Contrast ratios: A list of valid ratios between the contrasted attributes can be specified, from which one will randomly be chosen per instance. For instance, a ratio of 2:3 means that there are $50 \%$ more objects with the second than the first attribute. We look at values close to 1:1, that is, 1:2, 2:3, 3:4, 4:5, etc. The increasing difficulty (for humans) resulting from closer ratios is illustrated in figure 3. Multiples of the smaller-valued ratios are also generated (e.g., 2:4 or 6:9), within the limit of up to 15 objects overall.
+Area-controlled: If this option is set, object sizes are not chosen uniformly across the entire valid range, but size ranges for the two contrasting object types are adapted to the given contrast ratio and size of the chosen shape(s), so that both attributes cover the same image area on average. This means that the more numerous attribute will generally be represented by smaller objects, and the difference in covered area between, for instance, squares and triangles is taken into account.
+![](images/687147eec990d42635eb5ad93cd1cd6969f03efed2811f813665a87c84a4e4ac.jpg)
+Figure 3: From left to right, the ratio between the two attributes is increasingly balanced.
+While objects are still positioned randomly in the basic version of this new generator module, we define two modes which control this aspect as well. Figure 1 in the introduction illustrates the different modes.
+Partitioned positioning: An angle is randomly chosen for each image, and objects of the contrasting attributes are consistently placed either on one side or the other.
+Paired positioning: If there are objects of the contrasted attribute which are not yet paired, one of them is randomly chosen and the new object is placed next to it.
+The captions of these evaluation instances are always of the form “More/less than half the shapes are $X ^ { \prime \prime }$ . with $" X '$ being the attribute in question, for instance, “squares” or “red”. Note that this is an even more constrained captioner than the one used for Q-half, since the subject is always fully underspecified as “shape”. We also emphasize that, in contrast to this new evaluation generator module, the default generator configuration of the ‘quantification’ dataset pre-specified in ShapeWorld is used to generate the training instances in Q-half and Q-full. So these images generally contain many more than just two contrasted attributes, and ratios between attributes tend to be accordingly smaller. The examples in figure 2 are chosen to illustrate this fact: the second example contains a “half” statement with ratio 7:8, and the first contains one about a 0:4 ratio, while the image would also allow for a more ‘interesting’ 3:4 ratio (color of semicircles).
+While we generally try to stay close to the experimental setup of Pietroski et al. (2009), in the following we point out some differences. Most importantly, instead of just using yellow and blue dots, we use all eight shapes and seven colors that ShapeWorld provides. This increases the visual variety of the instances and thus encourages the system to actually learn the fact that shape and color are attributes that can be combined in any way, instead of just straightforward binary pattern matching. Note that the humans in the psychological experiments have learned language in even more complex situations, which we cannot hope to approximate here. Moreover, our data does not contain yes/no questions but true/false captions, and “most”-equivalent phrasings “more/less than half”. Since the model is trained from scratch on such data, this should not affect results.
+We do not implement their ‘column pairs mixed/sorted’ modes since they would require comparatively big and mostly empty images, hence require bigger networks and might cause practical learning problems due to sparseness, which we do not want to address here. In contrast, our ‘partitioned’ mode is more difficult than the ones investigated by Pietroski et al. (2009), at least for a pairing-based mechanism.
+We will publish the generator configurations and custom generator modules required to reproduce the datasets we used here on acceptance of the paper.
+# 3.2 MODEL
+We focus on the FiLM model (Perez et al., 2018) here since it exhibited close-to-perfect accuracy on the CLEVR dataset (Johnson et al., 2017a), a diagnostic dataset for VQA which also consists of abstract images. We interpret the ShapeWorld captions and agreement values as questions and answer, respectively. The image is processed using either a pre-trained CNN or a four-layer CNN trained from scratch on the task. The question is processed by a GRU. In a sequence of four residual blocks, the image information is processed with its features linearly modulated (scale, offset) conditioned on the processed question embedding. Finally, the classifier module produces the answer, true or false. We use the code made available by the authors of the FiLM model, without changing any parameters. The only aspect we adapt is the trainable four-layer CNN, which uses a kernel size of 3, batch normalization and a stride of 2 in the second and fourth layer.
+![](images/89879fb5ba739ee5c3a88c305f87f6a8627ded0560b33bfe649f2f3acf3a9d87.jpg)
+Figure 4: Training performance (iterations in 1000).
+We considered investigating other models as well: The $\mathrm { P G + E E }$ model (Johnson et al., 2017b) is openly available and achieved very good performance on CLEVR, however, it relies on the ‘program tree’ provided by CLEVR, and while there exists a basic conversion of ShapeWorld caption models to CLEVR program trees, first, the CLEVR-specific modules do not cover quantifiers like “most” and, second, these program trees encode the interpretation strategy, which would defeat the purpose of our investigation to analyze precisely this mechanism as learned from data. The RelationNet architecture (Santoro et al., 2017) explicitly implements a pairing-based mechanism and hence we considered its evaluation less interesting than FiLM. For similar reasons, we did not focus on the VQA model of Zhang et al. (2018), whose architecture includes an explicit counting component. While our aim is to investigate the strategy for understanding “most” learned from data, it would be interesting to examine in both cases whether their architectural prior does indeed have the expected effect. Finally, we only learned about the MAC model (Hudson & Manning, 2018) after we started this project and so decided to leave it for future work, but we definitely consider it one of the most interesting candidate models to evaluate, since its architecture does not suggest an obvious preference for either strategy.
+# 3.3 TRAINING DETAILS
+The training set for both Q-full and Q-half consists of around $1 0 0 \mathrm { k }$ $2 5 \mathrm { x } 4 0 9 6 )$ images with 5 captions per image, so overall around 500k instances. The model is trained for 100k iterations with a batch size of 64. Training performance is measured on an additional validation set of 20k instances. Moreover, we produced 1024 instances for each of the overall 48 evaluation configurations, to investigate the trained model in more detail.
+# 4 RESULTS
+Training. We train two versions of the FiLM model, with CNN trained from scratch on the task: one on the Q-full dataset which contains all available quantifier and number caption types, the other on the Q-half dataset which is restricted to captions involving the quantifier “half” only. Performance of the system over the course of the $1 0 0 \mathrm { k }$ training iterations is shown in figure 4. The two models, referred to by Q-full and Q-half below, learn to solve the task quasi-perfectly, with a final accuracy of $9 8 . 9 \%$ and $9 9 . 4 \%$ respectively. Not surprisingly, the system trained on the more diverse Q-full training set takes longer to reach this level of performance, but nevertheless plateaus after around 70k iterations.
+For the sake of completeness, we also include the performance of other models in this figure, which failed to show clear improvement over the first $5 0 \mathrm { k }$ iterations. This includes the FiLM model with pre-trained instead of trainable CNN module (Q-full-pre, Q-half-pre), and an earlier trial on Q-half (Q-half-coll) where we did not constrain the data generation to not produce object collisions (the default in ShapeWorld is to allow up to $2 5 \%$ area overlap). We note, however, that we have not done any hyperparameter search which might alleviate these learning problems.
+Figure 5: Accuracy (in $\%$ ) of model trained on Q-full and Q-half for the various evaluation setups.
+<table><tr><td rowspan=2 colspan=1>train</td><td rowspan=2 colspan=1>mode</td><td rowspan=1 colspan=8>size-controlled</td><td rowspan=1 colspan=8>area-controlled</td></tr><tr><td rowspan=1 colspan=1>all</td><td rowspan=1 colspan=1>1:2</td><td rowspan=1 colspan=1>2:3</td><td rowspan=1 colspan=1>3:4</td><td rowspan=1 colspan=2>4:55:6</td><td rowspan=1 colspan=1>6:7</td><td rowspan=1 colspan=1>7:8</td><td rowspan=1 colspan=1>all</td><td rowspan=1 colspan=1>1:2</td><td rowspan=1 colspan=1>2:3</td><td rowspan=1 colspan=1>3:4</td><td rowspan=1 colspan=1>4:5</td><td rowspan=1 colspan=1>5:6</td><td rowspan=1 colspan=1>6:7</td><td rowspan=1 colspan=1>7:8</td></tr><tr><td rowspan=3 colspan=1>Q-full</td><td rowspan=3 colspan=1>randompairedpart.</td><td rowspan=3 colspan=1>929389</td><td rowspan=3 colspan=1>10099100</td><td rowspan=2 colspan=1>9999</td><td rowspan=1 colspan=1>97</td><td rowspan=1 colspan=2>94 91</td><td rowspan=1 colspan=1>88</td><td rowspan=1 colspan=1>85</td><td rowspan=1 colspan=1>93</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>97</td><td rowspan=1 colspan=1>93</td><td rowspan=1 colspan=1>91</td><td rowspan=1 colspan=1>86</td><td rowspan=1 colspan=1>82</td></tr><tr><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>93</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>88</td><td rowspan=1 colspan=1>82</td><td rowspan=1 colspan=1>93</td><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>91</td><td rowspan=1 colspan=1>87</td><td rowspan=1 colspan=1>84</td><td rowspan=1 colspan=1>80</td></tr><tr><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>92</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>81</td><td rowspan=1 colspan=1>77</td><td rowspan=1 colspan=1>72</td><td rowspan=1 colspan=1>89</td><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>98</td><td rowspan=1 colspan=1>92</td><td rowspan=1 colspan=1>88</td><td rowspan=1 colspan=1>82</td><td rowspan=1 colspan=1>78</td><td rowspan=1 colspan=1>72</td></tr><tr><td rowspan=3 colspan=1>Q-half</td><td rowspan=3 colspan=1>randompairedpart.</td><td rowspan=3 colspan=1>291</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>98</td><td rowspan=1 colspan=1>93</td><td rowspan=1 colspan=1>88</td><td rowspan=1 colspan=1>88</td><td rowspan=1 colspan=1>87</td><td rowspan=1 colspan=1>93</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>97</td><td rowspan=1 colspan=1>92</td><td rowspan=1 colspan=1>86</td><td rowspan=1 colspan=1>85</td><td rowspan=1 colspan=1>82</td></tr><tr><td rowspan=2 colspan=1>100100</td><td rowspan=2 colspan=1>10099</td><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>86</td><td rowspan=1 colspan=1>84</td><td rowspan=1 colspan=1>79</td><td rowspan=1 colspan=1>92</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>87</td><td rowspan=1 colspan=1>84</td><td rowspan=1 colspan=1>79</td><td rowspan=2 colspan=1>76</td></tr><tr><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=2>86 83</td><td rowspan=1 colspan=1>83</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>91</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>94</td><td rowspan=1 colspan=1>89</td><td rowspan=1 colspan=1>83</td><td rowspan=1 colspan=1>83</td></tr></table>
+Evaluation. Table 5 presents a detailed breakdown of system performance on the evaluation settings. Before discussing the results in detail, we want to reiterate three key differences between the evaluation data and the training data:
+• The visual scenes here do all exhibit close-to-balanced contrast ratios, while this is not the case for the training instances.
+• The evaluation scenes only contain objects of two different attribute pairs, and consequently the numbers to compare are generally greater than in the training instances, where more attributes are likely present in a scene. Q-full contains not just statements involving “half” – in fact, a random sample of 100 images / 500 captions suggests that they constitute only around $8 \%$ of the dataset (and this includes combinations with modifiers beyond “more/less than”).
+Considering that, the relatively high accuracy on test instances throughout indicates a remarkable degree of generalization.
+More balanced ratios. The most consistent effect is that more balanced ratios of contrasted attributes cause performance to decrease. This is certainly affected by the tendency of the training data to not include many examples of almost balanced ratios. However, if this were the only reason, one would expect a much more sudden and less uniformly linear decrease. More importantly, since Q-full generally contains fewer “half” statements, the decline should be more pronounced here. We do not observe either of these effects, and thus conclude that both models may actually have developed an approximate number system. This is further discussed at the end of this section.
+Random vs paired vs partitioned. There is definitely a clear negative effect of the partitioned configuration on performance for the model trained on Q-full, which indicates that the learned mechanism is not robust to a high degree of per-attribute clustering. This does not indicate a preference for the pairing-based strategy, though, since both models perform best on the random configuration. While this suggests that there is neither a preference for the perfectly clustered partitioned nor for the perfectly mixed paired arrangement, we note that the effect is not strong, and that these instances are most similar to the random placement of objects in the training data, which might cause this effect.
+Size- vs area-controlled. The performance in both cases is comparable, showing that the models do not (solely) learn to rely on comparing the overall covered area, which would only work well in the size-controlled mode. Nevertheless, we note a tendency for area-controlled instances to be somewhat more difficult in random and paired mode, more so for Q-half, which suggests that the model(s) learn to use covered area as a feature to inform a correct decision in some cases.
+Q-full vs Q-half. There seems to be a tendency of the system trained on Q-full to perform marginally better, except for the partitioned mode discussed before. The fact that this model performs at least on a par with the one trained on Q-half, while only seeing a fraction of directly relevant training captions, indicates that the learning process is not ‘distracted’ by the variety of captions, and indeed might profit from it.
+Ratios and Weber fraction. We generated evaluation sets of even more balanced ratios (8:9, 9:10, 10:11, increasing the overall number of objects accordingly to 17/19/21), and in figure 6 plotted the accuracy of the Q-full model on increasingly balanced sets for all three spatial configuration modes, not controlling for area (which for greater numbers only has a negligible effect anyway). The figure also contains a diagram with accuracy plotted against ratio fraction, which is more common in the context of Weber’s law. The characteristic Weber fraction can be read off directly as the ratio at which a subject is able to distinguish two values with $7 5 \%$ accuracy. We observe around 1.11 for random/paired and 1.16 for partitioned, which corresponds to 9:10 and 6:7 as closest integer ratios. These values are in the same region as the average human Weber fraction, which is often reported as being 1.14, or 7:8.
+![](images/76fe8e687a29bca0dd010d7ae8e942658d2596c8cb334aeaf19eaa0d9b11dd61.jpg)
+Figure 6: (Left) Q-full model performance for increasingly balanced ratios ( $\mathbf { \bar { X } }$ -axis: ratio as $\mathrm { n m } { + 1 }$ ). (Right) Performance as a function of actual ratio fraction $\mathrm { n } { + } 1 / \mathrm { n }$ , with Weber fractions $( 7 5 \% )$ highlighted and the corresponding idealized model Weber curves indicated.
+We emphasize that these curves align well with the trend predicted by Weber’s law, even for the ratios with more than 15 objects overall, where such situations have never been encountered during training. All this strongly suggests that the model learns a mechanism similar to an ANS, which is able to produce representations that can (at least) be utilized for identifying the more numerous set. It can in particular be concluded that the system does not actually learn to explicitly count, since we would then not expect to observe such fuzziness characteristic to an ANS.
+Moreover, since performance is affected somewhat by the partitioned and the area-controlled modes, the interpretation of “most” seems to be informed by other features as well. As we noted earlier, since the model is trained to optimize this task, an adaptive strategy is not unexpected. On the contrary, more surprising is the fact that an ANS-like system emerges as a dominating ‘backbone’ mechanism, with additional factors acting as less influential ‘secondary’ features.
+# 5 RELATED WORK
+Visual question answering (VQA) is the general task of answering questions about visual scenes. Since the introduction of the VQA Dataset (Antol et al., 2015), this dataset was widely used as evaluation benchmark for multimodal deep learning. It provides a shallow categorization of questions, including basic count questions, however, these categories are far too coarse for our purposes.
+Motivated by various problems with the VQA Dataset (Goyal et al., 2017; Agrawal et al., 2016), a range of artificial abstract datasets have been introduced recently. CLEVR (Johnson et al., 2017a) consists of rendered images of geometric objects and questions generated based on templates, covering some abilities like number or attribute comparison in more detail, but still in a fixed categorization. NLVR (Suhr et al., 2017) contains crowdsourced statements about abstract images, but does not sort them according to some criteria. Recently, the COG dataset (Yang et al., 2018) was introduced, which most explicitly focuses on replicating psychological experiments for deep learning models, hence most related to our work. However, their dataset does not contain any number or quantifier statements.
+There is some work on investigating deep neural networks which look at numerosity from a more psychologically inspired viewpoint. Stoianov & Zorzi (2012) find that visual numerosity emerges from unsupervised learning on abstract image data. Zhang et al. (2015) look at salient object subitizing in real-world images, formulated as a classification task over five classes ranging from $\cdot _ { 0 } \cdot \mathrm { \ }$ to $^ { \bullet } 4$ or more’. In a more general number-per-category classification setup, Chattopadhyay et al. (2017) investigate different methods of obtaining counts per object category, one of them inspired by subitizing. Moving beyond explicit number classification, Zhang et al. (2018) recently introduced a dedicated counting module for visual question answering.
+Other work looks at a similar classification task, but for proper quantifiers like “no”, “few”, “most”, “all”, first on abstract images of circles (Sorodoc et al., 2016), then on natural scenes (Sorodoc et al., 2018). Recently, Pezzelle et al. (2018) investigated a hierarchy of quantifier-related classification abilities, from comparatives via quantifiers like the ones above to fine-grained proportions. Wu et al. (2018), besides investigating precise numerosity via number classification as above, also look at approximate numerosity as binary greater/smaller decision, which closely corresponds to our experiments. However, their focus is on the subitizing ability, not the approximate number system, and their experiments follow a different methodology in that they already train models on specifically designed datasets, while we deliberately leverage such targeted data only for evaluation.
+On a methodological level, our proposal of inspiring experimental setup and evaluation practice for deep learning by cognitive psychology is in line with that of Ritter et al. (2017) and their shape bias investigation for modern vision architectures.
+# 6 CONCLUSION
+We identify two strategies of algorithmically interpreting “most” in a visual context, with different implications on cognitive concepts. Following experimental practice of similar investigations with humans in psycholinguistics, we design experiments and data to shed light on the question whether the state-of-the-art FiLM VQA model shows preference for one strategy over the other. Performance on various specifically designed instances does indeed indicate that a form of approximate number system is learned, which generalizes to more difficult scenes as predicted by Weber’s law. The results further suggest that additional features influence the interpretation process, which are affected by the spatial arrangement and relative size of objects in a scene. There are many opportunities for future work from here, from strengthening the finding of an approximate number system and further analyzing confounding factors, to investigating the relation to more explicit counting tasks, to extending the evaluation to other visual question answering models which also exhibit good performance on related tasks (Hudson & Manning, 2018; Zhang et al., 2018; Santoro et al., 2017).
+# REFERENCES
+Aishwarya Agrawal, Dhruv Batra, and Devi Parikh. Analyzing the behavior of visual question answering models. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, EMNLP 2016, pp. 1955–1960, 2016.
+Stanislaw Antol, Aishwarya Agrawal, Jiasen Lu, Margaret Mitchell, Dhruv Batra, C. Lawrence Zitnick, and Devi Parikh. VQA: Visual question answering. In Proceedings of the IEEE International Conference on Computer Vision, ICCV 2015, 2015.
+Prithvijit Chattopadhyay, Ramakrishna Vedantam, Ramprasaath R. Selvaraju, Dhruv Batra, and Devi Parikh. Counting everyday objects in everyday scenes. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2017, pp. 4428–4437, 2017.
+Felix A. Gers and Jurgen Schmidhuber. LSTM recurrent networks learn simple context-free and ¨ context-sensitive languages. Transactions on Neural Networks, 12(6):1333–1340, 2001.
+Yash Goyal, Tejas Khot, Douglas Summers-Stay, Dhruv Batra, and Devi Parikh. Making the V in VQA matter: Elevating the role of image understanding in Visual Question Answering. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2017, pp. 6325–6334, 2017.
+Martin Hackl. On the grammar and processing of proportional quantifiers: most versus more than half. Natural Language Semantics, 17(1):63–98, 2009.
+Drew A. Hudson and Christopher D. Manning. Compositional attention networks for machine reasoning. In Proceedings of the International Conference on Learning Representations, ICLR 2018, 2018.
+Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C. Lawrence Zitnick, and Ross Girshick. CLEVR: A diagnostic dataset for compositional language and elementary visual reasoning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2017, 2017a.
+Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Judy Hoffman, Li Fei-Fei, C Lawrence Zitnick, and Ross Girshick. Inferring and executing programs for visual reasoning. In Proceedings of the IEEE International Conference on Computer Vision, ICCV 2017, 2017b.
+Alexander Kuhnle and Ann Copestake. ShapeWorld - A new test methodology for multimodal language understanding. ArXiv e-prints 1704.04517, 2017.
+Jeffrey Lidz, Paul Pietroski, Justin Halberda, and Tim Hunter. Interface transparency and the psychosemantics of most. Natural Language Semantics, 19(3):227–256, 2011.
+Ethan Perez, Florian Strub, Harm de Vries, Vincent Dumoulin, and Aaron C. Courville. FiLM: Visual reasoning with a general conditioning layer. In AAAI, 2018.
+Sandro Pezzelle, Ionut-Teodor Sorodoc, and Raffaella Bernardi. Comparatives, quantifiers, proportions: A multi-task model for the learning of quantities from vision. In Proceedings of the Conference of the North American Chapter of the Association for Computational Linguistics, NAACL 2018, 2018.
+Paul Pietroski, Jeffrey Lidz, Tim Hunter, and Justin Halberda. The meaning of ’most’: Semantics, numerosity and psychology. Mind and Language, 24(5):554–585, 2009.
+Samuel Ritter, David G. T. Barrett, Adam Santoro, and Matt M. Botvinick. Cognitive psychology for deep neural networks: A shape bias case study. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, pp. 2940–2949, 2017.
+Adam Santoro, David Raposo, David G. T. Barrett, Mateusz Malinowski, Razvan Pascanu, Peter Battaglia, and Timothy P. Lillicrap. A simple neural network module for relational reasoning. In Proceedings of the Annual Conference on Neural Information Processing Systems, NIPS 2017, pp. 4974–4983, 2017.
+Ionut Sorodoc, Angeliki Lazaridou, Gemma Boleda, Aurelie Herbelot, Sandro Pezzelle, and Raf- ´ faella Bernardi. “Look, some green circles!”: Learning to quantify from images. In Proceedings of the 5th Workshop on Vision and Language, Berlin, Germany, 2016.
+Ionut Sorodoc, Sandro Pezzelle, Aurelie Herbelot, Mariella Dimiccoli, and Raffaella Bernardi.´ Learning quantification from images: A structured neural architecture. Natural Language Engineering, pp. 130, 2018.
+Ivilin Stoianov and Marco Zorzi. Emergence of a ‘visual number sense’ in hierarchical generative models. Nature Neuroscience, 15(194):194–196, 2012.
+Alane Suhr, Mike Lewis, James Yeh, and Yoav Artzi. A corpus of natural language for visual reasoning. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, 2017.
+Xiaolin Wu, Xi Zhang, and Xiao Shu. On numerosity of deep convolutional neural networks. ArXiv e-prints 1802.05160, 2018.
+Guangyu Robert Yang, Igor Ganichev, Xiao-Jing Wang, Jonathon Shlens, and David Sussillo. A dataset and architecture for visual reasoning with a working memory. ArXiv e-prints 1803.06092, 2018.
+Jianming Zhang, Shuga Ma, Mehrnoosh Sameki, Stan Sclaroff, Margrit Betke, Zhe Lin, Xiaohui Shen, Brian Price, and Radom´ır Mech. Salient object subitizing. In ˇ Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2015, 2015.
+Yan Zhang, Jonathon Hare, and Adam Prugel-Bennett. Learning to count objects in natural im- ¨ ages for visual question answering. In Proceedings of the International Conference on Learning Representations, ICLR 2018, 2018.

parse/train/rket4i0qtX/rket4i0qtX_content_list.json ADDED Viewed

	@@ -0,0 +1,1276 @@

+[
+    {
+        "type": "text",
+        "text": "THE MEANING OF “MOST” FOR VISUAL QUESTION ANSWERING MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The correct interpretation of quantifier statements in the context of a visual scene requires non-trivial inference mechanisms. For the example of “most”, we discuss two strategies which rely on fundamentally different cognitive concepts. Our aim is to identify what strategy deep learning models for visual question answering learn when trained on such questions. To this end, we carefully design data to replicate experiments from psycholinguistics where the same question was investigated for humans. Focusing on the FiLM visual question answering model, our experiments indicate that a form of approximate number system emerges whose performance declines with more difficult scenes as predicted by Weber’s law. Moreover, we identify confounding factors, like spatial arrangement of the scene, which impede the effectiveness of this system. ",
+        "bbox": [
+            233,
+            271,
+            764,
+            424
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            463,
+            336,
+            479
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning methods have been very successful in many natural language processing tasks, ranging from syntactic parsing to machine translation to image captioning. However, despite significantly raised performance scores on benchmark datasets, researchers increasingly worry about interpretability and indeed quality of model decisions. We see two distinct research endeavors here, one being more pragmatic, forward-oriented, and guided by the question “Can a system solve this task?”, the other being more analytic, reflective, and motivated by the question “How does a system solve this task?”. In other words, the former aspires to improve performance, while the latter aims to increase our understanding of deep learning models. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            611
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "By ‘understanding’ here we mean observing a reasoning mechanism that, if not resembling human behavior, at least is cognitively plausible. This is by no means necessary for practically solving a task, however, we highlight two reasons why being able to explain model behavior is nonetheless important: On the one hand, cognitive plausibility increases confidence in the abilities of a system – one is generally more willing to rely on a reasonable than an incomprehensible mechanism. On the other hand, pointing out systematic shortcomings inspires systematic improvements and hence can guide progress. Moreover, particularly in the case of a human-centered domain like natural language, ultimately, some degree of comparability to human performance is indispensable. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper we are inspired by experimental practice in psycholinguistics to shed light on the question of how deep learning models for visual question answering (VQA) learn to interpret statements involving the quantifier “most”. We follow Pietroski et al. (2009) in designing abstract visual scenes where we control the ratio of the objects quantified over and their spatial arrangement, to identify whether VQA models exhibit a preferred strategy of verifying whether “most” applies. Figure 1 illustrates how visual scenes can be configured to favor one over another mechanism. ",
+        "bbox": [
+            174,
+            736,
+            823,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We want to emphasize the experimental approach and its difference to mainstream machine learning practice. For different interpretation strategies, conditions are identified that should or should not affect their performance, and test instances are designed accordingly. By comparing the accuracy of subjects on various instance types, predictions about a subject’s performance for these mechanisms can be verified and the most likely explanation identified. Note that our advocated evaluation methodology is entirely extrinsic and does not constrain the system in any way (like requiring attention maps) or require a specific framework (like being probabilistic). ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/519cf8a0fd13367b45764328c0b9ce1dfae2b8c20a6d3c20b024044e747311e7.jpg",
+        "image_caption": [
+            "“More than half the shapes are red shapes?” ",
+            "Figure 1: Three spatial arrangements of objects which may or may not affect the performance of a mechanism for interpreting “most” statements. Going from left to right, a strategy based on pairing entities of each set and identifying the remainder gets more difficult, while a strategy based on comparing cardinalities does not. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            271,
+            98,
+            727,
+            214
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Psychology as a discipline has focused entirely on questions around how humans process situations and arrive at decisions, and consequently has the potential to inspire a lot of experiments (like ours) for investigating the same questions in the context of machine learning. Similar to psychology, we advocate the preference of an artificial experimentation environment which can be controlled in detail, over the importance of data originating from the real world, to arrive at more convincing and thus meaningful results. ",
+        "bbox": [
+            174,
+            320,
+            825,
+            405
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Artificial data has a history in deep learning of establishing new techniques – most prominently, LSTMs were introduced by showing their ability to handle various formal grammars (Gers & Schmidhuber, 2001) – and our higher-level goal with this paper is to demonstrate the potential for more informative evaluation of machine learning models in general. This is motivated by our belief that, in the long term, true progress can only be made if we do not just rely on the narrative of neural networks “learning to understand/solve” a task, but can actually confirm our theories experimentally. Taking inspiration from psychology seems particularly appropriate in the context of powerful deep learning models, which recently are not infrequently described by anthropomorphizing words like “understanding”, and compared to “human-level” performance. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            536
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 THE MEANING OF “MOST” ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            556,
+            423,
+            571
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section we will introduce the two mechanisms of interpreting “most”, discuss cognitive differences and implications, and introduce relevant cognitive concepts. ",
+        "bbox": [
+            174,
+            587,
+            823,
+            616
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 GENERALIZED QUANTIFIERS AND “MOST” ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            632,
+            508,
+            646
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "“Most” has a special status in linguistics due to the fact that it is the most prominent example of a quantifier whose semantics cannot be expressed in first-order logic, while other simple natural language quantifiers like “some”, “every” or $\" n o '$ directly correspond to the quantifier primitives $\\exists$ and $\\forall$ (plus logical operators $\\wedge$ , ∨ and $\\neg$ ). This situation is not just a matter of introducing further appropriate primitives, but requires a fundamental extension of the logic system and its expressivity. ",
+        "bbox": [
+            174,
+            657,
+            825,
+            728
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the following, by $x$ we denote an entity, $\\pmb { A }$ and $\\textbf {  { B } }$ denote predicates (“square”, “red”), $A ( x )$ is true if and only if $x$ satisfies $\\pmb { A }$ , and $\\mathbb { S } _ { A } \\stackrel { \\cdot } { = } \\{ x : A ( x ) \\}$ is the corresponding set of entities satisfying this predicate (“squares”). Thus we can define the semantics of “some” and “every”: ",
+        "bbox": [
+            174,
+            734,
+            825,
+            776
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/de03318c0e630e2a0e4d67b05bf1eb80cc8853f39d9798061c93315b6ffa1a4f.jpg",
+        "text": "$$\n\\operatorname { s o m e } / \\mathrm { e v e r y } ( A , B ) \\Leftrightarrow \\exists / \\forall x : A ( x ) \\Rightarrow B ( x )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            780,
+            650,
+            796
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Importantly, these definitions do not involve the concept of set cardinality and indeed can be formulated without involving sets. This is not possible for “most”, which is commonly defined in one of the following ways: ",
+        "bbox": [
+            173,
+            799,
+            826,
+            842
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/12f16534c027685b074397e139d43585ba89dd5595d39d5ed6c8c0dbeca12ace.jpg",
+        "text": "$$\n\\begin{array} { r } { \\operatorname* { m o s t } ( A , B ) \\Leftrightarrow \\vert \\mathbb { S } _ { A \\wedge B } \\vert > 1 / 2 \\cdot \\vert A \\vert } \\\\ { \\Leftrightarrow \\vert \\mathbb { S } _ { A \\wedge B } \\vert > \\vert \\mathbb { S } _ { A \\wedge - B } \\vert } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            843,
+            620,
+            882
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This makes “most” an example of a generalized quantifier, and in fact all generalized quantifiers can be defined in terms of cardinalities, indicating the apparent importance of a cardinality concept to human cognition. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 ALTERNATIVE CHARACTERIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            460,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There is another way to define “most” which uses the fact that whether two sets are equinumerous can be determined without a concept of cardinality, based on the idea of a bijection: ",
+        "bbox": [
+            173,
+            128,
+            821,
+            159
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c14c5c681ef2b625655f0f882036794acf7fb516f3a9569cab0def52ee0d8549.jpg",
+        "text": "$$\n\\begin{array} { c } { A  B : \\Leftrightarrow \\forall x : [ A ( x ) \\Leftrightarrow B ( x ) ] } \\\\ { \\Leftrightarrow | \\mathbb { S } _ { A } | = | \\mathbb { S } _ { B } | } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            161,
+            612,
+            199
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The definition of equinumerosity can be generalized to “more than” (and, correspondingly, “less than”), which lets us define “most” as follows: ",
+        "bbox": [
+            173,
+            200,
+            823,
+            228
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c7a2f95f1e6826ef065db5b28d7384af1dc49bca9adff749b2eb4398143f4935.jpg",
+        "text": "$$\n\\operatorname { m o s t } ( A , B ) \\Leftrightarrow \\exists \\mathbb { S } \\subset \\mathbb { S } _ { A \\land B } : \\mathbb { S }  \\mathbb { S } _ { A \\land \\neg B }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            233,
+            643,
+            251
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Although, at a first glance, this definition looks similar to the one above, it can be seen as suggesting a different algorithmic approach to interpreting “most”, as we will discuss below. ",
+        "bbox": [
+            174,
+            253,
+            823,
+            284
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 TWO INTERPRETATION STRATEGIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            299,
+            460,
+            314
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The two characterizations of “most” are of course truth-conditionally equivalent, that is, every situation in which one of them holds, the other holds, and vice versa. In particular, if we are just interested in solving a task involving “most” statements, we can be agnostic about which definition our system prefers. Nevertheless, the subtle differences between these two characterizations suggest different algorithmic mechanisms of verifying or falsifying such statements, meaning that a system processes a visual scene differently to come to the (same) conclusion about a statement’s truth. ",
+        "bbox": [
+            173,
+            324,
+            825,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Characterization (2) represents the cardinality-based strategy of interpreting “most”: ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            415,
+            741,
+            430
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. Estimate the number of entities satisfying both predicates (“red squares”) and the number satisfying one predicate but not the other (“non-red squares”). 2. Compare these number estimates and check whether the former is greater than the latter. ",
+        "bbox": [
+            212,
+            440,
+            823,
+            486
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We want to add that, actually, the two definitions in (2) already suggest a minor variation of this mechanism – see Hackl (2009) for a discussion on “most” versus “more than half”. However, we do not focus on this detail here, and assume the second variant in (2) to be ‘strictly’ simpler in the sense that both involve estimating and comparing cardinalities, but the first variant additionally involves the rather complex operation of halving one number estimate. ",
+        "bbox": [
+            174,
+            496,
+            823,
+            565
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Characterization (5) utilizes the concept of a bijection, which is a comparatively simple pairing mechanism and as such could be imagined to be a primitive cognitive operation. This gives us the pairing-based strategy of interpreting “most”: ",
+        "bbox": [
+            176,
+            573,
+            825,
+            614
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. Successively match entities satisfying both predicates (“red squares”) uniquely with entities satisfying one predicate but not the other (“non-red squares”). 2. The remaining entities are all of one type, so pick one and check whether it is of the first type (“red square”). ",
+        "bbox": [
+            200,
+            626,
+            825,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.4 COGNITIVE IMPLICATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            702,
+            400,
+            715
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finding evidence for one strategy over the other has substantial implications with respect to the ‘cognitive abilities’ of a neural network model. In particular, evidence for a cardinality-based processing of “most” suggests the existence of an approximate number system (ANS), which is able to simultaneously estimate the number of objects in two sets, and perform higher-level operations on the resulting number representations themselves, like the comparison operation here. Explicit counting would be an even more accurate mechanism here, but neither available to the subjects in the experiments of Pietroski et al. (2009) due to very short scene display time, nor likely to be learned by the ‘one-glance’ feed-forward-style neural network we evaluate in this work1. ",
+        "bbox": [
+            173,
+            727,
+            825,
+            838
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The ANS (see appendix in Lidz et al. (2011) for a summary) is an evolutionary comparatively old mechanism which is shared between many different species throughout the animal world. It emerges without explicit training and produces approximate representations of the number of objects of some type. They are approximate in the sense that their number judgment is not ‘sharp’, but resulting behavior exhibits variance – like interpreting “most” statements with a cardinality-based strategy, as described above. This variance follows Weber’s law which states that the discriminability of two quantities is a function of their ratio2. The precision of the ANS is thus usually indicated by a characteristic value called Weber fraction which relates quantity and variance. The ANS of a typical adult human is often reported to have a Weber fraction of 1.14 or, more tangibly, it can distinguish a ratio of 7:8 with $7 5 \\%$ accuracy. Finding evidence for the emergence of a similar system in deep neural networks indicates that these models can indeed learn and utilize more abstract concepts (approximate numbers) than mere superficial pattern matching (“red squares” etc). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Both mechanisms to interpret “most” suggest conditions in which they should perform well or badly. For the cardinality-based one, the difference in numbers of the two sets in question is expected to be essential: smaller differences, or greater numbers for the same absolute difference, require more accurate number estimations and hence make this comparison harder, according to Weber’s law. The pairing-based mechanism, on the other hand, is likely affected by the spatial arrangement of the objects in question: if the objects are more clustered within one set, pairing them with objects from the other set becomes harder. Importantly, these conditions are orthogonal, so each mechanism should not substantially be affected by the other condition, respectively. By constructing (artificial) scenes where one of the conditions dominates the configuration, and measuring the accuracy of being able to correctly interpret propositions involving “most”, the expected difficulties can be confirmed (or refuted) and thus indicate which mechanism is actually at work. ",
+        "bbox": [
+            174,
+            277,
+            825,
+            429
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Using this methodology, Pietroski et al. (2009) show that humans exhibit a default strategy of interpreting “most”, at least when only given $2 0 0 \\mathrm { m s }$ to look at the scene and hence having to rely on an immediate subconscious judgment. This strategy is based on the approximate number system and the cardinality-based mechanism. Moreover, the behavior is shown to be sub-optimal in some situations where humans would, in principle, be able to perform better if deviating from their default strategy. Since machine learning models are trained by optimizing parameters for the task at hand, it is far from obvious whether they learn a similarly stable default mechanism, or instead follow a potentially superior adaptive strategy depending on the situation. While the latter is likely more efficient in solving at least a narrowly defined task, the former would instead suggest that the system is able to acquire and utilize core concepts like an approximate number system. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            575
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We may speculate about the innate preference of modern network architectures for either of the strategies: Most of the visual processing is based on convolutions which, being an inherently local computation, we assume would favor the pairing-based strategy via locally matching and ‘cancelling out’ entities of the two predicates. On the other hand, the tensors resulting from the sequence of convolution operations are globally fused into a final embedding vector, which in turn would support the more globally aggregating cardinality-based strategy. However, the type of computations and representations learned by deep neural networks are poorly understood, making such speculations fallacious. We thus emphasize again that the higher-level motivation for this paper is to demonstrate how we need not rely on such speculative ‘narratives’, but can experimentally substantiate our claims. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            756,
+            397,
+            772
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The setup in this paper closely resembles the psychological experiments conducted by Pietroski et al. (2009), but aimed at a state-of-the-art VQA model and its interpretation of “most”. ",
+        "bbox": [
+            173,
+            796,
+            823,
+            824
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Exactly two squares are yellow.   \n• Exactly no square is red.   \nMore than half the red shapes are squares.   \n• More than a third of the shapes are cyan.   \n• Less than half the shapes are green.   \n• Exactly all magenta shapes are squares.   \n• At most five shapes are magenta.   \n• At least one triangle is gray. ",
+        "bbox": [
+            281,
+            99,
+            486,
+            179
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/b7831eb3292ea0d291005dfe3cd6dea5b33ab6904aa03d8e75b8d3d39e98c08b.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            504,
+            102,
+            602,
+            178
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/53d50c1372a6d57ab37ab67c617cc4c17737075607b09eca25ab94c0e2fb8b22.jpg",
+        "image_caption": [
+            "Figure 2: Two example images with four in-/correct captions each, taken from the Q-full dataset (all quantifier and number captions). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            102,
+            272,
+            178
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            609,
+            99,
+            825,
+            179
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 TRAINING AND EVALUATION DATA ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            250,
+            452,
+            263
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use the ShapeWorld framework (Kuhnle & Copestake, 2017) as starting point to generate appropriate data. ShapeWorld is a configurable generation system for abstract, visually grounded language data. A data point consists of an image, an accompanying caption, and an agreement value indicating whether the caption is true given the image. The underlying task, image caption agreement, essentially corresponds to yes/no questions and as such is a type of visual question answering. Internally, the system samples an abstract world description from which a semantic caption representation is extracted. Both are then turned into ‘natural’ (but still abstract) representations as image and natural language statement, respectively. The latter transformation is based on a semantic grammar formalism (see their paper for details). ",
+        "bbox": [
+            174,
+            277,
+            825,
+            404
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use the pre-implemented quantifier captioner component, both in its unrestricted version and one with available quantifiers restricted to “more than half” and “less than half”3. The former contains various additional (generalized) quantifiers (“no”, “a/three quarter(s)”, “a/two third(s)”, “all”) and numbers (ranging from “zero” to “five”), each in combination with a comparing modifier (“less than”, “at most”, “exactly”, “at least”, “more than”, “not”). We refer to the unrestricted version as Q-full, the other one as Q-half. Figure 2 shows two images together with potential Q-full captions. ",
+        "bbox": [
+            174,
+            410,
+            825,
+            507
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We also use the default world generator to produce training data (up to 15 randomly positioned objects, as seen in figure 2). However, all of the pre-implemented generator modules are too generic for our evaluation purposes, since they do not allow to control attributes and positioning of objects to the desired degree. We thus implemented our own custom generator module with the following functionality to produce test data. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            584
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Attribute contrast: For each instance, either the attribute ‘shape’ or ‘color’ is picked4, and subsequently two values for this attribute and one value for the other is randomly chosen. This means that the only relevant difference between objects in every image is either one of two shape or color values (for instance, red vs blue squares, or red squares vs circles). ",
+        "bbox": [
+            174,
+            603,
+            823,
+            659
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Contrast ratios: A list of valid ratios between the contrasted attributes can be specified, from which one will randomly be chosen per instance. For instance, a ratio of 2:3 means that there are $50 \\%$ more objects with the second than the first attribute. We look at values close to 1:1, that is, 1:2, 2:3, 3:4, 4:5, etc. The increasing difficulty (for humans) resulting from closer ratios is illustrated in figure 3. Multiples of the smaller-valued ratios are also generated (e.g., 2:4 or 6:9), within the limit of up to 15 objects overall. ",
+        "bbox": [
+            173,
+            670,
+            825,
+            753
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Area-controlled: If this option is set, object sizes are not chosen uniformly across the entire valid range, but size ranges for the two contrasting object types are adapted to the given contrast ratio and size of the chosen shape(s), so that both attributes cover the same image area on average. This means that the more numerous attribute will generally be represented by smaller objects, and the difference in covered area between, for instance, squares and triangles is taken into account. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            847
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/687147eec990d42635eb5ad93cd1cd6969f03efed2811f813665a87c84a4e4ac.jpg",
+        "image_caption": [
+            "Figure 3: From left to right, the ratio between the two attributes is increasingly balanced. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            101,
+            807,
+            167
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While objects are still positioned randomly in the basic version of this new generator module, we define two modes which control this aspect as well. Figure 1 in the introduction illustrates the different modes. ",
+        "bbox": [
+            176,
+            223,
+            825,
+            265
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Partitioned positioning: An angle is randomly chosen for each image, and objects of the contrasting attributes are consistently placed either on one side or the other. ",
+        "bbox": [
+            173,
+            280,
+            821,
+            308
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Paired positioning: If there are objects of the contrasted attribute which are not yet paired, one of them is randomly chosen and the new object is placed next to it. ",
+        "bbox": [
+            174,
+            314,
+            821,
+            342
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The captions of these evaluation instances are always of the form “More/less than half the shapes are $X ^ { \\prime \\prime }$ . with $\" X '$ being the attribute in question, for instance, “squares” or “red”. Note that this is an even more constrained captioner than the one used for Q-half, since the subject is always fully underspecified as “shape”. We also emphasize that, in contrast to this new evaluation generator module, the default generator configuration of the ‘quantification’ dataset pre-specified in ShapeWorld is used to generate the training instances in Q-half and Q-full. So these images generally contain many more than just two contrasted attributes, and ratios between attributes tend to be accordingly smaller. The examples in figure 2 are chosen to illustrate this fact: the second example contains a “half” statement with ratio 7:8, and the first contains one about a 0:4 ratio, while the image would also allow for a more ‘interesting’ 3:4 ratio (color of semicircles). ",
+        "bbox": [
+            174,
+            357,
+            823,
+            496
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While we generally try to stay close to the experimental setup of Pietroski et al. (2009), in the following we point out some differences. Most importantly, instead of just using yellow and blue dots, we use all eight shapes and seven colors that ShapeWorld provides. This increases the visual variety of the instances and thus encourages the system to actually learn the fact that shape and color are attributes that can be combined in any way, instead of just straightforward binary pattern matching. Note that the humans in the psychological experiments have learned language in even more complex situations, which we cannot hope to approximate here. Moreover, our data does not contain yes/no questions but true/false captions, and “most”-equivalent phrasings “more/less than half”. Since the model is trained from scratch on such data, this should not affect results. ",
+        "bbox": [
+            174,
+            502,
+            823,
+            627
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We do not implement their ‘column pairs mixed/sorted’ modes since they would require comparatively big and mostly empty images, hence require bigger networks and might cause practical learning problems due to sparseness, which we do not want to address here. In contrast, our ‘partitioned’ mode is more difficult than the ones investigated by Pietroski et al. (2009), at least for a pairing-based mechanism. ",
+        "bbox": [
+            174,
+            635,
+            823,
+            704
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We will publish the generator configurations and custom generator modules required to reproduce the datasets we used here on acceptance of the paper. ",
+        "bbox": [
+            174,
+            712,
+            823,
+            739
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            758,
+            266,
+            772
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We focus on the FiLM model (Perez et al., 2018) here since it exhibited close-to-perfect accuracy on the CLEVR dataset (Johnson et al., 2017a), a diagnostic dataset for VQA which also consists of abstract images. We interpret the ShapeWorld captions and agreement values as questions and answer, respectively. The image is processed using either a pre-trained CNN or a four-layer CNN trained from scratch on the task. The question is processed by a GRU. In a sequence of four residual blocks, the image information is processed with its features linearly modulated (scale, offset) conditioned on the processed question embedding. Finally, the classifier module produces the answer, true or false. We use the code made available by the authors of the FiLM model, without changing any parameters. The only aspect we adapt is the trainable four-layer CNN, which uses a kernel size of 3, batch normalization and a stride of 2 in the second and fourth layer. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/89879fb5ba739ee5c3a88c305f87f6a8627ded0560b33bfe649f2f3acf3a9d87.jpg",
+        "image_caption": [
+            "Figure 4: Training performance (iterations in 1000). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            103,
+            736,
+            284
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We considered investigating other models as well: The $\\mathrm { P G + E E }$ model (Johnson et al., 2017b) is openly available and achieved very good performance on CLEVR, however, it relies on the ‘program tree’ provided by CLEVR, and while there exists a basic conversion of ShapeWorld caption models to CLEVR program trees, first, the CLEVR-specific modules do not cover quantifiers like “most” and, second, these program trees encode the interpretation strategy, which would defeat the purpose of our investigation to analyze precisely this mechanism as learned from data. The RelationNet architecture (Santoro et al., 2017) explicitly implements a pairing-based mechanism and hence we considered its evaluation less interesting than FiLM. For similar reasons, we did not focus on the VQA model of Zhang et al. (2018), whose architecture includes an explicit counting component. While our aim is to investigate the strategy for understanding “most” learned from data, it would be interesting to examine in both cases whether their architectural prior does indeed have the expected effect. Finally, we only learned about the MAC model (Hudson & Manning, 2018) after we started this project and so decided to leave it for future work, but we definitely consider it one of the most interesting candidate models to evaluate, since its architecture does not suggest an obvious preference for either strategy. ",
+        "bbox": [
+            173,
+            337,
+            825,
+            545
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            565,
+            348,
+            579
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The training set for both Q-full and Q-half consists of around $1 0 0 \\mathrm { k }$ $2 5 \\mathrm { x } 4 0 9 6 )$ images with 5 captions per image, so overall around 500k instances. The model is trained for 100k iterations with a batch size of 64. Training performance is measured on an additional validation set of 20k instances. Moreover, we produced 1024 instances for each of the overall 48 evaluation configurations, to investigate the trained model in more detail. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            662
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            688,
+            281,
+            704
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Training. We train two versions of the FiLM model, with CNN trained from scratch on the task: one on the Q-full dataset which contains all available quantifier and number caption types, the other on the Q-half dataset which is restricted to captions involving the quantifier “half” only. Performance of the system over the course of the $1 0 0 \\mathrm { k }$ training iterations is shown in figure 4. The two models, referred to by Q-full and Q-half below, learn to solve the task quasi-perfectly, with a final accuracy of $9 8 . 9 \\%$ and $9 9 . 4 \\%$ respectively. Not surprisingly, the system trained on the more diverse Q-full training set takes longer to reach this level of performance, but nevertheless plateaus after around 70k iterations. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the sake of completeness, we also include the performance of other models in this figure, which failed to show clear improvement over the first $5 0 \\mathrm { k }$ iterations. This includes the FiLM model with pre-trained instead of trainable CNN module (Q-full-pre, Q-half-pre), and an earlier trial on Q-half (Q-half-coll) where we did not constrain the data generation to not produce object collisions (the default in ShapeWorld is to allow up to $2 5 \\%$ area overlap). We note, however, that we have not done any hyperparameter search which might alleviate these learning problems. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/11ab05fda0e1d3b9c0576fd6b6051541c077e113dc8ed8b4d740d2210f4353b4.jpg",
+        "table_caption": [
+            "Figure 5: Accuracy (in $\\%$ ) of model trained on Q-full and Q-half for the various evaluation setups. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>train</td><td rowspan=2 colspan=1>mode</td><td rowspan=1 colspan=8>size-controlled</td><td rowspan=1 colspan=8>area-controlled</td></tr><tr><td rowspan=1 colspan=1>all</td><td rowspan=1 colspan=1>1:2</td><td rowspan=1 colspan=1>2:3</td><td rowspan=1 colspan=1>3:4</td><td rowspan=1 colspan=2>4:55:6</td><td rowspan=1 colspan=1>6:7</td><td rowspan=1 colspan=1>7:8</td><td rowspan=1 colspan=1>all</td><td rowspan=1 colspan=1>1:2</td><td rowspan=1 colspan=1>2:3</td><td rowspan=1 colspan=1>3:4</td><td rowspan=1 colspan=1>4:5</td><td rowspan=1 colspan=1>5:6</td><td rowspan=1 colspan=1>6:7</td><td rowspan=1 colspan=1>7:8</td></tr><tr><td rowspan=3 colspan=1>Q-full</td><td rowspan=3 colspan=1>randompairedpart.</td><td rowspan=3 colspan=1>929389</td><td rowspan=3 colspan=1>10099100</td><td rowspan=2 colspan=1>9999</td><td rowspan=1 colspan=1>97</td><td rowspan=1 colspan=2>94 91</td><td rowspan=1 colspan=1>88</td><td rowspan=1 colspan=1>85</td><td rowspan=1 colspan=1>93</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>97</td><td rowspan=1 colspan=1>93</td><td rowspan=1 colspan=1>91</td><td rowspan=1 colspan=1>86</td><td rowspan=1 colspan=1>82</td></tr><tr><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>93</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>88</td><td rowspan=1 colspan=1>82</td><td rowspan=1 colspan=1>93</td><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>91</td><td rowspan=1 colspan=1>87</td><td rowspan=1 colspan=1>84</td><td rowspan=1 colspan=1>80</td></tr><tr><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>92</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>81</td><td rowspan=1 colspan=1>77</td><td rowspan=1 colspan=1>72</td><td rowspan=1 colspan=1>89</td><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>98</td><td rowspan=1 colspan=1>92</td><td rowspan=1 colspan=1>88</td><td rowspan=1 colspan=1>82</td><td rowspan=1 colspan=1>78</td><td rowspan=1 colspan=1>72</td></tr><tr><td rowspan=3 colspan=1>Q-half</td><td rowspan=3 colspan=1>randompairedpart.</td><td rowspan=3 colspan=1>291</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>98</td><td rowspan=1 colspan=1>93</td><td rowspan=1 colspan=1>88</td><td rowspan=1 colspan=1>88</td><td rowspan=1 colspan=1>87</td><td rowspan=1 colspan=1>93</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>97</td><td rowspan=1 colspan=1>92</td><td rowspan=1 colspan=1>86</td><td rowspan=1 colspan=1>85</td><td rowspan=1 colspan=1>82</td></tr><tr><td rowspan=2 colspan=1>100100</td><td rowspan=2 colspan=1>10099</td><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>86</td><td rowspan=1 colspan=1>84</td><td rowspan=1 colspan=1>79</td><td rowspan=1 colspan=1>92</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>87</td><td rowspan=1 colspan=1>84</td><td rowspan=1 colspan=1>79</td><td rowspan=2 colspan=1>76</td></tr><tr><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=2>86 83</td><td rowspan=1 colspan=1>83</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>91</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>99</td><td rowspan=1 colspan=1>94</td><td rowspan=1 colspan=1>89</td><td rowspan=1 colspan=1>83</td><td rowspan=1 colspan=1>83</td></tr></table>",
+        "bbox": [
+            178,
+            137,
+            823,
+            232
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Evaluation. Table 5 presents a detailed breakdown of system performance on the evaluation settings. Before discussing the results in detail, we want to reiterate three key differences between the evaluation data and the training data: ",
+        "bbox": [
+            176,
+            258,
+            825,
+            300
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• The visual scenes here do all exhibit close-to-balanced contrast ratios, while this is not the case for the training instances.   \n• The evaluation scenes only contain objects of two different attribute pairs, and consequently the numbers to compare are generally greater than in the training instances, where more attributes are likely present in a scene. Q-full contains not just statements involving “half” – in fact, a random sample of 100 images / 500 captions suggests that they constitute only around $8 \\%$ of the dataset (and this includes combinations with modifiers beyond “more/less than”). ",
+        "bbox": [
+            215,
+            311,
+            825,
+            429
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Considering that, the relatively high accuracy on test instances throughout indicates a remarkable degree of generalization. ",
+        "bbox": [
+            176,
+            440,
+            823,
+            469
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "More balanced ratios. The most consistent effect is that more balanced ratios of contrasted attributes cause performance to decrease. This is certainly affected by the tendency of the training data to not include many examples of almost balanced ratios. However, if this were the only reason, one would expect a much more sudden and less uniformly linear decrease. More importantly, since Q-full generally contains fewer “half” statements, the decline should be more pronounced here. We do not observe either of these effects, and thus conclude that both models may actually have developed an approximate number system. This is further discussed at the end of this section. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            582
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Random vs paired vs partitioned. There is definitely a clear negative effect of the partitioned configuration on performance for the model trained on Q-full, which indicates that the learned mechanism is not robust to a high degree of per-attribute clustering. This does not indicate a preference for the pairing-based strategy, though, since both models perform best on the random configuration. While this suggests that there is neither a preference for the perfectly clustered partitioned nor for the perfectly mixed paired arrangement, we note that the effect is not strong, and that these instances are most similar to the random placement of objects in the training data, which might cause this effect. ",
+        "bbox": [
+            174,
+            597,
+            825,
+            695
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Size- vs area-controlled. The performance in both cases is comparable, showing that the models do not (solely) learn to rely on comparing the overall covered area, which would only work well in the size-controlled mode. Nevertheless, we note a tendency for area-controlled instances to be somewhat more difficult in random and paired mode, more so for Q-half, which suggests that the model(s) learn to use covered area as a feature to inform a correct decision in some cases. ",
+        "bbox": [
+            174,
+            710,
+            823,
+            781
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Q-full vs Q-half. There seems to be a tendency of the system trained on Q-full to perform marginally better, except for the partitioned mode discussed before. The fact that this model performs at least on a par with the one trained on Q-half, while only seeing a fraction of directly relevant training captions, indicates that the learning process is not ‘distracted’ by the variety of captions, and indeed might profit from it. ",
+        "bbox": [
+            174,
+            796,
+            823,
+            866
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ratios and Weber fraction. We generated evaluation sets of even more balanced ratios (8:9, 9:10, 10:11, increasing the overall number of objects accordingly to 17/19/21), and in figure 6 plotted the accuracy of the Q-full model on increasingly balanced sets for all three spatial configuration modes, not controlling for area (which for greater numbers only has a negligible effect anyway). The figure also contains a diagram with accuracy plotted against ratio fraction, which is more common in the context of Weber’s law. The characteristic Weber fraction can be read off directly as the ratio at which a subject is able to distinguish two values with $7 5 \\%$ accuracy. We observe around 1.11 for random/paired and 1.16 for partitioned, which corresponds to 9:10 and 6:7 as closest integer ratios. These values are in the same region as the average human Weber fraction, which is often reported as being 1.14, or 7:8. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/76fe8e687a29bca0dd010d7ae8e942658d2596c8cb334aeaf19eaa0d9b11dd61.jpg",
+        "image_caption": [
+            "Figure 6: (Left) Q-full model performance for increasingly balanced ratios ( $\\mathbf { \\bar { X } }$ -axis: ratio as $\\mathrm { n m } { + 1 }$ ). (Right) Performance as a function of actual ratio fraction $\\mathrm { n } { + } 1 / \\mathrm { n }$ , with Weber fractions $( 7 5 \\% )$ highlighted and the corresponding idealized model Weber curves indicated. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            103,
+            800,
+            267
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            352,
+            825,
+            450
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We emphasize that these curves align well with the trend predicted by Weber’s law, even for the ratios with more than 15 objects overall, where such situations have never been encountered during training. All this strongly suggests that the model learns a mechanism similar to an ANS, which is able to produce representations that can (at least) be utilized for identifying the more numerous set. It can in particular be concluded that the system does not actually learn to explicitly count, since we would then not expect to observe such fuzziness characteristic to an ANS. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            540
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Moreover, since performance is affected somewhat by the partitioned and the area-controlled modes, the interpretation of “most” seems to be informed by other features as well. As we noted earlier, since the model is trained to optimize this task, an adaptive strategy is not unexpected. On the contrary, more surprising is the fact that an ANS-like system emerges as a dominating ‘backbone’ mechanism, with additional factors acting as less influential ‘secondary’ features. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            617
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            640,
+            339,
+            656
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Visual question answering (VQA) is the general task of answering questions about visual scenes. Since the introduction of the VQA Dataset (Antol et al., 2015), this dataset was widely used as evaluation benchmark for multimodal deep learning. It provides a shallow categorization of questions, including basic count questions, however, these categories are far too coarse for our purposes. ",
+        "bbox": [
+            174,
+            672,
+            823,
+            728
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Motivated by various problems with the VQA Dataset (Goyal et al., 2017; Agrawal et al., 2016), a range of artificial abstract datasets have been introduced recently. CLEVR (Johnson et al., 2017a) consists of rendered images of geometric objects and questions generated based on templates, covering some abilities like number or attribute comparison in more detail, but still in a fixed categorization. NLVR (Suhr et al., 2017) contains crowdsourced statements about abstract images, but does not sort them according to some criteria. Recently, the COG dataset (Yang et al., 2018) was introduced, which most explicitly focuses on replicating psychological experiments for deep learning models, hence most related to our work. However, their dataset does not contain any number or quantifier statements. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            861
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "There is some work on investigating deep neural networks which look at numerosity from a more psychologically inspired viewpoint. Stoianov & Zorzi (2012) find that visual numerosity emerges from unsupervised learning on abstract image data. Zhang et al. (2015) look at salient object subitizing in real-world images, formulated as a classification task over five classes ranging from $\\cdot _ { 0 } \\cdot \\mathrm { \\ }$ to $^ { \\bullet } 4$ or more’. In a more general number-per-category classification setup, Chattopadhyay et al. (2017) investigate different methods of obtaining counts per object category, one of them inspired by subitizing. Moving beyond explicit number classification, Zhang et al. (2018) recently introduced a dedicated counting module for visual question answering. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Other work looks at a similar classification task, but for proper quantifiers like “no”, “few”, “most”, “all”, first on abstract images of circles (Sorodoc et al., 2016), then on natural scenes (Sorodoc et al., 2018). Recently, Pezzelle et al. (2018) investigated a hierarchy of quantifier-related classification abilities, from comparatives via quantifiers like the ones above to fine-grained proportions. Wu et al. (2018), besides investigating precise numerosity via number classification as above, also look at approximate numerosity as binary greater/smaller decision, which closely corresponds to our experiments. However, their focus is on the subitizing ability, not the approximate number system, and their experiments follow a different methodology in that they already train models on specifically designed datasets, while we deliberately leverage such targeted data only for evaluation. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            291
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "On a methodological level, our proposal of inspiring experimental setup and evaluation practice for deep learning by cognitive psychology is in line with that of Ritter et al. (2017) and their shape bias investigation for modern vision architectures. ",
+        "bbox": [
+            174,
+            299,
+            825,
+            340
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            359,
+            318,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We identify two strategies of algorithmically interpreting “most” in a visual context, with different implications on cognitive concepts. Following experimental practice of similar investigations with humans in psycholinguistics, we design experiments and data to shed light on the question whether the state-of-the-art FiLM VQA model shows preference for one strategy over the other. Performance on various specifically designed instances does indeed indicate that a form of approximate number system is learned, which generalizes to more difficult scenes as predicted by Weber’s law. The results further suggest that additional features influence the interpretation process, which are affected by the spatial arrangement and relative size of objects in a scene. There are many opportunities for future work from here, from strengthening the finding of an approximate number system and further analyzing confounding factors, to investigating the relation to more explicit counting tasks, to extending the evaluation to other visual question answering models which also exhibit good performance on related tasks (Hudson & Manning, 2018; Zhang et al., 2018; Santoro et al., 2017). ",
+        "bbox": [
+            174,
+            390,
+            825,
+            558
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            578,
+            285,
+            592
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aishwarya Agrawal, Dhruv Batra, and Devi Parikh. Analyzing the behavior of visual question answering models. In Proceedings of the Conference on Empirical Methods in Natural Language Processing, EMNLP 2016, pp. 1955–1960, 2016.   \nStanislaw Antol, Aishwarya Agrawal, Jiasen Lu, Margaret Mitchell, Dhruv Batra, C. Lawrence Zitnick, and Devi Parikh. VQA: Visual question answering. In Proceedings of the IEEE International Conference on Computer Vision, ICCV 2015, 2015.   \nPrithvijit Chattopadhyay, Ramakrishna Vedantam, Ramprasaath R. Selvaraju, Dhruv Batra, and Devi Parikh. Counting everyday objects in everyday scenes. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2017, pp. 4428–4437, 2017.   \nFelix A. Gers and Jurgen Schmidhuber. LSTM recurrent networks learn simple context-free and ¨ context-sensitive languages. Transactions on Neural Networks, 12(6):1333–1340, 2001.   \nYash Goyal, Tejas Khot, Douglas Summers-Stay, Dhruv Batra, and Devi Parikh. Making the V in VQA matter: Elevating the role of image understanding in Visual Question Answering. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2017, pp. 6325–6334, 2017.   \nMartin Hackl. On the grammar and processing of proportional quantifiers: most versus more than half. Natural Language Semantics, 17(1):63–98, 2009.   \nDrew A. Hudson and Christopher D. Manning. Compositional attention networks for machine reasoning. In Proceedings of the International Conference on Learning Representations, ICLR 2018, 2018. ",
+        "bbox": [
+            169,
+            599,
+            826,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C. Lawrence Zitnick, and Ross Girshick. CLEVR: A diagnostic dataset for compositional language and elementary visual reasoning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2017, 2017a. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Judy Hoffman, Li Fei-Fei, C Lawrence Zitnick, and Ross Girshick. Inferring and executing programs for visual reasoning. In Proceedings of the IEEE International Conference on Computer Vision, ICCV 2017, 2017b. ",
+        "bbox": [
+            173,
+            167,
+            821,
+            210
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexander Kuhnle and Ann Copestake. ShapeWorld - A new test methodology for multimodal language understanding. ArXiv e-prints 1704.04517, 2017. ",
+        "bbox": [
+            173,
+            218,
+            820,
+            248
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Lidz, Paul Pietroski, Justin Halberda, and Tim Hunter. Interface transparency and the psychosemantics of most. Natural Language Semantics, 19(3):227–256, 2011. ",
+        "bbox": [
+            174,
+            256,
+            821,
+            285
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ethan Perez, Florian Strub, Harm de Vries, Vincent Dumoulin, and Aaron C. Courville. FiLM: Visual reasoning with a general conditioning layer. In AAAI, 2018. ",
+        "bbox": [
+            173,
+            292,
+            821,
+            323
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sandro Pezzelle, Ionut-Teodor Sorodoc, and Raffaella Bernardi. Comparatives, quantifiers, proportions: A multi-task model for the learning of quantities from vision. In Proceedings of the Conference of the North American Chapter of the Association for Computational Linguistics, NAACL 2018, 2018. ",
+        "bbox": [
+            174,
+            330,
+            826,
+            387
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Paul Pietroski, Jeffrey Lidz, Tim Hunter, and Justin Halberda. The meaning of ’most’: Semantics, numerosity and psychology. Mind and Language, 24(5):554–585, 2009. ",
+        "bbox": [
+            173,
+            395,
+            823,
+            425
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Samuel Ritter, David G. T. Barrett, Adam Santoro, and Matt M. Botvinick. Cognitive psychology for deep neural networks: A shape bias case study. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, pp. 2940–2949, 2017. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            476
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Santoro, David Raposo, David G. T. Barrett, Mateusz Malinowski, Razvan Pascanu, Peter Battaglia, and Timothy P. Lillicrap. A simple neural network module for relational reasoning. In Proceedings of the Annual Conference on Neural Information Processing Systems, NIPS 2017, pp. 4974–4983, 2017. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            540
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ionut Sorodoc, Angeliki Lazaridou, Gemma Boleda, Aurelie Herbelot, Sandro Pezzelle, and Raf- ´ faella Bernardi. “Look, some green circles!”: Learning to quantify from images. In Proceedings of the 5th Workshop on Vision and Language, Berlin, Germany, 2016. ",
+        "bbox": [
+            173,
+            547,
+            825,
+            592
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ionut Sorodoc, Sandro Pezzelle, Aurelie Herbelot, Mariella Dimiccoli, and Raffaella Bernardi.´ Learning quantification from images: A structured neural architecture. Natural Language Engineering, pp. 130, 2018. ",
+        "bbox": [
+            173,
+            599,
+            823,
+            642
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ivilin Stoianov and Marco Zorzi. Emergence of a ‘visual number sense’ in hierarchical generative models. Nature Neuroscience, 15(194):194–196, 2012. ",
+        "bbox": [
+            166,
+            651,
+            825,
+            680
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alane Suhr, Mike Lewis, James Yeh, and Yoav Artzi. A corpus of natural language for visual reasoning. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, 2017. ",
+        "bbox": [
+            173,
+            688,
+            823,
+            731
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiaolin Wu, Xi Zhang, and Xiao Shu. On numerosity of deep convolutional neural networks. ArXiv e-prints 1802.05160, 2018. ",
+        "bbox": [
+            171,
+            738,
+            825,
+            768
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guangyu Robert Yang, Igor Ganichev, Xiao-Jing Wang, Jonathon Shlens, and David Sussillo. A dataset and architecture for visual reasoning with a working memory. ArXiv e-prints 1803.06092, 2018. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            819
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jianming Zhang, Shuga Ma, Mehrnoosh Sameki, Stan Sclaroff, Margrit Betke, Zhe Lin, Xiaohui Shen, Brian Price, and Radom´ır Mech. Salient object subitizing. In ˇ Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2015, 2015. ",
+        "bbox": [
+            176,
+            827,
+            823,
+            871
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yan Zhang, Jonathon Hare, and Adam Prugel-Bennett. Learning to count objects in natural im- ¨ ages for visual question answering. In Proceedings of the International Conference on Learning Representations, ICLR 2018, 2018. ",
+        "bbox": [
+            178,
+            878,
+            821,
+            921
+        ],
+        "page_idx": 10
+    }
+]

parse/train/rket4i0qtX/rket4i0qtX_middle.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/rket4i0qtX/rket4i0qtX_model.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/yqj6q_eNTJd/yqj6q_eNTJd.md ADDED Viewed

	@@ -0,0 +1,636 @@

+# ActCooLR – High-Level Learning Rate Schedules using Activation Pattern Temperature
+Anonymous Author(s)
+Affiliation
+Address
+email
+# Abstract
+1 We consider the aspect of learning rate (LR-)scheduling in neural networks, which
+2 often significantly affects achievable training time and generalization performance.
+3 Although schedules such as $^ { l }$ -cycle offer substantial gains over base-line methods,
+4 the effect of LR-curves on the training process is not very well understood. In order
+5 to gain more insight into the training process, we combine information theoretic
+6 ideas and probabilistic optimization, namely simulated annealing. In more detail,
+7 we introduce the activation pattern temperature, which (i) captures changes in the
+8 non-linear behavior of ReLU networks and (ii) is free of hyperparameters and thus
+9 is more interpretable. Examining the training process, 1-cycle simply yields a linear
+10 decrease in temperature, reminiscent of successful cooling strategies in simulated
+11 annealing. In order to test a causal connection, we devise ActCooLR, an automatic
+12 LR-scheduler that produces declining temperature profiles. In experiments with
+13 various CNN architectures and different image classification data sets, we obtain
+14 results that perform favorably or exceed the performance of hand-tuned schedules.
+# 15 1 Introduction
+16 Despite the huge success of deep networks, their training dynamics is still ground for many discussions.
+17 Above all, the reason for the good performance of such a simple algorithm as Stochastic Gradient
+18 Descent (SGD) remains an open question. As stated by Bengio [4], the learning rate (LR) of SGD is
+19 “[t]he single most important hyperparameter and one should always make sure that has been tuned”.
+20 It is considered to steer the amount of noise that regularizes the optimization [6; 22]. Research spans
+21 from practical recommendations, such as best practice learning rate schedules of distinct forms [4]
+22 to theoretical models that unveil the implicit regularization of SGD that depends on the learning
+23 rate [2; 46]. For instance, many training procedures include a warm up phase into the learning rate
+24 schedules to adapt training to numerical limitations as well as the distinct behavior of the initial
+25 training phase compared to the rest of training [14; 15; 36]. Recent studies divide the whole training
+26 process into phases of distinct characteristics. Nevertheless, the number of regimes or phases is still
+27 under discussion, most commonly described as two or three phases ([13; 29; 31; 32; 39]). A broad
+28 variety of work introduce sharpness based measures that give mathematical characterizations of the
+29 loss landscape promising a deeper understanding of the phases, trainability and generalization of deep
+30 networks [24]. However, these typically either introduce hyperparameters themselves or describe
+31 only a subspace of optimization directions.
+32 In this paper, we are trying to understand the effect of varying learning rates on the training process
+33 better. As a central tool, we propose a new measure of learning progress, activation pattern temper
+34 ature (APT). The key idea is to focus on the “hard” part of optimization, which is the fitting of a
+35 non-linear function. We therefore measure changes not by step-size in parameter space but counting
+36 changes in activation patterns, i.e., testing if the decomposition of feature maps into piecewise
+37 linear regions changes. Due to its independence of changes to the linear mappings, the measure is,
+38 unlike the original LR and other simple differential measures in parameter space, more stable under
+39 reparametrization.
+40 Through the lens of this measure we analyze the training of convolutional neural networks on image
+41 classification tasks using several LR schedules (Section 3.2) and find that the commonly used $^ { l }$ -cycle
+42 scheduler [45] has a very simple behavior, namely an approximately linear decrease during training.
+43 It also provides some additional insights into the training dynamic, such as connections between
+44 temperature and generalization behavior, and a visualization of phase-boundaries for different learning
+45 rates.
+46 Using the analysis, we present a method that adapts the learning rate automatically to match a user
+47 specified target temperature profile throughout training. Effective profiles start at high temperature
+48 and decrease monotonically until the activation patterns do not change anymore and optimization
+49 becomes purely linear. Correspondingly, we name our method ActCooLR. As our method matches
+50 the performance of previously hand-tuned learning rate schedules in our experiments, it could be
+51 considered as a candidate for an effective and efficient, hyper-parameter free automatic LR-scheduler.
+52 The computational overhead is moderate , with only one additional forward-pass.
+53 In summary, our main contributions are (i) the introduction of the activation pattern temperature,
+54 which reveals a more uniform view of the effect of LR-scheduling on training and (ii), based on
+55 this, an automatic learning rate scheduler that provides accuracy for short training times in a fully
+56 automatic way.
+# 57 2 Related Work
+Driven by the goal to better understand generalization, the training process of deep network training has been analyzed in a large body of work. We would structure the background as follows:
+60 Training Phases: One approach of understanding the training process is to describe it in different
+61 phases. An early variant of this idea is the work of Bengio et al. [5], who showed that increasing
+62 the intrinsic complexity of data during training can help to improve generalization performance.
+63 Several studies identify two training phases: the network trains low-frequency features first, yielding
+64 low generalization error and continues to learn high-frequency features in a second training phase
+65 that is more susceptible to overfitting [42; 26]. Similar observations have been made in studies
+66 that also take the effect of the learning rate into account [29; 31; 32]. A more recent study stated
+67 that their “experiments suggest that this [(two training phases)] is not the complete picture” [39].
+68 Others show evidence of three instead of two training phases [13; 31]. However, there appears to
+69 be consensus in literature that at the beginning of the training, the activations of a network mainly
+70 perform a random walk [13; 20]. More practically, increasing the randomness has been shown to
+71 even improve performance (see e.g. [40; 54]), having dropout as a more prominent example [47].
+72 The other widely accepted fact relates to the end of training, where momentum becomes increasingly
+73 important [29] as gradients directions simplify [16] and the loss landscape flattens [2]. Hoffer et al.
+74 [20] have shown that this comes from the loss landscape getting smoother the farther the weights
+75 travel from initialization. More recently, mode connectivity has been used as a tool to check whether
+76 a modification in the training process leads to distinct optimization trajectories in the loss landscape
+77 and its found minima [14; 23].
+78 Measures: There are several studies on the correlation between complexity- and norm-based mea
+79 sures [24]. In particular, generalization improvements from flatness of the loss landscape has been
+80 discussed both affirmatively and negatively [11; 46]. Nevertheless, sharpness or curvature based
+81 methods have been utilized to improve generalization in practice [10; 12]. Numerous work have
+82 included additional regularization into the training process. The angle between the momentum vector
+83 and the local gradient has been utilized to construct a statistical test to determine convergence [28].
+84 The value and statistics of the loss have also been used for regularization during training, either by
+85 relaxing the softmax loss [37] or by adapting the gradients in order to make constant progress on the
+86 loss [43]. Lastly, Raghu et al. [41] proposed a method to measure the layer-wise complexity of a
+87 network by computing the Singular Value Decomposition of the activations. This method is similar in
+88 spirit to ours, but it measures the intrinsic dimensions in a stationary fashion, excluding the training
+89 process in the measure itself. In contrast to competing measures, our measure is hyperparameter-free
+90 and does not depend on the setting it is evaluated in. It avoids the complexity of rescaling due to
+91 surrounding layers, which plague many continuous measures, by solely focusing on the discrete
+92 activations of a ReLU network.
+93 Hyperparameter Schedules: Hyperparameter choice has a strong effect on (generalization) perfor
+94 mance and convergence speed. Economically, under fixed training budgets, this leads to a trade-off
+95 [8; 49]. In cases of small batch sizes, one crucial invariant control parameter has been shown to be the
+96 ratio of learning rate and batch size [15; 20]. SGD has been shown to have an implicit bias towards
+97 flat regions theoretically that is reinforced by high learning rates [2; 46]. There is strong empirical
+98 evidence that large initial learning rates can help with generalization in over-parameterized networks
+99 [31; 32]. However, large networks require a “warm up” phase to prevent divergence of deeper layers
+100 [14]. While most schedules let the learning rate approach zero with training time, especially the
+101 course of the learning rate in the middle of the training process has not yet been analyzed extensively.
+102 Our model suggest here an analogy to annealing schemes in discrete stochastic optimization and
+103 provides a holistic perspective on the whole training process. LR scheduling is considered to be
+104 directly linked to generalization performance [20; 22; 24; 29; 32]. For instance, a cyclic schedule
+105 enables to train networks with a good “anytime performance” [34] and the implicit learning rate
+106 schedules that are built into adaptive optimizers such as Adam [27] are topic of current research
+107 [1; 36]. However, specific research in learning rate schedules is sparse. Although, correctly tuned,
+108 1-cycle achieves the same accuracy using order-of-magnitude fewer training iterations [45], “large
+109 models in NLP and vision use schedules which can be easily resumed” [30], such as “clipped” cosine
+110 decay [7] or exponential decay [48]. Recently, research in automatic and adaptive hyperparameter
+111 tuning has become more prominent. For instance, automatic tuning of decay time for the exponential
+112 decay schedule, [28; 30], and meta-networks designed to predict the learning rate based on learned
+113 typical training courses ([21], or more specifically, [9; 51]) have been tested. Another approach
+114 includes the learning rate into the optimization process by deriving the loss w.r.t. the learning rate
+115 as well [3]. Lastly, weight decay has been focus of discussion related generalization gap between
+116 SGD and adaptive optimizers [35; 49]. Also, it has been shown to affect the learning rate scheduling
+117 directly when used in conjunction with batch norm: every weight decay step increases the effective
+118 learning rate by a multiplicative factor for a constant learning rate schedule [33; 52]. The most similar
+119 of the named methods to ours from an optimization perspective is probably that of de Roos et al.
+120 [10], where successive training steps are used to estimate change of curvature of the loss function to
+121 adapt the learning rate automatically; however it requires additional hyperparameters and continuous
+122 re-evaluations of the batch-loss.
+# 123 3 Activation Pattern Temperature (APT)
+124 We base our approach on the view that non-linearity is what makes deep networks actually expressive.
+125 Throughout this paper, we restrict ourselves to the non-linear aspects of training and study (the
+126 popular) ReLU activation function [38], which switches binarily between two linear states. Non
+127 linearity of whole networks is thus encoded in the way the network is switching between those discrete
+128 states in an orchestrated way. We call these binary patterns assigned to data “activation patterns”.
+129 Our idea is very simple: We track the change of activation patterns, by comparing corresponding
+130 outputs of ReLU layers for the same input data, and use the neg-log-likelihood of these changes to
+131 quantify the “step-size” of the training progress.
+# 3.1 Formal Definition of APT
+Formally, we consider a feed-forward ReLU network $F _ { \theta } ^ { L }$ with parameters $\theta$ , that contains $L$ activation layers. Further, let $f ^ { l } ( x ) \in \mathbb { R } ^ { d _ { l } }$ denote the output of such a layer $l \in \{ 1 , . . . , L \}$ , for an input batch $\boldsymbol { x } \in \mathbb { R } ^ { B \times d _ { 0 } }$ of batch-size $B$ .
+136 We now define the activation pattern for (ReLU) layer $l$ as
+$$
+M _ { \theta } ^ { l } ( x ) : = \left( \mathrm { s i g n } \left( f ^ { l } ( x ) \right) \right) ( x ) \in \{ 0 , 1 \} ^ { d _ { l } } ,
+$$
+137 which can be seen as a bit-vector of ReLU activated neurons.
+138 Training: Training is performed in discrete steps $t = 0 , 1 , 2 , \ldots$ At each step, an input batch $x$
+139 is considered and the optimizer computes new parameters $\theta _ { t }$ . $\theta _ { 0 }$ is determined by the network’s
+140 initialization, and
+$$
+\theta _ { t + 1 } = \theta _ { t } + \lambda _ { t } \nabla _ { \theta _ { t } } L ( F _ { \theta _ { t } } ^ { L } , x _ { t } )
+$$
+141 is the update by a single optimization step for batch $x$ under loss $L$ (which, we assume, is informed
+142 of the ground-truth outputs $y ( x )$ ).
+143 In this context, the incremental updates to $\theta _ { t }$ from randomly drawn batches $x _ { t }$ make the temporal
+144 sequence $( \theta _ { 0 } , \theta _ { 1 } , \theta _ { 2 } , \ldots )$ a Markov chain; the same holds for the sequence of activation patterns
+145 $M _ { \theta _ { t } } ^ { l } ( x )$ over time $t$ . Additionally, we model the effect of one optimization step on the activation
+146 patters as a Markov chain,
+$$
+( X , Y ) \xrightarrow [ \theta _ { \varepsilon  \theta _ { t }  \theta _ { t }  \iota _ { \nabla _ { \theta _ { t } } \sum _ { j } \varepsilon _ { 0 } r _ { i } \gamma _ { j } } ] } { \xrightarrow [ { \mathrm { N e t w o r k ~ E v a l u a t i o n } } ] { \mathrm { N e t w o r k ~ } } } ( M _ { \theta _ { t + 1 } } ^ { 1 } , \dots , M _ { \theta _ { t } } ^ { L } ) \xrightarrow [ ] { \mathrm { N e t w o r k ~ } } ( T _ { t } ^ { 1 } , \dots , T _ { t } ^ { L } )
+$$
+147 where $X$ denotes the random variables that chooses examples from any distribution, $Y$ describes its
+148 true underlying information that we are interested in, and $\mathbf { \dot { \nabla } } T _ { t } ^ { l }$ the change in activation patterns. Each
+149 stochastic process, symbolized by an arrow, optionally adds uncorrelated noise to the mapping.
+150 Definition: We now define the activation pattern temperature $( A P T )$ on layer $l$ as the self-information
+151 of the event that an activation pattern has not changed,
+$$
+T _ { t } ^ { l } ( x ) : = - \log _ { 2 } \left( \mathrm { P r } \left( M _ { \theta _ { t + 1 } } ^ { l } ( x ) = M _ { \theta _ { t } } ^ { l } ( x ) \right) \right) ,
+$$
+152 where $\mathrm { P r }$ denotes the probability distribution.1 This estimates the probability of an activation pattern
+153 change over the batch $x$ . We also define the average activation pattern temperature $T _ { t }$ as the average
+154 of $T _ { t } ^ { \tilde { l } }$ over all (ReLU) layers of the network. This measure is parameter-free and specifies the amount
+155 of non-linear change in a network. Its lower bound is 0, stating that no non-linear change occurred
+156 and only the linear parts of the network could have been changed during that step. The temperature
+157 approaches infinity if all activations have changed during a single optimization step.
+158 Computation: To measure $\boldsymbol { T _ { t } ^ { l } }$ , we run the forward-pass of a network twice, recording the activation
+159 patterns in the first pass and comparing and accumulating changes in the second. In experiments,
+160 we observe that evaluation on a single training batch already give good estimates. Thus, we use the
+161 single-batch estimate of APT in the rest of the paper, unless stated otherwise. This allows the measure
+162 to be calculated at the cost of only one single additional forward pass of the same batch that has been
+163 already used for the previous optimization step.
+# 164 3.2 Training Methods & their Training Dynamics
+165 In this section, we utilize the activation pattern temperature (APT) (Equation (4)) to gain more insight
+166 into the non-linear training dynamics affected by the choice of learning rate schedules. As a baseline
+167 experiment, we compare the training of ResNet-32 (CIFAR-Variant, [19]) trained on CIFAR-10
+168 with step decay learning rate schedule. 2 We study the effect of three modifications to the ResNet
+169 Architecture: ResNet with removed shortcut connections, FixUp [53] (no batch normalization) and
+170 Pyramid-Net [17] (linear growing number of filters). In Figure 1, we show the learning rate (top row),
+171 the corresponding activation temperature of the first layer $\mathsf { \bar { f } } ^ { 1 }$ (middle row), and the Top-1 validation
+172 error (bottom row) for the baseline experiment. In the following, we analyze these plots regarding
+173 their temperature profiles, training time and generalization performance.
+APT simplified learning rate description: During the training process, APT reflects changes of the LR (APT is reduced, whenever LR is reduced). APT starts strictly greater than zero, the actual value depends on the architecture as well as the training hyperparameters, and, during the training process, APT is reduced and approaches zero. Most importantly, 1-cycle schedule (blue curves), shows approximately a linear decrease of APT.
+Temperature cools down bottom-to-top: Defined as a per-layer temperature, we discuss the APT on a per-layer basis in the APPENDIX. We observe that deeper layers have a higher temperature (we call these hotter) in comparison to the first layers in a network (we call these cooler). Also, we
+![](images/be02063d82e8f03339d0fd9a40afa207f727fe8833c30e0c141be772005841ec.jpg)
+Figure 1: Learning Rates, Validation Accuracy & Temperatures of the first ReLU-Layer in ResNet-32 (and its Variants) on CIFAR-10 for different LR schedules.
+182 observe that in each network the activation pattern temperatures decreases (or “cools down”) from
+183 bottom to top, in accordance to recent work [41].
+APT possibly relates to generalization: On the other hand, we observe that the validation error has similarities to the APT profile, despite having no direct relation between the AT and the loss. In this setting, APT is proportional to the validation error. Architectural adaptions also affect performance, negatively (as ResNet in the absence of shortcut connections), and positively (FixUp and PyramidNet) have that characteristics.
+APT is not explained by learning rate alone: The temperature can change (decrease) despite a constant learning rate. This can be observed, for example, in all experiments of fig. 1(b), especially in the beginning of training, but also with every drop of the learning rate. We conclude: for a fixed setting, the course of APT is not steered by the magnitude of learning rate alone, and APT contains hidden variables responsible for its course.
+This is in comply with previous work that studied the early phase of training in more detail [13]. We think that this view could shed some light on the initial phase of training and possibly explains the requirement of using a warm-up schedule in common training schemes beyond numerical instabilities.
+# 3.3 Learning Rate Range Analysis
+In the following chapter, we want to study the connection between LR and APT. We do so by reevaluating the exact same update step with a fixed range of learning rates. This allows us to observe the training from a global LR-invariant perspective. In more detail, we carry out this experiment for two different architectures on different data sets, using two different LR schedules. First we train a ResNet-56 on ImageNet, and second a ResNet-50 on CIFAR-10. Both networks are trained using step decay (90 rep. 200 epochs) and 1-cycle scheduler (20 resp. 50 epochs) each. For the initialization and every epoch in training, we freeze the network and re-evaluate the temperature for the exact same range of learning rates. The learning rates we use are uniformly sampled on a log scale, ranging from $1 0 ^ { - 4 }$ to $\bar { 1 } 0 ^ { 2 }$ . The results are shown in Figure 2: The top row shows the average activation pattern temperature $T _ { t }$ for each network and for each LR schedule. The white lines indicate the learning rate, which actually has been used for training.3 The theoretical temperature is shown in the background as color gradient from black (cold) to yellow (hot). We observe, that after a short initialization phase the temperature has a rather homogeneous behavior
+![](images/2064de668a20d955dc6af7d00314ec10e3501792a29ca8e7f71da882a7b990b1.jpg)
+Figure 2: Learning Rate Range Analysis: For each point in training time of ResNet-50 on ImageNet (left two columns) and ResNet-56 on CIFAR-10 (right two columns) each with 1-cycle LR and step decay schedules, we measure the temperature for a theoretical scaling of the global LR ().
+211 over the whole training process. After few initial epochs, we observe only minor changes to the
+212 temperature profile. Furthermore, the temperature profiles of ResNet-56 (ImageNet) show a phase in
+213 which, from a global and LR-independent perspective, the networks cool down slowly, independently
+214 of the choice of learning rate. Most notably, 1-cycle schedule uses LRs in a higher temperature
+215 regime (near the vertex) for a longer period of time during training. In contrast, step decay passes
+216 through into the colder temperature regime very quickly (ResNet-56/ImageNet) or already stats in it
+217 (ResNet-50/CIFAR-10).
+# 3.4 Model of the Activation Pattern Temperature
+Typically, weight initialization is based on [18], which specifies the initial distribution of the weights in such a way that the output after the ReLU-activation is Gaussian distributed on all layers. As the activation itself zeros the output if the weighted sum of normal distributed variables is smaller than zero, we model the probability of a change in activation patterns itself as the cumulative distribution function of a normal distribution. Thus, we postulate the following closed form formula.
+Hypothesis 1. The probability of an activation pattern change depending on the used learning rate $\lambda$ for a single update step on any layer during training is given by
+$$
+\mathrm { P r } \left( M _ { \theta _ { t + \lambda \cdot \nabla L } } ^ { l } = M _ { \theta _ { t } } ^ { l } \right) = \frac { 1 } { 2 } \cdot \left( 1 + \mathrm { e r f } \left( \frac { \log \lambda - \mu } { \sigma \cdot \sqrt { 2 } } \right) \right) .
+$$
+226 The real numbers $\mu , \sigma \in \mathbb { R }$ depend on the training process, choice of architecture and layer.
+227 We show next that the model, given by Equation (5), actually fits in practice. In more detail, for a
+228 fixed network state, we fit the model using non-linear least squares to the data shown in Figure 2.
+229 We evaluate the fit by visualizing the the evaluated model together with its reconstruction error
+230 against ground truth in the second and third row of Figure 2. The estimated parameters $\mu$ and $\sigma$ of
+231 Equation (5) are shown in the bottom row of Figure 2. From our experience its values depends on the
+232 layer the temperature has been measured in, the data set and architecture used and varies also with
+233 the random seed of the initialization of weights.
+234 Most importantly, we could observe favorably only small drifts of the parameter $\sigma$ that defines the
+235 width of the Gaussian distribution used in the model. (But we also show an example of larger changes
+236 in the APPENDIX). In contrast, the course of $\mu$ seems to be especially affected by the learning rate
+237 used for training. We will use this observation and Equation (5) to define an automatic learning rate
+238 schedule in Section 4.
+# 239 4 Activation Cooling based Learning Rate Scheduler
+# 4.1 Optimization using ActCooLR
+The goal of the scheduler is to determine learning rates that impose a specified temperature profile. This has to be done online, adapting the learning rate $\lambda$ to the current network state. As a design decision, we have the option to measure temperatures at every layer, and using adaptive learning rates, even to specify them layer-wise. For simplicity we leave fine-grained adaptation for future work and generally operate with a global learning rate (similar to 1-cycle) and use the mean temperature over all layers for control.
+247 In order to determine the learning rate, we simply rearrange Equation (5) from Section 3.4, which
+248 describes the probability of a pattern change using only three parameters: $\sigma , \mu$ and $\lambda$ :
+$$
+\begin{array} { r l } & { \mu = \sigma \cdot \sqrt { 2 } \cdot \mathrm { e r f } ^ { - 1 } \left( 2 \cdot P _ { \lambda } - 1 \right) - \log \lambda , } \\ & { \lambda = \exp \left( \sigma \cdot \sqrt { 2 } \cdot \mathrm { e r f } ^ { - 1 } \left( 2 \cdot P _ { \lambda } - 1 \right) - \mu \right) , } \end{array}
+$$
+249 where $P _ { \lambda }$ denotes the probability given the used learning rate $\lambda$ .
+250 Thus, to derive the learning rate $\bar { \lambda }$ required to measure the target temperature $C$ , we first estimate $\mu$
+251 using the measured probability $P _ { \lambda }$ using the learning rate $\lambda$ Equation (6). Assuming that the value of
+252 $\mu$ and $\sigma$ only changes slowly (see Section 3.3) we can use Equation (7) to estimate the learning rate
+253 that would produce the given temperature $C$ . We call this learning rate adaption technique ActCooLR.
+254 Too reduce computational costs, we limit measuring and readjustments to once every 10 optimization
+255 steps. In between two measurements, we just interpolate linearly between the new and old learning
+256 rate. The computational overhead is thus moderate, in particular as only a forward pass is needed.
+257 Note, this requires to estimate $\sigma$ in the beginning of training. The value of $\mu$ can be estimated using
+258 the formulas given above. We show in the APPENDIX a dynamic version of this technique, that
+259 removes the requirement of estimating $\sigma$ and adapting the learning rate dynamically at the cost of
+260 additional hyperparameters. A numerical problem arises from temperatures living on a logarithmic
+261 scale (Section 3.4). Due to finite sampling, We might estimate a probability of 1 (all patterns have
+262 changed) by chance. According to Equation (5) this would correspond to an infinite learning rate.
+263 We remove the singularity by an ad-hoc regularizer: For empirical propabilities of 1, we assume that
+264 “half an activation has changed”, but was not measured.
+# 4.2 Designing Target Temperature Curves (CIFAR-10)
+66 Until now we moved the problem of choosing the learning rate curve with a more abstract problem;
+67 choosing the temperature curve. It is clear that we want to cool the mean temperature to a value
+68 of zero, specifying explicitly that the network shall converge. This temperature is trivially given
+69 by a learning rate of 0. We have seen that for sufficiently many data points it becomes increasingly
+70 hard to let the network change all patterns with a single optimization step, in the limit this becomes
+71 impossible.
+272 Many previous work has analyzed the positive effects of large initial learning rates (see Section 2
+273 for a discussion). A large initial learning rate corresponds directly to a larger temperature. Thus, we
+274 assume that we want to start training with a high temperature, i.e. a huge flow of information through
+275 the network with every optimization step, and end with a very low temperature (mostly only linear
+276 regression to be optimized). Empirically, we observed in the Section 3.2 that 1-cycle shows a linear
+277 decrease in temperature. Thus, we test next if a linear decrease in temperature accelerates training
+278 by actively controlling the temperature with ActCooLR. As a simple baseline experiment, to test
+279 against, we use, again, a ResNet-32 on CIFAR-10 and train it using ActCooLR and momentum SGD
+280 (see appendix the used Hyperparameters). To test our hypothesis, we define a family of temperature
+281 curves of the form
+$$
+C _ { \gamma } ^ { \mathrm { l i n e a r } } ( i , i _ { \mathrm { t o t a l } } , T _ { \mathrm { s t a r t } } ) : = T _ { \mathrm { s t a r t } } \cdot ( 1 - ( i / i _ { \mathrm { t o t a l } } ) ^ { \gamma } ) ,
+$$
+starting at $T _ { \mathrm { s t a r t } }$ and cooling down under a reduction factor $\gamma$ to 0.
+283 Figure 3 shows the effect of the selected target temperature curve $C _ { \underline { { { \gamma } } } } ^ { \mathrm { l i n e a r } }$ on the learning rate (Figure 3
+284 (middle row) and the validation error (Figure 3 (bottom row)). From our experience and also in
+285 comply with the observations made in Section 3.2, training generally longer on higher temperatures
+286 $( \gamma > 1 )$ ) achieves favorable performance compared to a faster reduction of temperature $( \gamma < 1 )$ ). In
+287 case of a too big $\gamma$ , the amount of time optimization takes place in a linear way only becomes short at
+288 the cost of a worse performance.
+289 We test in the following the same setting for varying number of epochs to show the stability of our
+290 method for various training budgets. For simplicity, we restrict the analysis to a linear temperature
+291 decay $( \gamma = 1 )$ ). In Figure 3(b), we show the disadvantage of our schedule: the validation error remains
+292 high for the most number of epochs during training, converging only very late compared to methods
+293 like cyclic learning rate or step decay (see Section 3.2). For instance, in contrast to a cyclic learning
+294 rate schedules, our method does not show a good anytime performance. On the one hand, cyclic
+295 temperatures could also work, but need to be evaluated separately, thus leaving this as topic of future
+296 research. We also show in the APPENDIX that our method is independent of the initial learning
+297 rate as long as the first few optimization steps do not lead to a diverged network. We believe that
+298 finding temperature curves with theoretical bounds is a promising direction for future work to better
+299 understand the internal effects. For the rest of our work, we use a linear temperature cool down.
+![](images/1f41f5bf1638ea5678f90f1a62d5031f5c947c6ca57d51301f81e6dd0c352816.jpg)
+Figure 3: Training ResNet-32 on CIFAR-10 using a linear target temperature curve and (a) using several values for $\gamma$ and (b) for varying number of epochs using a linear temperature curve each. We choose the same initial target temperature for all experiments to be 3.17 (i.e. a $8 9 \%$ chance that an activation has changed), all other hyperparameters, as well as seeds, are kept the same in each experiment set. Top row: measured mean temperature, Middle Row: resulting learning rates, bottom row corresponding top-1 validation error.
+# 4.3 Comparisons with other Methods
+301 Table 1 shows practical results on three different architectures (simple 4-layer CNN, VGG-16 and
+302 ResNet-50) on three different data sets (Fashion-MNIST, CIFAR-10, ImageNet). We compare to
+303 baselines and two automatic LR-schedulers (ABEL and AutoLRS). The experiments confirm that
+304 we reach, similar to our observations for 1-cycle, comparable generalization performance within a
+305 restricted training budget (Note though that ABEL uses 200 epochs, unlike the other methods). More
+306 results are provided in the APPENDIX.
+# 07 5 Discussion
+The key hypothesis of this paper is that tracking the changes to the nonlinear behavior only can provide us with the information needed for step-size control. Our experiments support this view (for image classification with feed-forward ReLU CNNs, which is the class of techniques we restrict our analysis to at this point). Specifically, performing a simple linear decrease in activation pattern temperature already yields a LR-scheduler with performance comparable to 1-cycle, and distorting the temperature curve towards staying longer in the high-temperature regime at the beginning appears to improve generalization performance slightly (at least for the training time scales examined).The
+Table 1: Comparison with previous automatic LR-schedulers
+<table><tr><td colspan="3">Setup</td><td colspan="2">Test error</td></tr><tr><td>Data set</td><td>Network</td><td>Epochs</td><td>Method</td><td>Top-1 Error</td></tr><tr><td>Fashion-MNIST</td><td>4-layer ：ConvNet [50]</td><td>200</td><td>constant LR</td><td>6.95%</td></tr><tr><td>Fashion-MNIST</td><td>4-layer ConvNet [50]</td><td>200</td><td>ActCooLR</td><td>7.29 %</td></tr><tr><td>CIFAR-10</td><td>VGG-16 [44]</td><td>350</td><td> step decay</td><td>6.30% [25]</td></tr><tr><td>CIFAR-10</td><td>VGG-16 [44]</td><td>350</td><td>AutoLRS</td><td>5.87%[25]</td></tr><tr><td>CIFAR-10</td><td>VGG-16 [44]</td><td>200</td><td>ABEL</td><td>7.1% [30]</td></tr><tr><td>CIFAR-10</td><td>VGG-16 [44]</td><td>350</td><td>ActCooLR</td><td>6.82 %</td></tr><tr><td>ImageNet</td><td>ResNet-50[]</td><td>20</td><td>1-cycle</td><td>27.27%</td></tr><tr><td>ImageNet</td><td>ResNet-50 [</td><td>20</td><td>ActCooLR</td><td>27.88%</td></tr></table>
+Table 2: Test errors for Fig. 3.
+<table><tr><td>Epochs</td><td>Test Error (Top-1)</td></tr><tr><td>10</td><td>37.88%</td></tr><tr><td>30</td><td>18.33%</td></tr><tr><td>50</td><td>11.87%</td></tr><tr><td>70</td><td>10.59%</td></tr><tr><td>90</td><td>9.09%</td></tr><tr><td>110</td><td>8.09%</td></tr><tr><td>130</td><td>7.50%</td></tr><tr><td>150</td><td>7.28%</td></tr><tr><td>170</td><td>7.18%</td></tr><tr><td></td><td>7.15%</td></tr><tr><td>190 210</td><td>6.41%</td></tr></table>
+315 simple Gaussian two-parameter model of Eq. 5 is approximates the temperature well empirically and
+316 leads to a simpler and more efficient automatic LR-scheduling algorithm than a direct optimization of
+317 the learning rate. The most important result is probably on the conceptual side: We observe that the
+318 rather complex LR-curve of a cyclic (or 1-cycle) scheduler appears to just correspond to an annealing
+319 of the APT. This is reminiscent of simulated annealing methods which use a very similar strategy in
+320 order to solve combinatorial optimization problems. The logarithmic temperature measure has an
+321 analogous form to the temperature in the Boltzmann-distribution of a Markov-Chain-Monte-Carlo
+322 (MCMC) optimizer used there. In this sense, our paper reveals that a good LR-scheduler for SGD just
+323 performs on the discrete, nonlinear network components a process very similar to simulated annealing.
+324 More concretely, we would like to point to the results in Fig. 2 which show a smooth transition
+325 between a linear training regime, with low probability of nonlinear changes and a high-temperature,
+326 presumably chaotic, regime at the high LRs. By controlling the APT, we can steer training within
+327 the band of non-linear, but not chaotic learning automatically, and only dive into the purely linear
+328 regime at the end, thereby plausibly obtaining a quicker convergence. The drop in temperature at
+329 early training steps is handled automatically, and provides a plausible explanation the utility of initial
+330 LW-ramp-up in 1-cycle. It is also interesting that the phase boundary drifts only slowly after this,
+331 with constant width, but depends more strongly on the LR-schedule (and data set) used.
+Limitations and future work: Our consequential findings are empirical; we do not have an analytical derivation of why the training process has the observed properties, or why the proposed temperature curves reach high performance levels. Our empirical observations are consistent over several data sets and rather different CNN architectures. Nonetheless, a broader study on a large corpus of models and architectures, as well as examining applications beyond image recognition and feed-forward CNNs, is an important next step for future work. Further, a predictive theoretical model of the statistical dynamics of activation patterns under parameter trajectories and exploring a closer connection of SGD and MCMC optimization would be interesting avenues for future work.
+# 340 Broader Impact
+341 From an application perspective, our paper aims at improvements in learning time scheduling, such
+342 that fast-training schedulers similar to 1-cycle can be used with little or no tuning of hyperparameters.
+343 To the extend of this being successful, we believe that this has a significant positive impact in
+344 saving time and (electrical) energy in the development and deployment of deep networks (aside
+345 from potential rebound effects applying to any improvement in efficiency). We advise the reader
+346 though to use caution in that our key findings are empirical in nature and there is no proof of absence
+347 of negative effects in terms of costs, and/or a random or systematic loss of accuracy (the same
+348 applies to related methods, too). The paper should be received as a step forward towards a more
+349 efficient automatic training schedules, not as a proven solution ready for wide deployment. We would
+350 correspondingly emphasize the impact of the conceptual view of tracking nonlinear optimization and
+351 the newly introduced techniques for implementing this over the practical aspects.
+352 References
+353 [1] N. Agarwal, R. Anil, E. Hazan, T. Koren, and C. Zhang. Disentangling adaptive gradient methods from
+354 learning rates. CoRR, abs/2002.11803, 2020. URL https://arxiv.org/abs/2002.11803.
+355 [2] D. G. T. Barrett and B. Dherin. Implicit gradient regularization. CoRR, abs/2009.11162, 2020. URL
+356 https://arxiv.org/abs/2009.11162.
+357 [3] A. G. Baydin, R. Cornish, D. Martínez-Rubio, M. Schmidt, and F. Wood. Online learning rate adaptation
+358 with hypergradient descent. In 6th International Conference on Learning Representations, ICLR 2018,
+359 Vancouver, BC, Canada, April 30 - May 3, 2018, Conference Track Proceedings. OpenReview.net, 2018.
+360 URL https://openreview.net/forum?id=BkrsAzWAb.
+361 [4] Y. Bengio. Practical recommendations for gradient-based training of deep architectures. In G. Montavon,
+362 G. B. Orr, and K. Müller, editors, Neural Networks: Tricks of the Trade - Second Edition, volume 7700 of
+363 Lecture Notes in Computer Science, pages 437–478. Springer, 2012. doi: 10.1007/978-3-642-35289-8\_26.
+364 URL https://doi.org/10.1007/978-3-642-35289-8_26.
+365 [5] Y. Bengio, J. Louradour, R. Collobert, and J. Weston. Curriculum learning. In A. P. Danyluk, L. Bottou,
+366 and M. L. Littman, editors, Proceedings of the 26th Annual International Conference on Machine Learning,
+367 ICML 2009, Montreal, Quebec, Canada, June 14-18, 2009, volume 382 of ACM International Conference
+368 Proceeding Series, pages 41–48. ACM, 2009. doi: 10.1145/1553374.1553380. URL https://doi.org/
+369 10.1145/1553374.1553380.
+370 [6] L. Bottou. Online learning and stochastic approximations. On-line learning in neural networks, 17(9):142,
+371 1998.
+372 [7] T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry,
+373 A. Askell, S. Agarwal, A. Herbert-Voss, G. Krueger, T. Henighan, R. Child, A. Ramesh, D. M. Ziegler,
+374 J. Wu, C. Winter, C. Hesse, M. Chen, E. Sigler, M. Litwin, S. Gray, B. Chess, J. Clark, C. Berner,
+375 S. McCandlish, A. Radford, I. Sutskever, and D. Amodei. Language models are few-shot learners. In
+376 H. Larochelle, M. Ranzato, R. Hadsell, M. Balcan, and H. Lin, editors, Advances in Neural Information
+377 Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS
+378 2020, December 6-12, 2020, virtual, 2020. URL https://proceedings.neurips.cc/paper/2020/
+379 hash/1457c0d6bfcb4967418bfb8ac142f64a-Abstract.html.
+380 [8] D. Choi, C. J. Shallue, Z. Nado, J. Lee, C. J. Maddison, and G. E. Dahl. On empirical comparisons
+381 of optimizers for deep learning. CoRR, abs/1910.05446, 2019. URL http://arxiv.org/abs/1910.
+382 05446.
+383 [9] C. Daniel, J. Taylor, and S. Nowozin. Learning step size controllers for robust neural network training. In
+384 D. Schuurmans and M. P. Wellman, editors, Proceedings of the Thirtieth AAAI Conference on Artificial
+385 Intelligence, February 12-17, 2016, Phoenix, Arizona, USA, pages 1519–1525. AAAI Press, 2016. URL
+386 http://www.aaai.org/ocs/index.php/AAAI/AAAI16/paper/view/11763.
+387 [10] F. de Roos, C. Jidling, A. Wills, T. B. Schön, and P. Hennig. A probabilistically motivated learning rate
+388 adaptation for stochastic optimization. CoRR, abs/2102.10880, 2021. URL https://arxiv.org/abs/
+389 2102.10880.
+390 [11] L. Dinh, R. Pascanu, S. Bengio, and Y. Bengio. Sharp minima can generalize for deep nets. In D. Precup
+391 and Y. W. Teh, editors, Proceedings of the 34th International Conference on Machine Learning, ICML
+392 2017, Sydney, NSW, Australia, 6-11 August 2017, volume 70 of Proceedings of Machine Learning Research,
+393 pages 1019–1028. PMLR, 2017. URL http://proceedings.mlr.press/v70/dinh17b.html.
+394 [12] P. Foret, A. Kleiner, H. Mobahi, and B. Neyshabur. Sharpness-aware minimization for efficiently improving
+395 generalization. CoRR, abs/2010.01412, 2020. URL https://arxiv.org/abs/2010.01412.
+396 [13] J. Frankle, D. J. Schwab, and A. S. Morcos. The early phase of neural network training. In 8th Interna
+397 tional Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020.
+398 OpenReview.net, 2020. URL https://openreview.net/forum?id=Hkl1iRNFwS.
+399 [14] A. Gotmare, N. S. Keskar, C. Xiong, and R. Socher. A closer look at deep learning heuristics: Learning
+400 rate restarts, warmup and distillation. In 7th International Conference on Learning Representations, ICLR
+401 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019. URL https://openreview.net/
+402 forum?id=r14EOsCqKX.
+403 [15] P. Goyal, P. Dollár, R. B. Girshick, P. Noordhuis, L. Wesolowski, A. Kyrola, A. Tulloch, Y. Jia, and
+404 K. He. Accurate, large minibatch SGD: training imagenet in 1 hour. CoRR, abs/1706.02677, 2017. URL
+405 http://arxiv.org/abs/1706.02677.
+406 [16] G. Gur-Ari, D. A. Roberts, and E. Dyer. Gradient descent happens in a tiny subspace. CoRR,
+407 abs/1812.04754, 2018. URL http://arxiv.org/abs/1812.04754.
+408 [17] D. Han, J. Kim, and J. Kim. Deep pyramidal residual networks. In 2017 IEEE Conference on Computer
+409 Vision and Pattern Recognition, CVPR 2017, Honolulu, HI, USA, July 21-26, 2017, pages 6307–6315.
+410 IEEE Computer Society, 2017. doi: 10.1109/CVPR.2017.668. URL https://doi.org/10.1109/CVPR.
+411 2017.668.
+412 [18] K. He, X. Zhang, S. Ren, and J. Sun. Delving deep into rectifiers: Surpassing human-level performance on
+413 imagenet classification. In Proceedings of the IEEE international conference on computer vision, pages
+414 1026–1034, 2015.
+415 [19] K. He, X. Zhang, S. Ren, and J. Sun. Identity mappings in deep residual networks. In B. Leibe,
+416 J. Matas, N. Sebe, and M. Welling, editors, Computer Vision - ECCV 2016 - 14th European Conference,
+417 Amsterdam, The Netherlands, October 11-14, 2016, Proceedings, Part IV, volume 9908 of Lecture Notes
+418 in Computer Science, pages 630–645. Springer, 2016. doi: 10.1007/978-3-319-46493-0\_38. URL
+419 https://doi.org/10.1007/978-3-319-46493-0_38.
+420 [20] E. Hoffer, I. Hubara, and D. Soudry. Train longer, generalize better: closing the generalization gap in large
+421 batch training of neural networks. In I. Guyon, U. von Luxburg, S. Bengio, H. M. Wallach, R. Fergus,
+422 S. V. N. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems 30:
+423 Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach,
+424 CA, USA, pages 1731–1741, 2017. URL https://proceedings.neurips.cc/paper/2017/hash/
+425 a5e0ff62be0b08456fc7f1e88812af3d-Abstract.html.
+426 [21] T. M. Hospedales, A. Antoniou, P. Micaelli, and A. J. Storkey. Meta-learning in neural networks: A survey.
+427 CoRR, abs/2004.05439, 2020. URL https://arxiv.org/abs/2004.05439.
+428 [22] S. Jastrzebski, Z. Kenton, D. Arpit, N. Ballas, A. Fischer, Y. Bengio, and A. J. Storkey. Three factors
+429 influencing minima in SGD. CoRR, abs/1711.04623, 2017. URL http://arxiv.org/abs/1711.04623.
+430 [23] S. Jastrzebski, M. Szymczak, S. Fort, D. Arpit, J. Tabor, K. Cho, and K. Geras. The break-even point
+431 on optimization trajectories of deep neural networks. In 8th International Conference on Learning
+432 Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. URL
+433 https://openreview.net/forum?id=r1g87C4KwB.
+434 [24] Y. Jiang, B. Neyshabur, H. Mobahi, D. Krishnan, and S. Bengio. Fantastic generalization measures and
+435 where to find them. In 8th International Conference on Learning Representations, ICLR 2020, Addis
+436 Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. URL https://openreview.net/forum?
+437 id=SJgIPJBFvH.
+438 [25] Y. Jin, T. Zhou, L. Zhao, Y. Zhu, C. Guo, M. Canini, and A. Krishnamurthy. Auto{lrs}: Automatic
+439 learning-rate schedule by bayesian optimization on the fly. In International Conference on Learning
+440 Representations, 2021. URL https://openreview.net/forum?id=SlrqM9_lyju.
+441 [26] D. Kalimeris, G. Kaplun, P. Nakkiran, B. L. Edelman, T. Yang, B. Barak, and H. Zhang. SGD on neural
+442 networks learns functions of increasing complexity. In H. M. Wallach, H. Larochelle, A. Beygelzimer,
+443 F. d’Alché-Buc, E. B. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32:
+444 Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019,
+445 Vancouver, BC, Canada, pages 3491–3501, 2019. URL https://proceedings.neurips.cc/paper/
+446 2019/hash/b432f34c5a997c8e7c806a895ecc5e25-Abstract.html.
+447 [27] D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. In Y. Bengio and Y. LeCun, editors,
+448 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9,
+449 2015, Conference Track Proceedings, 2015. URL http://arxiv.org/abs/1412.6980.
+450 [28] H. Lang, L. Xiao, and P. Zhang. Using statistics to automate stochastic optimization. In
+451 H. M. Wallach, H. Larochelle, A. Beygelzimer, F. d’Alché-Buc, E. B. Fox, and R. Garnett,
+452 editors, Advances in Neural Information Processing Systems 32: Annual Conference on Neu
+453 ral Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC,
+454 Canada, pages 9536–9546, 2019. URL https://proceedings.neurips.cc/paper/2019/hash/
+455 e1054bf2d703bca1e8fe101d3ac5efcd-Abstract.html.
+456 [29] G. Leclerc and A. Madry. The two regimes of deep network training. CoRR, abs/2002.10376, 2020. URL
+457 https://arxiv.org/abs/2002.10376.
+458 [30] A. Lewkowycz. How to decay your learning rate. CoRR, abs/2103.12682, 2021. URL https://arxiv.
+459 org/abs/2103.12682.
+460 [31] A. Lewkowycz, Y. Bahri, E. Dyer, J. Sohl-Dickstein, and G. Gur-Ari. The large learning rate phase of deep
+461 learning: the catapult mechanism. CoRR, abs/2003.02218, 2020. URL https://arxiv.org/abs/2003.
+462 02218.
+463 [32] Y. Li, C. Wei, and T. Ma. Towards explaining the regularization effect of initial large learning rate in
+464 training neural networks. In H. M. Wallach, H. Larochelle, A. Beygelzimer, F. d’Alché-Buc, E. B. Fox,
+465 and R. Garnett, editors, Advances in Neural Information Processing Systems 32: Annual Conference
+466 on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC,
+467 Canada, pages 11669–11680, 2019. URL https://proceedings.neurips.cc/paper/2019/hash/
+468 bce9abf229ffd7e570818476ee5d7dde-Abstract.html.
+469 [33] Z. Li and S. Arora. An exponential learning rate schedule for deep learning. In 8th International Conference
+470 on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net,
+471 2020. URL https://openreview.net/forum?id=rJg8TeSFDH.
+472 [34] I. Loshchilov and F. Hutter. SGDR: stochastic gradient descent with warm restarts. In 5th International
+473 Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference
+474 Track Proceedings. OpenReview.net, 2017. URL https://openreview.net/forum?id=Skq89Scxx.
+475 [35] I. Loshchilov and F. Hutter. Decoupled weight decay regularization. In 7th International Conference on
+476 Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.
+477 URL https://openreview.net/forum?id=Bkg6RiCqY7.
+478 [36] J. Ma and D. Yarats. On the adequacy of untuned warmup for adaptive optimization. CoRR, abs/1910.04209,
+479 2019. URL http://arxiv.org/abs/1910.04209.
+480 [37] R. Müller, S. Kornblith, and G. E. Hinton. When does label smoothing help? In H. M.
+481 Wallach, H. Larochelle, A. Beygelzimer, F. d’Alché-Buc, E. B. Fox, and R. Garnett, edi
+482 tors, Advances in Neural Information Processing Systems 32: Annual Conference on Neural
+483 Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC,
+484 Canada, pages 4696–4705, 2019. URL https://proceedings.neurips.cc/paper/2019/hash/
+485 f1748d6b0fd9d439f71450117eba2725-Abstract.html.
+486 [38] V. Nair and G. E. Hinton. 3d object recognition with deep belief nets. In Y. Bengio, D. Schuur
+487 mans, J. D. Lafferty, C. K. I. Williams, and A. Culotta, editors, Advances in Neural Information Pro
+488 cessing Systems 22: 23rd Annual Conference on Neural Information Processing Systems 2009. Pro
+489 ceedings of a meeting held 7-10 December 2009, Vancouver, British Columbia, Canada, pages 1339–
+490 1347. Curran Associates, Inc., 2009. URL https://proceedings.neurips.cc/paper/2009/hash/
+491 6e7b33fdea3adc80ebd648fffb665bb8-Abstract.html.
+492 [39] P. Nakkiran, G. Kaplun, Y. Bansal, T. Yang, B. Barak, and I. Sutskever. Deep double descent: Where
+493 bigger models and more data hurt. In 8th International Conference on Learning Representations, ICLR
+494 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. URL https://openreview.
+495 net/forum?id=B1g5sA4twr.
+496 [40] A. Neelakantan, L. Vilnis, Q. V. Le, I. Sutskever, L. Kaiser, K. Kurach, and J. Martens. Adding gradient
+497 noise improves learning for very deep networks. CoRR, abs/1511.06807, 2015. URL http://arxiv.
+498 org/abs/1511.06807.
+499 [41] M. Raghu, J. Gilmer, J. Yosinski, and J. Sohl-Dickstein. SVCCA: singular vector canonical correlation
+500 analysis for deep learning dynamics and interpretability. In I. Guyon, U. von Luxburg, S. Bengio, H. M.
+501 Wallach, R. Fergus, S. V. N. Vishwanathan, and R. Garnett, editors, Advances in Neural Information
+502 Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December
+503 4-9, 2017, Long Beach, CA, USA, pages 6076–6085, 2017. URL https://proceedings.neurips.cc/
+504 paper/2017/hash/dc6a7e655d7e5840e66733e9ee67cc69-Abstract.html.
+505 [42] N. Rahaman, A. Baratin, D. Arpit, F. Draxler, M. Lin, F. A. Hamprecht, Y. Bengio, and A. C. Courville.
+506 On the spectral bias of neural networks. In K. Chaudhuri and R. Salakhutdinov, editors, Proceedings of the
+507 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California,
+508 USA, volume 97 of Proceedings of Machine Learning Research, pages 5301–5310. PMLR, 2019. URL
+509 http://proceedings.mlr.press/v97/rahaman19a.html.
+510 [43] M. Rolinek and G. Martius. L4: practical loss-based stepsize adaptation for deep learn
+511 ing. In S. Bengio, H. M. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Gar
+512 nett, editors, Advances in Neural Information Processing Systems 31: Annual Conference on
+513 Neural Information Processing Systems 2018, NeurIPS 2018, December 3-8, 2018, Montréal,
+514 Canada, pages 6434–6444, 2018. URL https://proceedings.neurips.cc/paper/2018/hash/
+515 98b17f068d5d9b7668e19fb8ae470841-Abstract.html.
+516 [44] K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In
+517 Y. Bengio and Y. LeCun, editors, 3rd International Conference on Learning Representations, ICLR 2015,
+518 San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015. URL http://arxiv.org/
+519 abs/1409.1556.
+520 [45] L. N. Smith and N. Topin. Super-convergence: Very fast training of residual networks using large learning
+521 rates. CoRR, abs/1708.07120, 2017. URL http://arxiv.org/abs/1708.07120.
+522 [46] S. L. Smith, B. Dherin, D. G. T. Barrett, and S. De. On the origin of implicit regularization in stochastic
+523 gradient descent. CoRR, abs/2101.12176, 2021. URL https://arxiv.org/abs/2101.12176.
+524 [47] N. Srivastava, G. E. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhutdinov. Dropout: a simple
+525 way to prevent neural networks from overfitting. J. Mach. Learn. Res., 15(1):1929–1958, 2014. URL
+526 http://dl.acm.org/citation.cfm?id $\equiv ^ { \prime }$ 2670313.
+527 [48] M. Tan and Q. V. Le. Efficientnet: Rethinking model scaling for convolutional neural networks. In
+528 K. Chaudhuri and R. Salakhutdinov, editors, Proceedings of the 36th International Conference on Machine
+529 Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of
+530 Machine Learning Research, pages 6105–6114. PMLR, 2019. URL http://proceedings.mlr.press/
+531 v97/tan19a.html.
+532 [49] A. C. Wilson, R. Roelofs, M. Stern, N. Srebro, and B. Recht. The marginal value of adaptive gradient
+533 methods in machine learning. In I. Guyon, U. von Luxburg, S. Bengio, H. M. Wallach, R. Fergus,
+534 S. V. N. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems 30:
+535 Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach,
+536 CA, USA, pages 4148–4158, 2017. URL https://proceedings.neurips.cc/paper/2017/hash/
+537 81b3833e2504647f9d794f7d7b9bf341-Abstract.html.
+538 [50] H. Xiao, K. Rasul, and R. Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine
+539 learning algorithms. CoRR, abs/1708.07747, 2017. URL http://arxiv.org/abs/1708.07747.
+540 [51] Z. Xu, A. M. Dai, J. Kemp, and L. Metz. Learning an adaptive learning rate schedule. CoRR,
+541 abs/1909.09712, 2019. URL http://arxiv.org/abs/1909.09712.
+542 [52] G. Zhang, C. Wang, B. Xu, and R. B. Grosse. Three mechanisms of weight decay regularization. In 7th
+543 International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019.
+544 OpenReview.net, 2019. URL https://openreview.net/forum?id=B1lz-3Rct7.
+545 [53] H. Zhang, Y. N. Dauphin, and T. Ma. Fixup initialization: Residual learning without normalization. In
+546 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9,
+547 2019. OpenReview.net, 2019. URL https://openreview.net/forum?id=H1gsz30cKX.
+548 [54] Z. Zhu, J. Wu, B. Yu, L. Wu, and J. Ma. The anisotropic noise in stochastic gradient descent: Its behavior
+549 of escaping from sharp minima and regularization effects. In K. Chaudhuri and R. Salakhutdinov, editors,
+550 Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019,
+551 Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pages 7654–7663.
+552 PMLR, 2019. URL http://proceedings.mlr.press/v97/zhu19e.html.
+# 553 Checklist
+1. For all authors...
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]
+(b) Did you describe the limitations of your work? [Yes] This is discussed in Section 5.
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] This is discussed in Section 5
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+2. If you are including theoretical results...
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] The assumptions are stated with the results.
+(b) Did you include complete proofs of all theoretical results? [Yes] Complete proofs can be found in the APPENDIX
+3. If you ran experiments...
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] A reference implementation is provided under a free license.
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] Training details are specified with the experiments.
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] Errors bars are reported for our own experiments, where applicable.
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] We specify the used compute in the APPENDIX.
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+(a) If your work uses existing assets, did you cite the creators? [Yes]
+(b) Did you mention the license of the assets? [No] We only use freely available data sets.
+(c) Did you include any new assets either in the supplemental material or as a URL? [No] No new assets / data sets were used.
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No] No additional data was used.
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No] For the data sets we use, this is already discussed in the community.
+5. If you used crowdsourcing or conducted research with human subjects...
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A] Not applicable.
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A] Not applicable.
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] Not applicable.

parse/train/yqj6q_eNTJd/yqj6q_eNTJd_content_list.json ADDED Viewed

	@@ -0,0 +1,1110 @@

+[
+    {
+        "type": "text",
+        "text": "ActCooLR – High-Level Learning Rate Schedules using Activation Pattern Temperature ",
+        "text_level": 1,
+        "bbox": [
+            197,
+            122,
+            800,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            580,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 We consider the aspect of learning rate (LR-)scheduling in neural networks, which   \n2 often significantly affects achievable training time and generalization performance.   \n3 Although schedules such as $^ { l }$ -cycle offer substantial gains over base-line methods,   \n4 the effect of LR-curves on the training process is not very well understood. In order   \n5 to gain more insight into the training process, we combine information theoretic   \n6 ideas and probabilistic optimization, namely simulated annealing. In more detail,   \n7 we introduce the activation pattern temperature, which (i) captures changes in the   \n8 non-linear behavior of ReLU networks and (ii) is free of hyperparameters and thus   \n9 is more interpretable. Examining the training process, 1-cycle simply yields a linear   \n10 decrease in temperature, reminiscent of successful cooling strategies in simulated   \n11 annealing. In order to test a causal connection, we devise ActCooLR, an automatic   \n12 LR-scheduler that produces declining temperature profiles. In experiments with   \n13 various CNN architectures and different image classification data sets, we obtain   \n14 results that perform favorably or exceed the performance of hand-tuned schedules. ",
+        "bbox": [
+            148,
+            349,
+            766,
+            544
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "15 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            570,
+            312,
+            588
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "16 Despite the huge success of deep networks, their training dynamics is still ground for many discussions.   \n17 Above all, the reason for the good performance of such a simple algorithm as Stochastic Gradient   \n18 Descent (SGD) remains an open question. As stated by Bengio [4], the learning rate (LR) of SGD is   \n19 “[t]he single most important hyperparameter and one should always make sure that has been tuned”.   \n20 It is considered to steer the amount of noise that regularizes the optimization [6; 22]. Research spans   \n21 from practical recommendations, such as best practice learning rate schedules of distinct forms [4]   \n22 to theoretical models that unveil the implicit regularization of SGD that depends on the learning   \n23 rate [2; 46]. For instance, many training procedures include a warm up phase into the learning rate   \n24 schedules to adapt training to numerical limitations as well as the distinct behavior of the initial   \n25 training phase compared to the rest of training [14; 15; 36]. Recent studies divide the whole training   \n26 process into phases of distinct characteristics. Nevertheless, the number of regimes or phases is still   \n27 under discussion, most commonly described as two or three phases ([13; 29; 31; 32; 39]). A broad   \n28 variety of work introduce sharpness based measures that give mathematical characterizations of the   \n29 loss landscape promising a deeper understanding of the phases, trainability and generalization of deep   \n30 networks [24]. However, these typically either introduce hyperparameters themselves or describe   \n31 only a subspace of optimization directions.   \n32 In this paper, we are trying to understand the effect of varying learning rates on the training process   \n33 better. As a central tool, we propose a new measure of learning progress, activation pattern temper  \n34 ature (APT). The key idea is to focus on the “hard” part of optimization, which is the fitting of a   \n35 non-linear function. We therefore measure changes not by step-size in parameter space but counting   \n36 changes in activation patterns, i.e., testing if the decomposition of feature maps into piecewise   \n37 linear regions changes. Due to its independence of changes to the linear mappings, the measure is,   \n38 unlike the original LR and other simple differential measures in parameter space, more stable under   \n39 reparametrization.   \n40 Through the lens of this measure we analyze the training of convolutional neural networks on image   \n41 classification tasks using several LR schedules (Section 3.2) and find that the commonly used $^ { l }$ -cycle   \n42 scheduler [45] has a very simple behavior, namely an approximately linear decrease during training.   \n43 It also provides some additional insights into the training dynamic, such as connections between   \n44 temperature and generalization behavior, and a visualization of phase-boundaries for different learning   \n45 rates.   \n46 Using the analysis, we present a method that adapts the learning rate automatically to match a user  \n47 specified target temperature profile throughout training. Effective profiles start at high temperature   \n48 and decrease monotonically until the activation patterns do not change anymore and optimization   \n49 becomes purely linear. Correspondingly, we name our method ActCooLR. As our method matches   \n50 the performance of previously hand-tuned learning rate schedules in our experiments, it could be   \n51 considered as a candidate for an effective and efficient, hyper-parameter free automatic LR-scheduler.   \n52 The computational overhead is moderate , with only one additional forward-pass.   \n53 In summary, our main contributions are (i) the introduction of the activation pattern temperature,   \n54 which reveals a more uniform view of the effect of LR-scheduling on training and (ii), based on   \n55 this, an automatic learning rate scheduler that provides accuracy for short training times in a fully   \n56 automatic way. ",
+        "bbox": [
+            145,
+            603,
+            825,
+            824
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            830,
+            823,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            92,
+            826,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            138,
+            825,
+            222
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            229,
+            825,
+            327
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            332,
+            825,
+            388
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "57 2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            151,
+            409,
+            320,
+            426
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Driven by the goal to better understand generalization, the training process of deep network training has been analyzed in a large body of work. We would structure the background as follows: ",
+        "bbox": [
+            158,
+            443,
+            821,
+            470
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "60 Training Phases: One approach of understanding the training process is to describe it in different   \n61 phases. An early variant of this idea is the work of Bengio et al. [5], who showed that increasing   \n62 the intrinsic complexity of data during training can help to improve generalization performance.   \n63 Several studies identify two training phases: the network trains low-frequency features first, yielding   \n64 low generalization error and continues to learn high-frequency features in a second training phase   \n65 that is more susceptible to overfitting [42; 26]. Similar observations have been made in studies   \n66 that also take the effect of the learning rate into account [29; 31; 32]. A more recent study stated   \n67 that their “experiments suggest that this [(two training phases)] is not the complete picture” [39].   \n68 Others show evidence of three instead of two training phases [13; 31]. However, there appears to   \n69 be consensus in literature that at the beginning of the training, the activations of a network mainly   \n70 perform a random walk [13; 20]. More practically, increasing the randomness has been shown to   \n71 even improve performance (see e.g. [40; 54]), having dropout as a more prominent example [47].   \n72 The other widely accepted fact relates to the end of training, where momentum becomes increasingly   \n73 important [29] as gradients directions simplify [16] and the loss landscape flattens [2]. Hoffer et al.   \n74 [20] have shown that this comes from the loss landscape getting smoother the farther the weights   \n75 travel from initialization. More recently, mode connectivity has been used as a tool to check whether   \n76 a modification in the training process leads to distinct optimization trajectories in the loss landscape   \n77 and its found minima [14; 23].   \n78 Measures: There are several studies on the correlation between complexity- and norm-based mea  \n79 sures [24]. In particular, generalization improvements from flatness of the loss landscape has been   \n80 discussed both affirmatively and negatively [11; 46]. Nevertheless, sharpness or curvature based   \n81 methods have been utilized to improve generalization in practice [10; 12]. Numerous work have   \n82 included additional regularization into the training process. The angle between the momentum vector   \n83 and the local gradient has been utilized to construct a statistical test to determine convergence [28].   \n84 The value and statistics of the loss have also been used for regularization during training, either by   \n85 relaxing the softmax loss [37] or by adapting the gradients in order to make constant progress on the   \n86 loss [43]. Lastly, Raghu et al. [41] proposed a method to measure the layer-wise complexity of a   \n87 network by computing the Singular Value Decomposition of the activations. This method is similar in   \n88 spirit to ours, but it measures the intrinsic dimensions in a stationary fashion, excluding the training   \n89 process in the measure itself. In contrast to competing measures, our measure is hyperparameter-free   \n90 and does not depend on the setting it is evaluated in. It avoids the complexity of rescaling due to   \n91 surrounding layers, which plague many continuous measures, by solely focusing on the discrete   \n92 activations of a ReLU network.   \n93 Hyperparameter Schedules: Hyperparameter choice has a strong effect on (generalization) perfor  \n94 mance and convergence speed. Economically, under fixed training budgets, this leads to a trade-off   \n95 [8; 49]. In cases of small batch sizes, one crucial invariant control parameter has been shown to be the   \n96 ratio of learning rate and batch size [15; 20]. SGD has been shown to have an implicit bias towards   \n97 flat regions theoretically that is reinforced by high learning rates [2; 46]. There is strong empirical   \n98 evidence that large initial learning rates can help with generalization in over-parameterized networks   \n99 [31; 32]. However, large networks require a “warm up” phase to prevent divergence of deeper layers   \n100 [14]. While most schedules let the learning rate approach zero with training time, especially the   \n101 course of the learning rate in the middle of the training process has not yet been analyzed extensively.   \n102 Our model suggest here an analogy to annealing schemes in discrete stochastic optimization and   \n103 provides a holistic perspective on the whole training process. LR scheduling is considered to be   \n104 directly linked to generalization performance [20; 22; 24; 29; 32]. For instance, a cyclic schedule   \n105 enables to train networks with a good “anytime performance” [34] and the implicit learning rate   \n106 schedules that are built into adaptive optimizers such as Adam [27] are topic of current research   \n107 [1; 36]. However, specific research in learning rate schedules is sparse. Although, correctly tuned,   \n108 1-cycle achieves the same accuracy using order-of-magnitude fewer training iterations [45], “large   \n109 models in NLP and vision use schedules which can be easily resumed” [30], such as “clipped” cosine   \n110 decay [7] or exponential decay [48]. Recently, research in automatic and adaptive hyperparameter   \n111 tuning has become more prominent. For instance, automatic tuning of decay time for the exponential   \n112 decay schedule, [28; 30], and meta-networks designed to predict the learning rate based on learned   \n113 typical training courses ([21], or more specifically, [9; 51]) have been tested. Another approach   \n114 includes the learning rate into the optimization process by deriving the loss w.r.t. the learning rate   \n115 as well [3]. Lastly, weight decay has been focus of discussion related generalization gap between   \n116 SGD and adaptive optimizers [35; 49]. Also, it has been shown to affect the learning rate scheduling   \n117 directly when used in conjunction with batch norm: every weight decay step increases the effective   \n118 learning rate by a multiplicative factor for a constant learning rate schedule [33; 52]. The most similar   \n119 of the named methods to ours from an optimization perspective is probably that of de Roos et al.   \n120 [10], where successive training steps are used to estimate change of curvature of the loss function to   \n121 adapt the learning rate automatically; however it requires additional hyperparameters and continuous   \n122 re-evaluations of the batch-loss. ",
+        "bbox": [
+            147,
+            477,
+            825,
+            727
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            732,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            155,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            125,
+            825,
+            540
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "123 3 Activation Pattern Temperature (APT) ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            558,
+            529,
+            575
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "124 We base our approach on the view that non-linearity is what makes deep networks actually expressive.   \n125 Throughout this paper, we restrict ourselves to the non-linear aspects of training and study (the   \n126 popular) ReLU activation function [38], which switches binarily between two linear states. Non  \n127 linearity of whole networks is thus encoded in the way the network is switching between those discrete   \n128 states in an orchestrated way. We call these binary patterns assigned to data “activation patterns”.   \n129 Our idea is very simple: We track the change of activation patterns, by comparing corresponding   \n130 outputs of ReLU layers for the same input data, and use the neg-log-likelihood of these changes to   \n131 quantify the “step-size” of the training progress. ",
+        "bbox": [
+            140,
+            589,
+            826,
+            702
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Formal Definition of APT ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            715,
+            390,
+            731
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Formally, we consider a feed-forward ReLU network $F _ { \\theta } ^ { L }$ with parameters $\\theta$ , that contains $L$ activation layers. Further, let $f ^ { l } ( x ) \\in \\mathbb { R } ^ { d _ { l } }$ denote the output of such a layer $l \\in \\{ 1 , . . . , L \\}$ , for an input batch $\\boldsymbol { x } \\in \\mathbb { R } ^ { B \\times d _ { 0 } }$ of batch-size $B$ . ",
+        "bbox": [
+            173,
+            741,
+            825,
+            786
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "136 We now define the activation pattern for (ReLU) layer $l$ as ",
+        "bbox": [
+            147,
+            792,
+            560,
+            808
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e47f5b820df90692d9f2e13fc0b52732df80f4a99f70598b2a0677aaccd85a63.jpg",
+        "text": "$$\nM _ { \\theta } ^ { l } ( x ) : = \\left( \\mathrm { s i g n } \\left( f ^ { l } ( x ) \\right) \\right) ( x ) \\in \\{ 0 , 1 \\} ^ { d _ { l } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            811,
+            635,
+            832
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "137 which can be seen as a bit-vector of ReLU activated neurons. ",
+        "bbox": [
+            142,
+            834,
+            575,
+            849
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "138 Training: Training is performed in discrete steps $t = 0 , 1 , 2 , \\ldots$ At each step, an input batch $x$   \n139 is considered and the optimizer computes new parameters $\\theta _ { t }$ . $\\theta _ { 0 }$ is determined by the network’s   \n140 initialization, and ",
+        "bbox": [
+            145,
+            854,
+            828,
+            897
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/08ea01a04f007f0731c8230e88865b9354c72b8b03ced101b2dd017c830fb559.jpg",
+        "text": "$$\n\\theta _ { t + 1 } = \\theta _ { t } + \\lambda _ { t } \\nabla _ { \\theta _ { t } } L ( F _ { \\theta _ { t } } ^ { L } , x _ { t } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            895,
+            598,
+            914
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "141 is the update by a single optimization step for batch $x$ under loss $L$ (which, we assume, is informed   \n142 of the ground-truth outputs $y ( x )$ ).   \n143 In this context, the incremental updates to $\\theta _ { t }$ from randomly drawn batches $x _ { t }$ make the temporal   \n144 sequence $( \\theta _ { 0 } , \\theta _ { 1 } , \\theta _ { 2 } , \\ldots )$ a Markov chain; the same holds for the sequence of activation patterns   \n145 $M _ { \\theta _ { t } } ^ { l } ( x )$ over time $t$ . Additionally, we model the effect of one optimization step on the activation   \n146 patters as a Markov chain, ",
+        "bbox": [
+            147,
+            90,
+            825,
+            121
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            126,
+            825,
+            183
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b51a5c9eca099410f247e987c5c3a49d63b8e61a2dd52a48fa7f84c59214c499.jpg",
+        "text": "$$\n( X , Y ) \\xrightarrow [ \\theta _ { \\varepsilon  \\theta _ { t }  \\theta _ { t }  \\iota _ { \\nabla _ { \\theta _ { t } } \\sum _ { j } \\varepsilon _ { 0 } r _ { i } \\gamma _ { j } } ] } { \\xrightarrow [ { \\mathrm { N e t w o r k ~ E v a l u a t i o n } } ] { \\mathrm { N e t w o r k ~ } } } ( M _ { \\theta _ { t + 1 } } ^ { 1 } , \\dots , M _ { \\theta _ { t } } ^ { L } ) \\xrightarrow [ ] { \\mathrm { N e t w o r k ~ } } ( T _ { t } ^ { 1 } , \\dots , T _ { t } ^ { L } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            194,
+            767,
+            260
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "147 where $X$ denotes the random variables that chooses examples from any distribution, $Y$ describes its   \n148 true underlying information that we are interested in, and $\\mathbf { \\dot { \\nabla } } T _ { t } ^ { l }$ the change in activation patterns. Each   \n149 stochastic process, symbolized by an arrow, optionally adds uncorrelated noise to the mapping.   \n150 Definition: We now define the activation pattern temperature $( A P T )$ on layer $l$ as the self-information   \n151 of the event that an activation pattern has not changed, ",
+        "bbox": [
+            143,
+            273,
+            825,
+            315
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            321,
+            828,
+            351
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/74c91a6df59eca6af4308ffebd114cf527f1675c483aef63bc0be4b640f67f23.jpg",
+        "text": "$$\nT _ { t } ^ { l } ( x ) : = - \\log _ { 2 } \\left( \\mathrm { P r } \\left( M _ { \\theta _ { t + 1 } } ^ { l } ( x ) = M _ { \\theta _ { t } } ^ { l } ( x ) \\right) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            358,
+            656,
+            385
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "152 where $\\mathrm { P r }$ denotes the probability distribution.1 This estimates the probability of an activation pattern   \n153 change over the batch $x$ . We also define the average activation pattern temperature $T _ { t }$ as the average   \n154 of $T _ { t } ^ { \\tilde { l } }$ over all (ReLU) layers of the network. This measure is parameter-free and specifies the amount   \n155 of non-linear change in a network. Its lower bound is 0, stating that no non-linear change occurred   \n156 and only the linear parts of the network could have been changed during that step. The temperature   \n157 approaches infinity if all activations have changed during a single optimization step.   \n158 Computation: To measure $\\boldsymbol { T _ { t } ^ { l } }$ , we run the forward-pass of a network twice, recording the activation   \n159 patterns in the first pass and comparing and accumulating changes in the second. In experiments,   \n160 we observe that evaluation on a single training batch already give good estimates. Thus, we use the   \n161 single-batch estimate of APT in the rest of the paper, unless stated otherwise. This allows the measure   \n162 to be calculated at the cost of only one single additional forward pass of the same batch that has been   \n163 already used for the previous optimization step. ",
+        "bbox": [
+            140,
+            392,
+            825,
+            478
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            483,
+            825,
+            568
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "164 3.2 Training Methods & their Training Dynamics ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            584,
+            531,
+            599
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "165 In this section, we utilize the activation pattern temperature (APT) (Equation (4)) to gain more insight   \n166 into the non-linear training dynamics affected by the choice of learning rate schedules. As a baseline   \n167 experiment, we compare the training of ResNet-32 (CIFAR-Variant, [19]) trained on CIFAR-10   \n168 with step decay learning rate schedule. 2 We study the effect of three modifications to the ResNet  \n169 Architecture: ResNet with removed shortcut connections, FixUp [53] (no batch normalization) and   \n170 Pyramid-Net [17] (linear growing number of filters). In Figure 1, we show the learning rate (top row),   \n171 the corresponding activation temperature of the first layer $\\mathsf { \\bar { f } } ^ { 1 }$ (middle row), and the Top-1 validation   \n172 error (bottom row) for the baseline experiment. In the following, we analyze these plots regarding   \n173 their temperature profiles, training time and generalization performance. ",
+        "bbox": [
+            140,
+            609,
+            825,
+            736
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "APT simplified learning rate description: During the training process, APT reflects changes of the LR (APT is reduced, whenever LR is reduced). APT starts strictly greater than zero, the actual value depends on the architecture as well as the training hyperparameters, and, during the training process, APT is reduced and approaches zero. Most importantly, 1-cycle schedule (blue curves), shows approximately a linear decrease of APT. ",
+        "bbox": [
+            173,
+            741,
+            825,
+            810
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Temperature cools down bottom-to-top: Defined as a per-layer temperature, we discuss the APT on a per-layer basis in the APPENDIX. We observe that deeper layers have a higher temperature (we call these hotter) in comparison to the first layers in a network (we call these cooler). Also, we ",
+        "bbox": [
+            169,
+            816,
+            823,
+            859
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/be02063d82e8f03339d0fd9a40afa207f727fe8833c30e0c141be772005841ec.jpg",
+        "image_caption": [
+            "Figure 1: Learning Rates, Validation Accuracy & Temperatures of the first ReLU-Layer in ResNet-32 (and its Variants) on CIFAR-10 for different LR schedules. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            88,
+            818,
+            351
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "182 observe that in each network the activation pattern temperatures decreases (or “cools down”) from   \n183 bottom to top, in accordance to recent work [41]. ",
+        "bbox": [
+            145,
+            433,
+            823,
+            462
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "APT possibly relates to generalization: On the other hand, we observe that the validation error has similarities to the APT profile, despite having no direct relation between the AT and the loss. In this setting, APT is proportional to the validation error. Architectural adaptions also affect performance, negatively (as ResNet in the absence of shortcut connections), and positively (FixUp and PyramidNet) have that characteristics. ",
+        "bbox": [
+            173,
+            468,
+            825,
+            536
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "APT is not explained by learning rate alone: The temperature can change (decrease) despite a constant learning rate. This can be observed, for example, in all experiments of fig. 1(b), especially in the beginning of training, but also with every drop of the learning rate. We conclude: for a fixed setting, the course of APT is not steered by the magnitude of learning rate alone, and APT contains hidden variables responsible for its course. ",
+        "bbox": [
+            171,
+            544,
+            825,
+            612
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This is in comply with previous work that studied the early phase of training in more detail [13]. We think that this view could shed some light on the initial phase of training and possibly explains the requirement of using a warm-up schedule in common training schemes beyond numerical instabilities. ",
+        "bbox": [
+            161,
+            613,
+            823,
+            654
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Learning Rate Range Analysis ",
+        "text_level": 1,
+        "bbox": [
+            163,
+            670,
+            424,
+            685
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the following chapter, we want to study the connection between LR and APT. We do so by reevaluating the exact same update step with a fixed range of learning rates. This allows us to observe the training from a global LR-invariant perspective. In more detail, we carry out this experiment for two different architectures on different data sets, using two different LR schedules. First we train a ResNet-56 on ImageNet, and second a ResNet-50 on CIFAR-10. Both networks are trained using step decay (90 rep. 200 epochs) and 1-cycle scheduler (20 resp. 50 epochs) each. For the initialization and every epoch in training, we freeze the network and re-evaluate the temperature for the exact same range of learning rates. The learning rates we use are uniformly sampled on a log scale, ranging from $1 0 ^ { - 4 }$ to $\\bar { 1 } 0 ^ { 2 }$ . The results are shown in Figure 2: The top row shows the average activation pattern temperature $T _ { t }$ for each network and for each LR schedule. The white lines indicate the learning rate, which actually has been used for training.3 The theoretical temperature is shown in the background as color gradient from black (cold) to yellow (hot). We observe, that after a short initialization phase the temperature has a rather homogeneous behavior ",
+        "bbox": [
+            173,
+            695,
+            825,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/2064de668a20d955dc6af7d00314ec10e3501792a29ca8e7f71da882a7b990b1.jpg",
+        "image_caption": [
+            "Figure 2: Learning Rate Range Analysis: For each point in training time of ResNet-50 on ImageNet (left two columns) and ResNet-56 on CIFAR-10 (right two columns) each with 1-cycle LR and step decay schedules, we measure the temperature for a theoretical scaling of the global LR (). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            97,
+            826,
+            335
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "211 over the whole training process. After few initial epochs, we observe only minor changes to the   \n212 temperature profile. Furthermore, the temperature profiles of ResNet-56 (ImageNet) show a phase in   \n213 which, from a global and LR-independent perspective, the networks cool down slowly, independently   \n214 of the choice of learning rate. Most notably, 1-cycle schedule uses LRs in a higher temperature   \n215 regime (near the vertex) for a longer period of time during training. In contrast, step decay passes   \n216 through into the colder temperature regime very quickly (ResNet-56/ImageNet) or already stats in it   \n217 (ResNet-50/CIFAR-10). ",
+        "bbox": [
+            140,
+            434,
+            825,
+            531
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4 Model of the Activation Pattern Temperature ",
+        "text_level": 1,
+        "bbox": [
+            165,
+            546,
+            527,
+            561
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Typically, weight initialization is based on [18], which specifies the initial distribution of the weights in such a way that the output after the ReLU-activation is Gaussian distributed on all layers. As the activation itself zeros the output if the weighted sum of normal distributed variables is smaller than zero, we model the probability of a change in activation patterns itself as the cumulative distribution function of a normal distribution. Thus, we postulate the following closed form formula. ",
+        "bbox": [
+            173,
+            571,
+            825,
+            642
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Hypothesis 1. The probability of an activation pattern change depending on the used learning rate $\\lambda$ for a single update step on any layer during training is given by ",
+        "bbox": [
+            163,
+            645,
+            825,
+            674
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/32057ca87ba7f0aede1313a999e790b9f97ae2527fc1b696d4144a10e3ceba12.jpg",
+        "text": "$$\n\\mathrm { P r } \\left( M _ { \\theta _ { t + \\lambda \\cdot \\nabla L } } ^ { l } = M _ { \\theta _ { t } } ^ { l } \\right) = \\frac { 1 } { 2 } \\cdot \\left( 1 + \\mathrm { e r f } \\left( \\frac { \\log \\lambda - \\mu } { \\sigma \\cdot \\sqrt { 2 } } \\right) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            676,
+            687,
+            712
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "226 The real numbers $\\mu , \\sigma \\in \\mathbb { R }$ depend on the training process, choice of architecture and layer. ",
+        "bbox": [
+            147,
+            714,
+            774,
+            729
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "227 We show next that the model, given by Equation (5), actually fits in practice. In more detail, for a   \n228 fixed network state, we fit the model using non-linear least squares to the data shown in Figure 2.   \n229 We evaluate the fit by visualizing the the evaluated model together with its reconstruction error   \n230 against ground truth in the second and third row of Figure 2. The estimated parameters $\\mu$ and $\\sigma$ of   \n231 Equation (5) are shown in the bottom row of Figure 2. From our experience its values depends on the   \n232 layer the temperature has been measured in, the data set and architecture used and varies also with   \n233 the random seed of the initialization of weights.   \n234 Most importantly, we could observe favorably only small drifts of the parameter $\\sigma$ that defines the   \n235 width of the Gaussian distribution used in the model. (But we also show an example of larger changes   \n236 in the APPENDIX). In contrast, the course of $\\mu$ seems to be especially affected by the learning rate   \n237 used for training. We will use this observation and Equation (5) to define an automatic learning rate   \n238 schedule in Section 4. ",
+        "bbox": [
+            140,
+            738,
+            825,
+            835
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "239 4 Activation Cooling based Learning Rate Scheduler ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            88,
+            629,
+            107
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 Optimization using ActCooLR ",
+        "text_level": 1,
+        "bbox": [
+            165,
+            119,
+            424,
+            135
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The goal of the scheduler is to determine learning rates that impose a specified temperature profile. This has to be done online, adapting the learning rate $\\lambda$ to the current network state. As a design decision, we have the option to measure temperatures at every layer, and using adaptive learning rates, even to specify them layer-wise. For simplicity we leave fine-grained adaptation for future work and generally operate with a global learning rate (similar to 1-cycle) and use the mean temperature over all layers for control. ",
+        "bbox": [
+            171,
+            145,
+            826,
+            228
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "247 In order to determine the learning rate, we simply rearrange Equation (5) from Section 3.4, which   \n248 describes the probability of a pattern change using only three parameters: $\\sigma , \\mu$ and $\\lambda$ : ",
+        "bbox": [
+            143,
+            234,
+            825,
+            263
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/40b9a5fc89e3ab7ff7986b0a44ab3bb47d9ef9f2fe5a722c567137999c8ce4b4.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mu = \\sigma \\cdot \\sqrt { 2 } \\cdot \\mathrm { e r f } ^ { - 1 } \\left( 2 \\cdot P _ { \\lambda } - 1 \\right) - \\log \\lambda , } \\\\ & { \\lambda = \\exp \\left( \\sigma \\cdot \\sqrt { 2 } \\cdot \\mathrm { e r f } ^ { - 1 } \\left( 2 \\cdot P _ { \\lambda } - 1 \\right) - \\mu \\right) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            267,
+            643,
+            318
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "249 where $P _ { \\lambda }$ denotes the probability given the used learning rate $\\lambda$ . ",
+        "bbox": [
+            142,
+            319,
+            593,
+            334
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "250 Thus, to derive the learning rate $\\bar { \\lambda }$ required to measure the target temperature $C$ , we first estimate $\\mu$   \n251 using the measured probability $P _ { \\lambda }$ using the learning rate $\\lambda$ Equation (6). Assuming that the value of   \n252 $\\mu$ and $\\sigma$ only changes slowly (see Section 3.3) we can use Equation (7) to estimate the learning rate   \n253 that would produce the given temperature $C$ . We call this learning rate adaption technique ActCooLR.   \n254 Too reduce computational costs, we limit measuring and readjustments to once every 10 optimization   \n255 steps. In between two measurements, we just interpolate linearly between the new and old learning   \n256 rate. The computational overhead is thus moderate, in particular as only a forward pass is needed.   \n257 Note, this requires to estimate $\\sigma$ in the beginning of training. The value of $\\mu$ can be estimated using   \n258 the formulas given above. We show in the APPENDIX a dynamic version of this technique, that   \n259 removes the requirement of estimating $\\sigma$ and adapting the learning rate dynamically at the cost of   \n260 additional hyperparameters. A numerical problem arises from temperatures living on a logarithmic   \n261 scale (Section 3.4). Due to finite sampling, We might estimate a probability of 1 (all patterns have   \n262 changed) by chance. According to Equation (5) this would correspond to an infinite learning rate.   \n263 We remove the singularity by an ad-hoc regularizer: For empirical propabilities of 1, we assume that   \n264 “half an activation has changed”, but was not measured. ",
+        "bbox": [
+            140,
+            335,
+            825,
+            433
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            438,
+            825,
+            549
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Designing Target Temperature Curves (CIFAR-10) ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            564,
+            566,
+            580
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "66 Until now we moved the problem of choosing the learning rate curve with a more abstract problem;   \n67 choosing the temperature curve. It is clear that we want to cool the mean temperature to a value   \n68 of zero, specifying explicitly that the network shall converge. This temperature is trivially given   \n69 by a learning rate of 0. We have seen that for sufficiently many data points it becomes increasingly   \n70 hard to let the network change all patterns with a single optimization step, in the limit this becomes   \n71 impossible.   \n272 Many previous work has analyzed the positive effects of large initial learning rates (see Section 2   \n273 for a discussion). A large initial learning rate corresponds directly to a larger temperature. Thus, we   \n274 assume that we want to start training with a high temperature, i.e. a huge flow of information through   \n275 the network with every optimization step, and end with a very low temperature (mostly only linear   \n276 regression to be optimized). Empirically, we observed in the Section 3.2 that 1-cycle shows a linear   \n277 decrease in temperature. Thus, we test next if a linear decrease in temperature accelerates training   \n278 by actively controlling the temperature with ActCooLR. As a simple baseline experiment, to test   \n279 against, we use, again, a ResNet-32 on CIFAR-10 and train it using ActCooLR and momentum SGD   \n280 (see appendix the used Hyperparameters). To test our hypothesis, we define a family of temperature   \n281 curves of the form ",
+        "bbox": [
+            150,
+            589,
+            825,
+            672
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            679,
+            825,
+            816
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/db768093c0b95456095f10229e08b55fb0660b9d46124c1a5f3d51c7945b7003.jpg",
+        "text": "$$\nC _ { \\gamma } ^ { \\mathrm { l i n e a r } } ( i , i _ { \\mathrm { t o t a l } } , T _ { \\mathrm { s t a r t } } ) : = T _ { \\mathrm { s t a r t } } \\cdot ( 1 - ( i / i _ { \\mathrm { t o t a l } } ) ^ { \\gamma } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            815,
+            648,
+            834
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "starting at $T _ { \\mathrm { s t a r t } }$ and cooling down under a reduction factor $\\gamma$ to 0. ",
+        "bbox": [
+            168,
+            835,
+            602,
+            849
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "283 Figure 3 shows the effect of the selected target temperature curve $C _ { \\underline { { { \\gamma } } } } ^ { \\mathrm { l i n e a r } }$ on the learning rate (Figure 3   \n284 (middle row) and the validation error (Figure 3 (bottom row)). From our experience and also in   \n285 comply with the observations made in Section 3.2, training generally longer on higher temperatures   \n286 $( \\gamma > 1 )$ ) achieves favorable performance compared to a faster reduction of temperature $( \\gamma < 1 )$ ). In   \n287 case of a too big $\\gamma$ , the amount of time optimization takes place in a linear way only becomes short at   \n288 the cost of a worse performance.   \n289 We test in the following the same setting for varying number of epochs to show the stability of our   \n290 method for various training budgets. For simplicity, we restrict the analysis to a linear temperature   \n291 decay $( \\gamma = 1 )$ ). In Figure 3(b), we show the disadvantage of our schedule: the validation error remains   \n292 high for the most number of epochs during training, converging only very late compared to methods   \n293 like cyclic learning rate or step decay (see Section 3.2). For instance, in contrast to a cyclic learning   \n294 rate schedules, our method does not show a good anytime performance. On the one hand, cyclic   \n295 temperatures could also work, but need to be evaluated separately, thus leaving this as topic of future   \n296 research. We also show in the APPENDIX that our method is independent of the initial learning   \n297 rate as long as the first few optimization steps do not lead to a diverged network. We believe that   \n298 finding temperature curves with theoretical bounds is a promising direction for future work to better   \n299 understand the internal effects. For the rest of our work, we use a linear temperature cool down. ",
+        "bbox": [
+            140,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/1f41f5bf1638ea5678f90f1a62d5031f5c947c6ca57d51301f81e6dd0c352816.jpg",
+        "image_caption": [
+            "Figure 3: Training ResNet-32 on CIFAR-10 using a linear target temperature curve and (a) using several values for $\\gamma$ and (b) for varying number of epochs using a linear temperature curve each. We choose the same initial target temperature for all experiments to be 3.17 (i.e. a $8 9 \\%$ chance that an activation has changed), all other hyperparameters, as well as seeds, are kept the same in each experiment set. Top row: measured mean temperature, Middle Row: resulting learning rates, bottom row corresponding top-1 validation error. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            88,
+            818,
+            339
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            150,
+            458,
+            823,
+            484
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            486,
+            825,
+            637
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Comparisons with other Methods ",
+        "text_level": 1,
+        "bbox": [
+            163,
+            654,
+            446,
+            669
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "301 Table 1 shows practical results on three different architectures (simple 4-layer CNN, VGG-16 and   \n302 ResNet-50) on three different data sets (Fashion-MNIST, CIFAR-10, ImageNet). We compare to   \n303 baselines and two automatic LR-schedulers (ABEL and AutoLRS). The experiments confirm that   \n304 we reach, similar to our observations for 1-cycle, comparable generalization performance within a   \n305 restricted training budget (Note though that ABEL uses 200 epochs, unlike the other methods). More   \n306 results are provided in the APPENDIX. ",
+        "bbox": [
+            143,
+            679,
+            825,
+            763
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "07 5 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            155,
+            782,
+            294,
+            799
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The key hypothesis of this paper is that tracking the changes to the nonlinear behavior only can provide us with the information needed for step-size control. Our experiments support this view (for image classification with feed-forward ReLU CNNs, which is the class of techniques we restrict our analysis to at this point). Specifically, performing a simple linear decrease in activation pattern temperature already yields a LR-scheduler with performance comparable to 1-cycle, and distorting the temperature curve towards staying longer in the high-temperature regime at the beginning appears to improve generalization performance slightly (at least for the training time scales examined).The ",
+        "bbox": [
+            171,
+            814,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/5b23b6ace2552c2cc6a319b2e70b52c8003e001d0f5672ffa6cf033cad2b2020.jpg",
+        "table_caption": [
+            "Table 1: Comparison with previous automatic LR-schedulers "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">Setup</td><td colspan=\"2\">Test error</td></tr><tr><td>Data set</td><td>Network</td><td>Epochs</td><td>Method</td><td>Top-1 Error</td></tr><tr><td>Fashion-MNIST</td><td>4-layer ：ConvNet [50]</td><td>200</td><td>constant LR</td><td>6.95%</td></tr><tr><td>Fashion-MNIST</td><td>4-layer ConvNet [50]</td><td>200</td><td>ActCooLR</td><td>7.29 %</td></tr><tr><td>CIFAR-10</td><td>VGG-16 [44]</td><td>350</td><td> step decay</td><td>6.30% [25]</td></tr><tr><td>CIFAR-10</td><td>VGG-16 [44]</td><td>350</td><td>AutoLRS</td><td>5.87%[25]</td></tr><tr><td>CIFAR-10</td><td>VGG-16 [44]</td><td>200</td><td>ABEL</td><td>7.1% [30]</td></tr><tr><td>CIFAR-10</td><td>VGG-16 [44]</td><td>350</td><td>ActCooLR</td><td>6.82 %</td></tr><tr><td>ImageNet</td><td>ResNet-50[]</td><td>20</td><td>1-cycle</td><td>27.27%</td></tr><tr><td>ImageNet</td><td>ResNet-50 [</td><td>20</td><td>ActCooLR</td><td>27.88%</td></tr></table>",
+        "bbox": [
+            173,
+            109,
+            658,
+            272
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/b75ea31bf02fc0118f82121cb148dbe12a8a6f48bf7cfd51bcd67c8c4f948bc5.jpg",
+        "table_caption": [
+            "Table 2: Test errors for Fig. 3. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Epochs</td><td>Test Error (Top-1)</td></tr><tr><td>10</td><td>37.88%</td></tr><tr><td>30</td><td>18.33%</td></tr><tr><td>50</td><td>11.87%</td></tr><tr><td>70</td><td>10.59%</td></tr><tr><td>90</td><td>9.09%</td></tr><tr><td>110</td><td>8.09%</td></tr><tr><td>130</td><td>7.50%</td></tr><tr><td>150</td><td>7.28%</td></tr><tr><td>170</td><td>7.18%</td></tr><tr><td></td><td>7.15%</td></tr><tr><td>190 210</td><td>6.41%</td></tr></table>",
+        "bbox": [
+            691,
+            122,
+            825,
+            304
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "315 simple Gaussian two-parameter model of Eq. 5 is approximates the temperature well empirically and   \n316 leads to a simpler and more efficient automatic LR-scheduling algorithm than a direct optimization of   \n317 the learning rate. The most important result is probably on the conceptual side: We observe that the   \n318 rather complex LR-curve of a cyclic (or 1-cycle) scheduler appears to just correspond to an annealing   \n319 of the APT. This is reminiscent of simulated annealing methods which use a very similar strategy in   \n320 order to solve combinatorial optimization problems. The logarithmic temperature measure has an   \n321 analogous form to the temperature in the Boltzmann-distribution of a Markov-Chain-Monte-Carlo   \n322 (MCMC) optimizer used there. In this sense, our paper reveals that a good LR-scheduler for SGD just   \n323 performs on the discrete, nonlinear network components a process very similar to simulated annealing.   \n324 More concretely, we would like to point to the results in Fig. 2 which show a smooth transition   \n325 between a linear training regime, with low probability of nonlinear changes and a high-temperature,   \n326 presumably chaotic, regime at the high LRs. By controlling the APT, we can steer training within   \n327 the band of non-linear, but not chaotic learning automatically, and only dive into the purely linear   \n328 regime at the end, thereby plausibly obtaining a quicker convergence. The drop in temperature at   \n329 early training steps is handled automatically, and provides a plausible explanation the utility of initial   \n330 LW-ramp-up in 1-cycle. It is also interesting that the phase boundary drifts only slowly after this,   \n331 with constant width, but depends more strongly on the LR-schedule (and data set) used. ",
+        "bbox": [
+            138,
+            338,
+            825,
+            574
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Limitations and future work: Our consequential findings are empirical; we do not have an analytical derivation of why the training process has the observed properties, or why the proposed temperature curves reach high performance levels. Our empirical observations are consistent over several data sets and rather different CNN architectures. Nonetheless, a broader study on a large corpus of models and architectures, as well as examining applications beyond image recognition and feed-forward CNNs, is an important next step for future work. Further, a predictive theoretical model of the statistical dynamics of activation patterns under parameter trajectories and exploring a closer connection of SGD and MCMC optimization would be interesting avenues for future work. ",
+        "bbox": [
+            165,
+            580,
+            825,
+            691
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "340 Broader Impact ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            722,
+            310,
+            738
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "341 From an application perspective, our paper aims at improvements in learning time scheduling, such   \n342 that fast-training schedulers similar to 1-cycle can be used with little or no tuning of hyperparameters.   \n343 To the extend of this being successful, we believe that this has a significant positive impact in   \n344 saving time and (electrical) energy in the development and deployment of deep networks (aside   \n345 from potential rebound effects applying to any improvement in efficiency). We advise the reader   \n346 though to use caution in that our key findings are empirical in nature and there is no proof of absence   \n347 of negative effects in terms of costs, and/or a random or systematic loss of accuracy (the same   \n348 applies to related methods, too). The paper should be received as a step forward towards a more   \n349 efficient automatic training schedules, not as a proven solution ready for wide deployment. We would   \n350 correspondingly emphasize the impact of the conceptual view of tracking nonlinear optimization and   \n351 the newly introduced techniques for implementing this over the practical aspects.   \n352 References   \n353 [1] N. Agarwal, R. Anil, E. Hazan, T. Koren, and C. Zhang. Disentangling adaptive gradient methods from   \n354 learning rates. CoRR, abs/2002.11803, 2020. URL https://arxiv.org/abs/2002.11803.   \n355 [2] D. G. T. Barrett and B. Dherin. Implicit gradient regularization. CoRR, abs/2009.11162, 2020. URL   \n356 https://arxiv.org/abs/2009.11162.   \n357 [3] A. G. Baydin, R. Cornish, D. Martínez-Rubio, M. Schmidt, and F. Wood. Online learning rate adaptation   \n358 with hypergradient descent. In 6th International Conference on Learning Representations, ICLR 2018,   \n359 Vancouver, BC, Canada, April 30 - May 3, 2018, Conference Track Proceedings. OpenReview.net, 2018.   \n360 URL https://openreview.net/forum?id=BkrsAzWAb.   \n361 [4] Y. Bengio. Practical recommendations for gradient-based training of deep architectures. In G. Montavon,   \n362 G. B. Orr, and K. Müller, editors, Neural Networks: Tricks of the Trade - Second Edition, volume 7700 of   \n363 Lecture Notes in Computer Science, pages 437–478. Springer, 2012. doi: 10.1007/978-3-642-35289-8\\_26.   \n364 URL https://doi.org/10.1007/978-3-642-35289-8_26.   \n365 [5] Y. Bengio, J. Louradour, R. Collobert, and J. Weston. Curriculum learning. In A. P. Danyluk, L. Bottou,   \n366 and M. L. Littman, editors, Proceedings of the 26th Annual International Conference on Machine Learning,   \n367 ICML 2009, Montreal, Quebec, Canada, June 14-18, 2009, volume 382 of ACM International Conference   \n368 Proceeding Series, pages 41–48. ACM, 2009. doi: 10.1145/1553374.1553380. URL https://doi.org/   \n369 10.1145/1553374.1553380.   \n370 [6] L. Bottou. Online learning and stochastic approximations. On-line learning in neural networks, 17(9):142,   \n371 1998.   \n372 [7] T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry,   \n373 A. Askell, S. Agarwal, A. Herbert-Voss, G. Krueger, T. Henighan, R. Child, A. Ramesh, D. M. Ziegler,   \n374 J. Wu, C. Winter, C. Hesse, M. Chen, E. Sigler, M. Litwin, S. Gray, B. Chess, J. Clark, C. Berner,   \n375 S. McCandlish, A. Radford, I. Sutskever, and D. Amodei. Language models are few-shot learners. In   \n376 H. Larochelle, M. Ranzato, R. Hadsell, M. Balcan, and H. Lin, editors, Advances in Neural Information   \n377 Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS   \n378 2020, December 6-12, 2020, virtual, 2020. URL https://proceedings.neurips.cc/paper/2020/   \n379 hash/1457c0d6bfcb4967418bfb8ac142f64a-Abstract.html.   \n380 [8] D. Choi, C. J. Shallue, Z. Nado, J. Lee, C. J. Maddison, and G. E. Dahl. On empirical comparisons   \n381 of optimizers for deep learning. CoRR, abs/1910.05446, 2019. URL http://arxiv.org/abs/1910.   \n382 05446.   \n383 [9] C. Daniel, J. Taylor, and S. Nowozin. Learning step size controllers for robust neural network training. In   \n384 D. Schuurmans and M. P. Wellman, editors, Proceedings of the Thirtieth AAAI Conference on Artificial   \n385 Intelligence, February 12-17, 2016, Phoenix, Arizona, USA, pages 1519–1525. AAAI Press, 2016. URL   \n386 http://www.aaai.org/ocs/index.php/AAAI/AAAI16/paper/view/11763.   \n387 [10] F. de Roos, C. Jidling, A. Wills, T. B. Schön, and P. Hennig. A probabilistically motivated learning rate   \n388 adaptation for stochastic optimization. CoRR, abs/2102.10880, 2021. URL https://arxiv.org/abs/   \n389 2102.10880.   \n390 [11] L. Dinh, R. Pascanu, S. Bengio, and Y. Bengio. Sharp minima can generalize for deep nets. In D. Precup   \n391 and Y. W. Teh, editors, Proceedings of the 34th International Conference on Machine Learning, ICML   \n392 2017, Sydney, NSW, Australia, 6-11 August 2017, volume 70 of Proceedings of Machine Learning Research,   \n393 pages 1019–1028. PMLR, 2017. URL http://proceedings.mlr.press/v70/dinh17b.html.   \n394 [12] P. Foret, A. Kleiner, H. Mobahi, and B. Neyshabur. Sharpness-aware minimization for efficiently improving   \n395 generalization. CoRR, abs/2010.01412, 2020. URL https://arxiv.org/abs/2010.01412.   \n396 [13] J. Frankle, D. J. Schwab, and A. S. Morcos. The early phase of neural network training. In 8th Interna  \n397 tional Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020.   \n398 OpenReview.net, 2020. URL https://openreview.net/forum?id=Hkl1iRNFwS.   \n399 [14] A. Gotmare, N. S. Keskar, C. Xiong, and R. Socher. A closer look at deep learning heuristics: Learning   \n400 rate restarts, warmup and distillation. In 7th International Conference on Learning Representations, ICLR   \n401 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019. URL https://openreview.net/   \n402 forum?id=r14EOsCqKX.   \n403 [15] P. Goyal, P. Dollár, R. B. Girshick, P. Noordhuis, L. Wesolowski, A. Kyrola, A. Tulloch, Y. Jia, and   \n404 K. He. Accurate, large minibatch SGD: training imagenet in 1 hour. CoRR, abs/1706.02677, 2017. URL   \n405 http://arxiv.org/abs/1706.02677.   \n406 [16] G. Gur-Ari, D. A. Roberts, and E. Dyer. Gradient descent happens in a tiny subspace. CoRR,   \n407 abs/1812.04754, 2018. URL http://arxiv.org/abs/1812.04754.   \n408 [17] D. Han, J. Kim, and J. Kim. Deep pyramidal residual networks. In 2017 IEEE Conference on Computer   \n409 Vision and Pattern Recognition, CVPR 2017, Honolulu, HI, USA, July 21-26, 2017, pages 6307–6315.   \n410 IEEE Computer Society, 2017. doi: 10.1109/CVPR.2017.668. URL https://doi.org/10.1109/CVPR.   \n411 2017.668.   \n412 [18] K. He, X. Zhang, S. Ren, and J. Sun. Delving deep into rectifiers: Surpassing human-level performance on   \n413 imagenet classification. In Proceedings of the IEEE international conference on computer vision, pages   \n414 1026–1034, 2015.   \n415 [19] K. He, X. Zhang, S. Ren, and J. Sun. Identity mappings in deep residual networks. In B. Leibe,   \n416 J. Matas, N. Sebe, and M. Welling, editors, Computer Vision - ECCV 2016 - 14th European Conference,   \n417 Amsterdam, The Netherlands, October 11-14, 2016, Proceedings, Part IV, volume 9908 of Lecture Notes   \n418 in Computer Science, pages 630–645. Springer, 2016. doi: 10.1007/978-3-319-46493-0\\_38. URL   \n419 https://doi.org/10.1007/978-3-319-46493-0_38.   \n420 [20] E. Hoffer, I. Hubara, and D. Soudry. Train longer, generalize better: closing the generalization gap in large   \n421 batch training of neural networks. In I. Guyon, U. von Luxburg, S. Bengio, H. M. Wallach, R. Fergus,   \n422 S. V. N. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems 30:   \n423 Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach,   \n424 CA, USA, pages 1731–1741, 2017. URL https://proceedings.neurips.cc/paper/2017/hash/   \n425 a5e0ff62be0b08456fc7f1e88812af3d-Abstract.html.   \n426 [21] T. M. Hospedales, A. Antoniou, P. Micaelli, and A. J. Storkey. Meta-learning in neural networks: A survey.   \n427 CoRR, abs/2004.05439, 2020. URL https://arxiv.org/abs/2004.05439.   \n428 [22] S. Jastrzebski, Z. Kenton, D. Arpit, N. Ballas, A. Fischer, Y. Bengio, and A. J. Storkey. Three factors   \n429 influencing minima in SGD. CoRR, abs/1711.04623, 2017. URL http://arxiv.org/abs/1711.04623.   \n430 [23] S. Jastrzebski, M. Szymczak, S. Fort, D. Arpit, J. Tabor, K. Cho, and K. Geras. The break-even point   \n431 on optimization trajectories of deep neural networks. In 8th International Conference on Learning   \n432 Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. URL   \n433 https://openreview.net/forum?id=r1g87C4KwB.   \n434 [24] Y. Jiang, B. Neyshabur, H. Mobahi, D. Krishnan, and S. Bengio. Fantastic generalization measures and   \n435 where to find them. In 8th International Conference on Learning Representations, ICLR 2020, Addis   \n436 Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. URL https://openreview.net/forum?   \n437 id=SJgIPJBFvH.   \n438 [25] Y. Jin, T. Zhou, L. Zhao, Y. Zhu, C. Guo, M. Canini, and A. Krishnamurthy. Auto{lrs}: Automatic   \n439 learning-rate schedule by bayesian optimization on the fly. In International Conference on Learning   \n440 Representations, 2021. URL https://openreview.net/forum?id=SlrqM9_lyju.   \n441 [26] D. Kalimeris, G. Kaplun, P. Nakkiran, B. L. Edelman, T. Yang, B. Barak, and H. Zhang. SGD on neural   \n442 networks learns functions of increasing complexity. In H. M. Wallach, H. Larochelle, A. Beygelzimer,   \n443 F. d’Alché-Buc, E. B. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32:   \n444 Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019,   \n445 Vancouver, BC, Canada, pages 3491–3501, 2019. URL https://proceedings.neurips.cc/paper/   \n446 2019/hash/b432f34c5a997c8e7c806a895ecc5e25-Abstract.html.   \n447 [27] D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. In Y. Bengio and Y. LeCun, editors,   \n448 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9,   \n449 2015, Conference Track Proceedings, 2015. URL http://arxiv.org/abs/1412.6980.   \n450 [28] H. Lang, L. Xiao, and P. Zhang. Using statistics to automate stochastic optimization. In   \n451 H. M. Wallach, H. Larochelle, A. Beygelzimer, F. d’Alché-Buc, E. B. Fox, and R. Garnett,   \n452 editors, Advances in Neural Information Processing Systems 32: Annual Conference on Neu  \n453 ral Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC,   \n454 Canada, pages 9536–9546, 2019. URL https://proceedings.neurips.cc/paper/2019/hash/   \n455 e1054bf2d703bca1e8fe101d3ac5efcd-Abstract.html.   \n456 [29] G. Leclerc and A. Madry. The two regimes of deep network training. CoRR, abs/2002.10376, 2020. URL   \n457 https://arxiv.org/abs/2002.10376.   \n458 [30] A. Lewkowycz. How to decay your learning rate. CoRR, abs/2103.12682, 2021. URL https://arxiv.   \n459 org/abs/2103.12682.   \n460 [31] A. Lewkowycz, Y. Bahri, E. Dyer, J. Sohl-Dickstein, and G. Gur-Ari. The large learning rate phase of deep   \n461 learning: the catapult mechanism. CoRR, abs/2003.02218, 2020. URL https://arxiv.org/abs/2003.   \n462 02218.   \n463 [32] Y. Li, C. Wei, and T. Ma. Towards explaining the regularization effect of initial large learning rate in   \n464 training neural networks. In H. M. Wallach, H. Larochelle, A. Beygelzimer, F. d’Alché-Buc, E. B. Fox,   \n465 and R. Garnett, editors, Advances in Neural Information Processing Systems 32: Annual Conference   \n466 on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC,   \n467 Canada, pages 11669–11680, 2019. URL https://proceedings.neurips.cc/paper/2019/hash/   \n468 bce9abf229ffd7e570818476ee5d7dde-Abstract.html.   \n469 [33] Z. Li and S. Arora. An exponential learning rate schedule for deep learning. In 8th International Conference   \n470 on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net,   \n471 2020. URL https://openreview.net/forum?id=rJg8TeSFDH.   \n472 [34] I. Loshchilov and F. Hutter. SGDR: stochastic gradient descent with warm restarts. In 5th International   \n473 Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference   \n474 Track Proceedings. OpenReview.net, 2017. URL https://openreview.net/forum?id=Skq89Scxx.   \n475 [35] I. Loshchilov and F. Hutter. Decoupled weight decay regularization. In 7th International Conference on   \n476 Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.   \n477 URL https://openreview.net/forum?id=Bkg6RiCqY7.   \n478 [36] J. Ma and D. Yarats. On the adequacy of untuned warmup for adaptive optimization. CoRR, abs/1910.04209,   \n479 2019. URL http://arxiv.org/abs/1910.04209.   \n480 [37] R. Müller, S. Kornblith, and G. E. Hinton. When does label smoothing help? In H. M.   \n481 Wallach, H. Larochelle, A. Beygelzimer, F. d’Alché-Buc, E. B. Fox, and R. Garnett, edi  \n482 tors, Advances in Neural Information Processing Systems 32: Annual Conference on Neural   \n483 Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC,   \n484 Canada, pages 4696–4705, 2019. URL https://proceedings.neurips.cc/paper/2019/hash/   \n485 f1748d6b0fd9d439f71450117eba2725-Abstract.html.   \n486 [38] V. Nair and G. E. Hinton. 3d object recognition with deep belief nets. In Y. Bengio, D. Schuur  \n487 mans, J. D. Lafferty, C. K. I. Williams, and A. Culotta, editors, Advances in Neural Information Pro  \n488 cessing Systems 22: 23rd Annual Conference on Neural Information Processing Systems 2009. Pro  \n489 ceedings of a meeting held 7-10 December 2009, Vancouver, British Columbia, Canada, pages 1339–   \n490 1347. Curran Associates, Inc., 2009. URL https://proceedings.neurips.cc/paper/2009/hash/   \n491 6e7b33fdea3adc80ebd648fffb665bb8-Abstract.html.   \n492 [39] P. Nakkiran, G. Kaplun, Y. Bansal, T. Yang, B. Barak, and I. Sutskever. Deep double descent: Where   \n493 bigger models and more data hurt. In 8th International Conference on Learning Representations, ICLR   \n494 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. URL https://openreview.   \n495 net/forum?id=B1g5sA4twr.   \n496 [40] A. Neelakantan, L. Vilnis, Q. V. Le, I. Sutskever, L. Kaiser, K. Kurach, and J. Martens. Adding gradient   \n497 noise improves learning for very deep networks. CoRR, abs/1511.06807, 2015. URL http://arxiv.   \n498 org/abs/1511.06807.   \n499 [41] M. Raghu, J. Gilmer, J. Yosinski, and J. Sohl-Dickstein. SVCCA: singular vector canonical correlation   \n500 analysis for deep learning dynamics and interpretability. In I. Guyon, U. von Luxburg, S. Bengio, H. M.   \n501 Wallach, R. Fergus, S. V. N. Vishwanathan, and R. Garnett, editors, Advances in Neural Information   \n502 Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December   \n503 4-9, 2017, Long Beach, CA, USA, pages 6076–6085, 2017. URL https://proceedings.neurips.cc/   \n504 paper/2017/hash/dc6a7e655d7e5840e66733e9ee67cc69-Abstract.html.   \n505 [42] N. Rahaman, A. Baratin, D. Arpit, F. Draxler, M. Lin, F. A. Hamprecht, Y. Bengio, and A. C. Courville.   \n506 On the spectral bias of neural networks. In K. Chaudhuri and R. Salakhutdinov, editors, Proceedings of the   \n507 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California,   \n508 USA, volume 97 of Proceedings of Machine Learning Research, pages 5301–5310. PMLR, 2019. URL   \n509 http://proceedings.mlr.press/v97/rahaman19a.html.   \n510 [43] M. Rolinek and G. Martius. L4: practical loss-based stepsize adaptation for deep learn  \n511 ing. In S. Bengio, H. M. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Gar  \n512 nett, editors, Advances in Neural Information Processing Systems 31: Annual Conference on   \n513 Neural Information Processing Systems 2018, NeurIPS 2018, December 3-8, 2018, Montréal,   \n514 Canada, pages 6434–6444, 2018. URL https://proceedings.neurips.cc/paper/2018/hash/   \n515 98b17f068d5d9b7668e19fb8ae470841-Abstract.html.   \n516 [44] K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In   \n517 Y. Bengio and Y. LeCun, editors, 3rd International Conference on Learning Representations, ICLR 2015,   \n518 San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015. URL http://arxiv.org/   \n519 abs/1409.1556.   \n520 [45] L. N. Smith and N. Topin. Super-convergence: Very fast training of residual networks using large learning   \n521 rates. CoRR, abs/1708.07120, 2017. URL http://arxiv.org/abs/1708.07120.   \n522 [46] S. L. Smith, B. Dherin, D. G. T. Barrett, and S. De. On the origin of implicit regularization in stochastic   \n523 gradient descent. CoRR, abs/2101.12176, 2021. URL https://arxiv.org/abs/2101.12176.   \n524 [47] N. Srivastava, G. E. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhutdinov. Dropout: a simple   \n525 way to prevent neural networks from overfitting. J. Mach. Learn. Res., 15(1):1929–1958, 2014. URL   \n526 http://dl.acm.org/citation.cfm?id $\\equiv ^ { \\prime }$ 2670313.   \n527 [48] M. Tan and Q. V. Le. Efficientnet: Rethinking model scaling for convolutional neural networks. In   \n528 K. Chaudhuri and R. Salakhutdinov, editors, Proceedings of the 36th International Conference on Machine   \n529 Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of   \n530 Machine Learning Research, pages 6105–6114. PMLR, 2019. URL http://proceedings.mlr.press/   \n531 v97/tan19a.html.   \n532 [49] A. C. Wilson, R. Roelofs, M. Stern, N. Srebro, and B. Recht. The marginal value of adaptive gradient   \n533 methods in machine learning. In I. Guyon, U. von Luxburg, S. Bengio, H. M. Wallach, R. Fergus,   \n534 S. V. N. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems 30:   \n535 Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach,   \n536 CA, USA, pages 4148–4158, 2017. URL https://proceedings.neurips.cc/paper/2017/hash/   \n537 81b3833e2504647f9d794f7d7b9bf341-Abstract.html.   \n538 [50] H. Xiao, K. Rasul, and R. Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine   \n539 learning algorithms. CoRR, abs/1708.07747, 2017. URL http://arxiv.org/abs/1708.07747.   \n540 [51] Z. Xu, A. M. Dai, J. Kemp, and L. Metz. Learning an adaptive learning rate schedule. CoRR,   \n541 abs/1909.09712, 2019. URL http://arxiv.org/abs/1909.09712.   \n542 [52] G. Zhang, C. Wang, B. Xu, and R. B. Grosse. Three mechanisms of weight decay regularization. In 7th   \n543 International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019.   \n544 OpenReview.net, 2019. URL https://openreview.net/forum?id=B1lz-3Rct7.   \n545 [53] H. Zhang, Y. N. Dauphin, and T. Ma. Fixup initialization: Residual learning without normalization. In   \n546 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9,   \n547 2019. OpenReview.net, 2019. URL https://openreview.net/forum?id=H1gsz30cKX.   \n548 [54] Z. Zhu, J. Wu, B. Yu, L. Wu, and J. Ma. The anisotropic noise in stochastic gradient descent: Its behavior   \n549 of escaping from sharp minima and regularization effects. In K. Chaudhuri and R. Salakhutdinov, editors,   \n550 Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019,   \n551 Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pages 7654–7663.   \n552 PMLR, 2019. URL http://proceedings.mlr.press/v97/zhu19e.html. ",
+        "bbox": [
+            140,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            137,
+            77,
+            828,
+            916
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            55,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            137,
+            74,
+            831,
+            921
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            137,
+            92,
+            826,
+            667
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "553 Checklist ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            689,
+            254,
+            705
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            715,
+            330,
+            728
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] This is discussed in Section 5.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] This is discussed in Section 5   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            240,
+            733,
+            825,
+            818
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            821,
+            467,
+            835
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] The assumptions are stated with the results.   \n(b) Did you include complete proofs of all theoretical results? [Yes] Complete proofs can be found in the APPENDIX ",
+        "bbox": [
+            240,
+            839,
+            825,
+            893
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            898,
+            379,
+            911
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] A reference implementation is provided under a free license.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] Training details are specified with the experiments.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] Errors bars are reported for our own experiments, where applicable.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] We specify the used compute in the APPENDIX. ",
+        "bbox": [
+            240,
+            92,
+            825,
+            214
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            214,
+            218,
+            767,
+            232
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [No] We only use freely available data sets.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No] No new assets / data sets were used.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No] No additional data was used.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No] For the data sets we use, this is already discussed in the community. ",
+        "bbox": [
+            240,
+            236,
+            825,
+            359
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            210,
+            364,
+            658,
+            377
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A] Not applicable.   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A] Not applicable.   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] Not applicable. ",
+        "bbox": [
+            240,
+            382,
+            825,
+            464
+        ],
+        "page_idx": 13
+    }
+]

parse/train/yqj6q_eNTJd/yqj6q_eNTJd_middle.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/yqj6q_eNTJd/yqj6q_eNTJd_model.json ADDED Viewed

The diff for this file is too large to render. See raw diff