Add files using upload-large-folder tool

parse/train/HkXWCMbRW/HkXWCMbRW.md

@@ -0,0 +1,363 @@
+# TOWARDS IMAGE UNDERSTANDING FROM DEEP COMPRESSION WITHOUT DECODING
+
+Robert Torfason ETH Zurich, Merantix robertto@ethz.ch
+
+Fabian Mentzer ETH Zurich mentzerf@vision.ee.ethz.ch
+
+Eirikur Agustsson ETH Zurich aeirikur@vision.ee.ethz.ch
+
+Michael Tschannen ETH Zurich michaelt@nari.ee.ethz.ch
+
+Radu Timofte ETH Zurich, Merantix radu.timofte@vision.ee.ethz.ch
+
+Luc Van Gool ETH Zurich, KU Leuven vangool@vision.ee.ethz.ch
+
+# ABSTRACT
+
+Motivated by recent work on deep neural network (DNN)-based image compression methods showing potential improvements in image quality, savings in storage, and bandwidth reduction, we propose to perform image understanding tasks such as classification and segmentation directly on the compressed representations produced by these compression methods. Since the encoders and decoders in DNN-based compression methods are neural networks with feature-maps as internal representations of the images, we directly integrate these with architectures for image understanding. This bypasses decoding of the compressed representation into RGB space and reduces computational cost. Our study shows that accuracies comparable to networks that operate on compressed RGB images can be achieved while reducing the computational complexity up to $2 \times$ . Furthermore, we show that synergies are obtained by jointly training compression networks with classification networks on the compressed representations, improving image quality, classification accuracy, and segmentation performance. We find that inference from compressed representations is particularly advantageous compared to inference from compressed RGB images for aggressive compression rates.
+
+# 1 INTRODUCTION
+
+Neural network-based image compression methods have recently emerged as an active area of research. These methods leverage common neural network architectures such as convolutional autoencoders (Balle et al., 2016; Theis et al., 2017; Rippel & Bourdev, 2017; Agustsson et al., 2017; ´ Li et al., 2017) or recurrent neural networks (Toderici et al., 2015; 2016; Johnston et al., 2017) to compress and reconstruct RGB images, and were shown to outperform JPEG2000 (Taubman & Marcellin, 2001) and even BPG (Bellard) on perceptual metrics such as structural similarity
+
+![](images/a46ded1bba554031b9e35011c7c2a8243894d381244e6fbe2cddba63bc2d7784.jpg)  
+0.3 bits per pixel
+
+Figure 1: We do inference on the learned compressed representation (middle), without decoding.
+
+index (SSIM) (Wang et al. (2004)) and multi-scale structural similarity index (MS-SSIM) (Wang et al. (2003)). In essence, these approaches encode an image $x$ to some feature-map (compressed representation), which is subsequently quantized to a set of symbols $z$ . These symbols are then (losslessly) compressed to a bitstream, from which a decoder reconstructs an image $\hat { x }$ of the same dimensions as $x$ (see Fig. 1 and Fig. 2 (a)).
+
+Besides their outstanding compression performance, learned compression algorithms can—in contrast to engineered compression algorithms—easily be adapted to specific target domains such as stereo images, medical images, or aerial images, leading to even better compression rates on the target domain. In this paper, we explore another promising advantage of learned compression algorithms compared to engineered ones, namely the amenability of the compressed representation they produce to learning and inference without reconstruction (see Fig. 2). Specifically, instead of reconstructing an RGB image from the (quantized) compressed representation and feeding it to a network for inference (e.g., classification or segmentation), one uses a modified network that bypasses reconstruction of the RGB image.
+
+The rationale behind this approach is that the neural network architectures commonly used for learned compression (in particular the encoders) are similar to the ones commonly used for inference, and learned image encoders are hence, in principle, capable of extracting features relevant for inference tasks. The encoder might learn features relevant for inference purely by training on the compression task, and can be forced to learn these features by training on the compression and inference tasks jointly.
+
+![](images/f865b99c8c8cee1a2b786d8fbb4cbc9781e46a7b3b487c565e8e366fba6dc086.jpg)  
+Figure 2: We perform inference of some variable $\hat { y }$ from the compressed representation $z$ instead of the decoded RGB $\hat { x }$ . The grey blocks denote encoders/decoders of a learned compression network and the white block an inference network.
+
+The advantage of learning an encoder for image compression which produces compressed representation containing features relevant for inference is obvious in scenarios where images are transmitted (e.g. from a mobile device) before processing (e.g. in the cloud), as it saves reconstruction of the RGB image as well as part of the feature extraction and hence speeds up processing. A typical use case is a cloud photo storage application where every image is processed immediately upon upload for indexing and search purposes.
+
+Our contributions can be summarized as follows:
+
+• We consider two diverse computer vision tasks from compressed image representations, namely image classification and semantic segmentation. Specifically, we use the image compression autoencoder described in (Theis et al., 2017), and adapt ResNet (He et al., 2015) as well as DeepLab (Chen et al., 2016) for inference from the compressed representations.   
+• We show that image classification from compressed representations is essentially as accurate as from the decompressed images (after re-training on decompressed images), while requiring $1 . 5 \times -$ $2 \times$ fewer operations than reconstructing the image and applying the original classifier.   
+• Further results indicate that semantic segmentation from compressed representations is as accurate as from decompressed images at moderate compression rate, while being more accurate at aggressive compression rates. This suggests that learned compression algorithms might learn semantic features at these aggressive rates or improve localization. Segmentation from compressed representation requires significantly fewer operations than segmentation from decompressed images.   
+• When jointly training for image compression and classification, we observe an increase in SSIM and MS-SSIM and, at the same time, an improved segmentation and classification accuracy.   
+• Our method only requires minor changes in the original image compression and classfication/segmentation networks, and slight changes in the corresponding training procedures.
+
+The remainder of the paper is organized as follows. We give an overview over related work in Section 2. In Section 3, we introduce the deep compression architecture we use and in Section 4 we propose a variant of ResNet (He et al., 2015) amenable to compressed representations. We present and evaluate our methods for image classification and semantic segmentation from compressed representations in Sections 4 and 5, respectively, along with baselines on compressed RGB images. In Section 6, we then address joint training of image compression and classification from compressed representations. Finally, we discuss our findings in Section 7.
+
+# 2 RELATED WORK
+
+In the literature there are a few examples of learning from features extracted from images compressed by engineered codecs. Classification of compressed hyperspectral images was studied in (Hahn et al., 2014; Aghagolzadeh & Radha, 2015). Recently, Fu & Guimaraes (2016) proposed an algorithm based on Discrete Cosine Transform (DCT) to compress the images before feeding them to a neural net for reportedly a 2 to $1 0 \times$ speed up of the training with minor image classification accuracy loss. Javed et al. (2017) provide a critical review on document image analysis techniques directly in the compressed domain. To our knowledge, inference from compressed representations produced by learned image compression algorithms has not been considered before.
+
+In the context of video analysis, different approaches for inference directly from compressed video (obtained using engineered codecs) were proposed, see (Babu et al., 2016) for an overview. The temporal structure of compressed video streams naturally lends itself to feature extraction for many inference tasks. Examples include video classification (Biswas & Babu, 2013; Chadha et al., 2017) and action recognition (Yeo et al., 2008; Kantorov & Laptev, 2014).
+
+We propose a method that does inference on top of a learned feature representation and hence has a direct relation to unsupervised feature learning using autoencoders. Hinton & Salakhutdinov (2006) proposed a dimensionality reduction scheme using autoencoders to learn robust image features that can be used for classification and regression. A more robust dimensionality reduction was proposed by Vincent et al. (2008) and Rifai et al. (2011) by using denoising autoencoders and by penalizing the Jacobian of the learned representation, respectively, for more robust/stable features. Masci et al. (2011) proposed convolutional autoencoders to learn hierarchical features.
+
+Finally, compression artifacts from both learned and engineered compression algorithms will compromise the performance of inference algorithms. The effect of JPEG compression artifacts on image classification using neural networks was studied in (Dodge & Karam, 2016).
+
+# 3 LEARNED DEEPLY COMPRESSED REPRESENTATION
+
+# 3.1 DEEP COMPRESSION ARCHITECTURE
+
+For image compression, we use the convolutional autoencoder proposed in (Theis et al., 2017) and a variant of the training procedure described in (Agustsson et al., 2017), using scalar quantization. We refer to Appendix A.1 for more details. We note here that the encoder of the convolutional autoencoder produces a compressed representation (feature map) of dimensions $w / 8 \times h / 8 \times C$ , where $w$ and $h$ are the spatial dimensions of the input image, and the number of channels $C$ is a hyperparameter related to the rate $R$ . For input RGB images with spatial dimensions $2 2 4 \times 2 2 4$ the computational complexity of the encoder and the decoder is $3 . 5 6 \cdot 1 0 ^ { 9 }$ and $2 . 8 5 \cdot 1 0 ^ { 9 }$ FLOPs, respectively.
+
+Quantizing the compressed representation imposes a distortion $D$ on $\hat { x }$ w.r.t. $x$ , i.e., it increases the reconstruction error. This is traded for a decrease in entropy of the quantized compressed representation $z$ which leads to a decrease of the length of the bitstream as measured by the rate $R$ . Thus, to train the image compression network, we minimize the classical rate-distortion trade-off $D + \beta R$ . As a metric for $D$ , we use the mean squared error (MSE) between $x$ and $\hat { x }$ and we estimate $R$ using $H ( q )$ . $H ( q )$ is the entropy of the probability distribution over the symbols and is estimated using a histogram of the probability distribution (see (Agustsson et al., 2017) for details). We control the trade-off between MSE and the entropy by adjusting $\beta$ . For each $\beta$ we get an operating point where the images have a certain bit rate, as measured by bits per pixel (bpp), and corresponding MSE. To better control the bpp, we introduce the target entropy $H _ { t }$ to formulate our loss:
+
+$$
+\mathcal { L } _ { c } = \mathbf { M S E } ( \boldsymbol { x } , \hat { \boldsymbol { x } } ) + \beta \operatorname* { m a x } \left( H ( \boldsymbol { q } ) - H _ { t } , 0 \right)
+$$
+
+We train compression networks for three different bpp operating points by adjusting the compression network hyperparameters. We obtain three operating points at 0.0983 bpp, 0.330 bpp and 0.635 $\mathsf { b p p } ^ { 1 }$ . On the ILSVRC2012 data, these operating points outperform JPEG and the newer JPEG2000 on the perceptual metrics SSIM and MS-SSIM. Appendix A.2 shows plots comparing the operating points to JPEG and JPEG2000 for different similarity metrics and discusses the metrics themselves.
+
+A visualization of the learned compression can be seen in Fig. 1, where we show an RGB-image along with the visualization of the corresponding compressed representation (showing a subset of the channels). For more visualizations of the compressed representations see Appendix A.2.
+
+# 4 IMAGE CLASSIFICATION FROM COMPRESSED REPRESENTATIONS
+
+# 4.1 RESNET FOR RGB IMAGES
+
+For image classification from RGB images we use the ResNet-50 (V1) architecture (He et al., 2015). It is composed of so-called bottleneck residual units where each unit has the same computational cost regardless of the spatial dimension of the input tensor (with the exception of blocks that subsample spatially, and the root-block). The network is fully convolutional and its structure can be seen in Table 1 for inputs with spatial dimension $2 2 4 \times 2 2 4$ .
+
+Following the architectural recipe of He et al. (2015), we adjust the number of 14x14 (conv4 x) blocks to obtain ResNet-71, an intermediate architecture between ResNet-50 and ResNet-101 (see Table 1).
+
+# 4.2 RESNET FOR COMPRESSED REPRESENTATIONS
+
+For input images with spatial dimension $2 2 4 \times 2 2 4$ , the encoder of the compression network outputs a compressed representation with dimensions $2 8 \times 2 8 \times C$ , where $C$ is the number of channels. We propose a simple variant of the ResNet architecture to use this compressed representation as input. We refer to this variant as cResNet- $k$ , where c stands for “compressed representation” and $k$ is the number of convolutional layers in the network. These networks are constructed by simply “cutting off” the front of the regular (RGB) ResNet. We simply remove the root-block and the residual layers that have a larger spatial dimension than $2 8 \times 2 8$ . To adjust the number of layers $k$ , we again follow the architectural recipe of He et al. (2015) and only adjust the number of $1 4 \times 1 4$ $\bf { \tau } ( o n v 4 . x )$ residual blocks.
+
+Employing this method, we get 3 different architectures: (i) cResNet-39 is ResNet-50 with the first 11 layers removed as described above, significantly reducing computational cost; (ii) cResNet-51 and (iii) cResNet-72 are then obtained by adding $1 4 \times 1 4$ residual blocks to match the computational cost of ResNet-50 and ResNet-71, respectively (see last column of Table 1).
+
+A description of these architectures and their computational complexity is given in Table 1 for inputs with spatial dimension $2 8 \times 2 8$ .
+
+Table 1: Structure of the ResNet and the cResNet architectures in terms of of residual block types, their number, and their associated spatial dimension. Numbers are reported for ResNet-networks with RGB images of spatial dimensions $2 2 4 \times 2 2 4$ as input, and for cResNet-networks with compressed representations of spatial dimensions $2 8 \times 2 8$ as inputs. For a detailed description of the blocks see Appendix A.3   
+
+<table><tr><td>Network</td><td></td><td></td><td>root conv2_x conv3_x conv4_x conv5_x FLOPs 56 × 56 28× 2814×147×7[×109]</td><td></td><td></td><td></td></tr><tr><td>ResNet-50</td><td>yes</td><td>3</td><td>4</td><td>6</td><td>3</td><td>3.86</td></tr><tr><td>ResNet-71</td><td>yes</td><td>3</td><td>4</td><td>13</td><td>3</td><td>5.38</td></tr><tr><td>cResNet-39</td><td>no</td><td>none</td><td>4</td><td>6</td><td>3</td><td>2.95</td></tr><tr><td>cResNet-51</td><td>no</td><td>none</td><td>4</td><td>10</td><td>3</td><td>3.83</td></tr><tr><td>cResNet-72</td><td>no</td><td>none</td><td>4</td><td>17</td><td>3</td><td>5.36</td></tr></table>
+
+1We obtain the bpp of an operating point by averaging the bpp of all images in the validation set.
+
+# 4.3 BENCHMARK
+
+We use the ImageNet dataset from the Large Scale Visual Recognition Challenge 2012 (ILSVRC2012) (Russakovsky et al., 2014) to train our image classification networks and our compression network. It consists of 1.28 million training images and $5 0 \mathrm { k }$ validation images. These images are distributed across 1000 diverse classes. For image classification we report top-1 classification accuracy and top-5 classification accuracy on the validation set on $2 2 4 \times 2 2 4$ center crops for RGB images and $2 8 \times 2 8$ center crops for the compressed representation.
+
+# 4.4 TRAINING PROCEDURE
+
+Given a trained compression network, we keep the compression network fixed while training the classification network, both when starting from compressed representations and from reconstructed compressed RGB images. For the compressed representations, we feed the output of the fixed encoder (the compressed representation) as input to the cResNets (decoder is not needed). When training on the reconstructed compressed RGB images, we feed the output of the fixed encoderdecoder (RGB image) to the ResNet. This is done for each operating point reported in Section 3.1.
+
+For training we use the standard hyperparameters and a slightly modified pre-processing procedure from He et al. (2015), described in detail in in Appendix A.4. To speed up training we decay the learning rate at a $3 . 7 5 \times$ faster speed than in He et al. (2015).
+
+# 4.5 CLASSIFICATION RESULTS
+
+![](images/2cfe3168b00a0ff67e1045a6568a68e71c067476d334d8d99aaa5dea260e76f2.jpg)  
+Figure 3: Top-5 accuracy on the validation set for different architectures and input types at each operating point. Results are shown for ResNet-50 (where reconstructed/decoded RGB images are used as input) and for cResNet-51 and cResNet-39 (where compressed representations are used as input).
+
+In Table 2 and in Fig. 3 the results for the classification accuracy of the different architectures at each operating point is listed, both classifying from the compressed representation and the corresponding reconstructed compressed RGB images.
+
+Fig. 3 shows validation curves for ResNet-50, cResNet-51, and cResNet-39. For the 2 classification architectures with the same computational complexity (ResNet-50 and cResNet-51), the validation curves at the 0.635 bpp compression operating point almost coincide, with ResNet-50 performing slightly better. As the rate (bpp) gets smaller this performance gap gets smaller. Table 2 shows the classification results when the different architectures have converged. At the 0.635 bpp operating point, ResNet-50 only performs $0 . 5 \%$ better in top-5 accuracy than cResNet-51, while for the 0.0983 bpp operating point this difference is only $0 . 3 \%$ .
+
+Using the same pre-processing and the same learning rate schedule but starting from the original uncompressed RGB images yields $8 9 . 9 6 \%$ top-5 accuracy. The top-5 accuracy obtained from the compressed representation at the 0.635 bpp compression operating point, $8 7 . 8 \bar { 5 } \%$ , is even competitive with that obtained for the original images at a significantly lower storage cost. Specifically, at 0.635 bpp the ImageNet dataset requires 24.8 GB of storage space instead of $1 4 4 \mathrm { G B }$ for the original version, a reduction by a factor $5 . 8 \times$ .
+
+Table 2: Image classification accuracies after 28 epochs for the $3 . 7 5 \times$ training rate schedule employed and image segmentation performance for the Deeplab training rate schedule. For each operating point the inputs to ResNet-networks are reconstructed/decoded RGB images and inputs to cResNet-networks are compressed representations. For comparison we show the results with the same training settings, but starting from the original RGB images, in the top row.
+
+<table><tr><td colspan="4">bpp Network architecture Top 5 acc.[%] Top1acc.[%] mIoU[%]</td></tr><tr><td></td><td>Resnet-50</td><td>89.96 71.06</td><td>65.75</td></tr><tr><td rowspan="3">509.3</td><td>ResNet-50</td><td>88.34 68.26</td><td>62.97</td></tr><tr><td>cResNet-51</td><td>87.85 67.68</td><td>62.86</td></tr><tr><td>cResNet-39 87.47</td><td>67.17</td><td>61.85</td></tr><tr><td rowspan="3">0050</td><td>ResNet-50</td><td>86.25 65.18</td><td>60.75</td></tr><tr><td>cResNet-51</td><td>85.87 64.78</td><td>61.12</td></tr><tr><td>cResNet-39</td><td>85.46 64.14</td><td>60.78</td></tr><tr><td rowspan="6">£8600</td><td>ResNet-50</td><td>78.52 55.30</td><td>52.97</td></tr><tr><td>cResNet-51</td><td>78.20 55.18</td><td>54.62</td></tr><tr><td>cResNet-39</td><td>77.65 54.31</td><td>53.51</td></tr><tr><td>ResNet-71</td><td>79.28 56.23</td><td>54.55</td></tr><tr><td>cResNet-72</td><td>79.02 55.82</td><td>55.78</td></tr><tr><td></td><td></td><td></td></tr></table>
+
+To show the computational gains, we plot the top-5 classification accuracy as a function of computational complexity for the 0.0983 bpp compression operating point in Fig. 6. This is done by classification using different architectures that each has an associated computational complexity. The top-5 accuracy of each of these architectures is then plotted as a function of their computational complexity. For the compressed representation we do this for the architectures cResNet-39, cResNet-51 and cResNet-72. For the reconstructed compressed RGB images we used the ResNet-50 and the ResNet-71 architectures.
+
+Looking at a fixed computational cost, the reconstructed compressed RGB images perform about $0 . 2 5 \%$ better. Looking at a fixed classification cost, inference from the compressed representation costs about $0 . 6 \cdot 1 0 ^ { 9 }$ FLOPs more. However when accounting for the decoding cost at a fixed classification performance, inference from the reconstructed compressed RGB images costs $2 . 2 \cdot 1 0 ^ { 9 }$ FLOPs more than inference from the compressed representation.
+
+# 5 SEMANTIC SEGMENTATION FROM COMPRESSED REPRESENTATIONS
+
+# 5.1 DEEP METHOD
+
+For semantic segmentation we use the ResNet-based Deeplab architecture (Chen et al., 2016) and our implementation is adapted using the codes from DeepLab-ResNet-TensorFlow2. The cResNet and ResNet image classification architectures from Sections 4.1 and 4.2, are re-purposed with atrous convolutions, where the filters are upsampled instead of downsampling the feature maps. This is done to increase their receptive field and to prevent aggressive subsampling of the feature maps, as described in (Chen et al., 2016). For segmentation the ResNet architecture is restructured such that the output feature map has $8 \times$ smaller spatial dimension than the original RGB image (instead subsampling by a factor $3 2 \times$ like for classification). When using the cResNets the output feature map has the same spatial dimensions as the input compressed representation (instead of subsampling $4 \times$ like for classification). This results in comparable sized feature maps for both the compressed representation and the reconstructed RGB images. Finally the last 1000-way classification layer of these classification architectures is replaced by an atrous spatial pyramid pooling (ASPP) with four parallel branches with rates $\{ 6 , 1 2 , 1 \bar { 8 } , 2 4 \}$ , which provides the final pixel-wise classification.
+
+# 5.2 BENCHMARK
+
+The PASCAL VOC-2012 dataset (Everingham et al. (2015)) for semantic segmentation was used for image segmentation tasks. It has 20 object foreground classes and 1 background class. The dataset consists of 1464 training and 1449 validation images. In every image, each pixel is annotated with one of the $2 0 + 1$ classes. The original dataset is furthermore augmented with extra annotations provided by Hariharan et al. (2011), so the final dataset has 10,582 images for training and 1449 images for validation. All performance is measured on pixelwise intersection-over-union (IoU) averaged over all the classes, or mean-intersection-over-union (mIoU) on the validation set.
+
+# 5.3 TRAINING PROCEDURE
+
+The cResNet/ResNet networks are pre-trained on the ImageNet dataset using the procedure described in Section 4.4 on the image classification task, the encoder and decoder are fixed as in Section 4.4. The architectures are then adapted with dilated convolutions, cResNet-d/ResNet-d, and finetuned on the semantic segmentation task.
+
+For the training of the segmentation architecture we use the same settings as in Chen et al. (2016) with a slightly modified pre-processing procedure as described in Appendix A.5.
+
+# 5.4 SEGMENTATION RESULTS
+
+![](images/9f0702481e57bc235bd172c7669ced5c132247161a090e6a17bd9e2229ca7196.jpg)  
+Figure 4: mIoU performance on the validation set for different architectures and input types at each operating point. Results shown for ResNet-50-d (where reconstructed/decoded RGB images are used as input), and for cResNet-51-d and cResNet-39-d (where compressed representations are used as input).
+
+Table 2 and Fig. 4 list the results of the different architectures for semantic segmentation at each operating point, both for segmentation from the compressed representation and the corresponding reconstructed compressed RGB images. Unlike classification, for semantic segmentation ResNet50-d and cResNet-51-d perform equally well at the 0.635 bpp compression operating point. For the 0.330 bpp operating point, segmentation from the compressed representation performs slightly better, $0 . 3 \hat { 7 } \%$ , and at the 0.0983 bpp operating point segmentation from the compressed representation performs considerably better than for the reconstructed compressed RGB images, by $1 . { \bar { 6 } } 5 \%$ .
+
+Fig. 5 shows the predicted segmentation visually for both the cResNet-51-d and the ResNet-50-d architecture at each operating point. Along with the segmentation it also shows the original uncompressed RGB image and the reconstructed compressed RGB image. These images highlight the challenging nature of these segmentation tasks, but they can nevertheless be performed using the compressed representation. They also clearly indicate that the compression affects the segmentation, as lowering the rate (bpp) progressively removes details in the image. Comparing the segmentation from the reconstructed RGB images to the segmentation from the compressed representation visually, they perform similar. More visual examples are shown in Appendix A.6.
+
+In Fig. 6 we report the mIoU validation performance as a function of computational complexity for the 0.0983 bpp compression operating point. This is done in the same way as in Section 4, using different architectures with different computational complexity, but for segmentation. Here, even without accounting for the decoding cost of the reconstructed images, the compressed representation performs better. At a fixed computational cost, segmentation from the compressed representation gives about $0 . 7 \%$ better mIoU. And at a fixed mIoU the computational cost is about $3 . 3 \cdot 1 0 ^ { 9 }$ FLOPs lower for compressed representations. Accounting for the decoding costs this difference becomes $6 . 1 \cdot 1 0 ^ { 9 }$ FLOPs. due to the nature of the dilated convolutions and the increased feature map size the relative computational gains for segmentation are not as pronounced as for classification.
+
+![](images/e44de8ef63de2b87e55484cf04da4b14cd64fc6226bd5a4b8c283fc7eba37528.jpg)  
+Figure 5: Top: Reconstructed/decoded RGB images at different compression operating points. Middle: Predicted segmentation mask starting from reconstructed/decoded RGB images using ResNet50-d architecture. Bottom: Predicted segmentation mask starting from compressed representation using cResNet-51-d architecture. Left: Original RGB image and the ground truth segmentation mask.
+
+# 6 JOINT TRAINING FOR COMPRESSION AND IMAGE CLASSIFICATION
+
+# 6.1 FORMULATION
+
+To train for compression and classification jointly, we combine the compression network and the cResNet-51 architecture. An overview of the setup can be seen in Fig. 2 b) where all parts, encoder, decoder, and inference network, are trained at the same time. The compressed representation is fed to the decoder to optimize for mean-squared reconstruction error and to a cResNet-51 network to optimize for classification using a cross-entropy loss. The combined loss function takes the form
+
+$$
+\mathcal { L } _ { c } = \gamma \left( \mathbf { M S E } ( x , \hat { x } ) + \beta \operatorname* { m a x } { \left( H ( q ) - H _ { t } , 0 \right) } \right) + \ell _ { c e } ( y , \hat { y } ) ,
+$$
+
+where the loss terms for the compression network, $\mathbf { M S E } ( x , \hat { x } ) + \beta \operatorname* { m a x } \left( H ( q ) - H _ { t } , 0 \right)$ , are the same as in training for compression only (see Eq. 1). $\ell _ { c e }$ is the cross-entropy loss for classification. $\gamma$ controls the trade-off between the compression loss and the classification loss.
+
+When training the cResNet-51 networks for image classification as described in Section 4.4 the compression network is fixed (after having been previously trained as described in Section 3.1). When doing joint training, we first initialize the compression network and the classification network from a trained state obtained as described in Section 3 and 4. After initialization the networks are both finetuned jointly. We initialize from a trained state and our learning rate schedule is short and does not perturb the weights too much from their initial state so we call this finetuning. For a detailed description of hyperparameters used and the training schedule see Appendix A.8.
+
+To control that the change in classification accuracy is not only due to (1) a better compression operating point or (2) the fact that the cResNet is trained longer, we do the following. We obtain a new operating point by finetuning the compression network only using the schedule described above. We then train a cResNet-51 on top of this new operating point from scratch. Finally, keeping the compression network fixed at the new operating point, we train the cResNet-51 for 9 epochs according to the training schedule above. This procedure controls (1) and (2), and we use it to compare to the joint finetuning.
+
+![](images/0b6d7e4230a132d4e546da6ed279ec3b78f5fed058d84a9dacd39fe1c8329f06.jpg)  
+Figure 6: Inference performance at the 0.0983 bpp operating point at different computational complexities, for both compressed representations and RGB images. We report the computational cost of the inference networks only and for reconstructed RGB images we also show the inference cost along with the decoding cost. For runtime benchmarks see Appendix A.9
+
+![](images/a9f9653f60d8aaba38d537e5dbeeee5571c30a23309af55d4fd2db0e36d3e0d2.jpg)  
+Figure 7: Showing how classification and segmentation performance improves by finetuning (ft.) the compression network only and the compression network and the classification network jointly. The dots show how the performance “moves up” from the baseline performance when finetuning. The baseline is obtained using fixed compression operating points.
+
+To obtain segmentation results we take the jointly trained network, fix the compression operating point and adopt the jointly finetuned classification network for segmentation (cResNet-51-d). It is then trained the same way as in Section 5.3. The difference to Section 5.3 is therefore only the pre-trained network.
+
+# 6.2 JOINT TRAINING RESULTS
+
+First, we observe that training the compression and segmentation networks jointly as described in Section 6.1 does not affect the compression performance significantly. In more detail, joint training increases the compression performance on the perceptual metrics MS-SSIM and SSIM by a small amount and decreases the PSNR slightly (high is good for all these metrics), see Appendix A.7.
+
+In Fig. 7 we show how the classification and segmentation metrics change when finetuning the networks (using cResNet-51). It can be seen that the classification and segmentation results “move up” from the baseline through finetuning. By finetuning the compression network only, we get a slight improvement in performance for the classification task but almost no improvements for the segmentation task. However, when training jointly the improvement for classification are larger and we get a significant improvement for segmentation. It is interesting to note that for the 0.635 bpp operating point the classification performance is similar for training the network jointly and training the compression network only, but when using these operating points for segmentation the difference is considerable.
+
+Considering the 0.0983 bpp operating point and looking at the improvements in terms of computational complexity shown in Fig. 6, we see that training the networks jointly, compared to the training only the compression network, we improve classification by $2 \%$ , a performance gain which would require an additional $7 5 \%$ of computational complexity of cResNet-51. In a similar way, the segmentation performance after training the networks jointly is $1 . 7 \%$ better in mIoU than training only the compression network. Translating this to computational complexity using Fig. 6, to get this performance by adding layers to the netowork would require an additional $4 0 \%$ of computational complexity of cResNet-51.
+
+# 7 DISCUSSION
+
+We proposed and explored inference when starting directly from learned compressed representations without the need to decode, for two fundamental computer vision tasks: classification and semantic segmentation of images.
+
+In our experiments we departed from a very recent state-of-the-art deep compression architecture proposed by Theis et al. (2017) and showed that the obtained compressed representations can be easily fed to variants of standard state-of-the-art DNN architectures while achieving comparable performance to the unmodified DNN architectures working on the decoded/reconstructed RGB images (see Fig. 6). In particular, only minor changes in the training procedures and hyperparameters of the original compression and classification/segmentation networks were necessary to obtain our results.
+
+The main strong points of the proposed method for image understanding from deep compression without decoding are the following:
+
+Runtime Our approach saves decoding time and also DNN inference time as the DNN adapted models can be of smaller depth than those using the decoded RGB images for comparable performance.
+
+Memory Removing the need for reconstructing the image is a feat with large potential for real-time memory constrained applications which use specialized hardware such as in the automotive industry. Complementary, we have the benefit of shallower DNN models and aggressive compression rates (low bpp) with good performance.
+
+Robustness The approach was successfully validated for image classification and semantic segmentation with minimal changes in the specialized DNN models, which make us to believe that the approach can be extended to most of the related image understanding tasks, such as object detection or structure-from-motion.
+
+Synergy The joint training of compression and inference DNN models led to synergistic improvements in both compression quality and classification/segmentation accuracy.
+
+Performance According to our experiments and the top performance achieved, compressed representations are a promising alternative to the largely common use of decoded images as starting point in image understanding tasks.
+
+At the same time the approach has a couple of shortcomings:
+
+Complexity In comparison with the current standard compression methods (such as JPEG, JPEG2000) the deep encoder we used and the learning process have higher time and memory complexities. However, research on deep compression is in its infancy while techniques such as JPEG are matured. Recently, Rippel & Bourdev (2017) have shown that deep compression algorithms can achieve the same or higher (de)compression speeds as standard compression algorithms on GPUs. As more and more devices are being equipped with dedicated deep learning hardware, deep compression could become commonplace.
+
+Performance The proposed approach is particularly suited for aggressive compression rates (low bpp) and wherever the memory constraints and storage are critical. Medium and low bpp compression rates are also the regime where deep compression algorithms considerably outperform standard ones.
+
+Extending our method for learning from compressed representation to other computer vision tasks is an interesting direction for future work. Furthermore, gaining a better understanding of the features/compressed representations learned by image compression networks might lead to interesting applications in the context of unsupervised/semisupervised learning.
+
+# ACKNOWLEDGMENTS
+
+This work was partly supported by ETH Zurich General Fund (OK) and by NVIDIA through a hardware grant.
+
+# REFERENCES
+
+Mohammad Aghagolzadeh and Hayder Radha. On hyperspectral classification in the compressed domain. arXiv preprint arXiv:1508.00282, 2015.
+
+Eirikur Agustsson, Fabian Mentzer, Michael Tschannen, Lukas Cavigelli, Radu Timofte, Luca Benini, and Luc Van Gool. Soft-to-hard vector quantization for end-to-end learned compression of images and neural networks. CoRR, abs/1704.00648, 2017.
+
+R Venkatesh Babu, Manu Tom, and Paras Wadekar. A survey on compressed domain video analysis techniques. Multimedia Tools and Applications, 75(2):1043–1078, 2016.
+
+Johannes Balle, Valero Laparra, and Eero P Simoncelli. End-to-end optimization of nonlinear trans- ´ form codes for perceptual quality. arXiv preprint arXiv:1607.05006, 2016.
+
+Fabrice Bellard. BPG Image format. https://bellard.org/bpg/.
+
+Sovan Biswas and R Venkatesh Babu. H. 264 compressed video classification using histogram of oriented motion vectors (homv). In Acoustics, Speech and Signal Processing (ICASSP), 2013 IEEE International Conference on, pp. 2040–2044. IEEE, 2013.
+
+Aaron Chadha, Alhabib Abbas, and Yiannis Andreopoulos. Video classification with cnns: Using the codec as a spatio-temporal activity sensor. arXiv preprint arXiv:1710.05112, 2017.
+
+Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L. Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. CoRR, abs/1606.00915, 2016. URL http://arxiv.org/abs/1606. 00915.
+
+Samuel Dodge and Lina Karam. Understanding how image quality affects deep neural networks. In Quality of Multimedia Experience (QoMEX), 2016 Eighth International Conference on, pp. 1–6. IEEE, 2016.
+
+Mark Everingham, S. M. Eslami, Luc Gool, Christopher K. Williams, John Winn, and Andrew Zisserman. The pascal visual object classes challenge: A retrospective. Int. J. Comput. Vision, 111(1):98–136, January 2015. ISSN 0920-5691. doi: 10.1007/s11263-014-0733-5. URL http: //dx.doi.org/10.1007/s11263-014-0733-5.
+
+Dan Fu and Gabriel Guimaraes. Using compression to speed up image classification in artificial neural networks. 2016.
+
+Priya Goyal, Piotr Dollar, Ross B. Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, ´ Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: training imagenet in 1 hour. CoRR, abs/1706.02677, 2017. URL http://arxiv.org/abs/1706. 02677.
+
+Jurgen Hahn, Simon Rosenkranz, and Abdelhak M Zoubir. Adaptive compressed classification for hyperspectral imagery. In Acoustics, Speech and Signal Processing (ICASSP), 2014 IEEE International Conference on, pp. 1020–1024. IEEE, 2014.
+
+B. Hariharan, P. Arbelez, L. Bourdev, S. Maji, and J. Malik. Semantic contours from inverse detectors. In 2011 International Conference on Computer Vision, pp. 991–998, Nov 2011. doi: 10.1109/ICCV.2011.6126343.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CoRR, abs/1512.03385, 2015. URL http://arxiv.org/abs/1512.03385.
+
+Geoffrey Hinton and Ruslan Salakhutdinov. Reducing the dimensionality of data with neural networks. Science, 313(5786):504 – 507, 2006.
+
+Mohammed Javed, P Nagabhushan, and Bidyut B Chaudhuri. A review on document image analysis techniques directly in the compressed domain. Artificial Intelligence Review, pp. 1–30, 2017.
+
+Nick Johnston, Damien Vincent, David Minnen, Michele Covell, Saurabh Singh, Troy Chinen, Sung Jin Hwang, Joel Shor, and George Toderici. Improved lossy image compression with priming and spatially adaptive bit rates for recurrent networks. arXiv preprint arXiv:1703.10114, 2017.
+
+Vadim Kantorov and Ivan Laptev. Efficient feature extraction, encoding and classification for action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2593–2600, 2014.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014.
+
+Mu Li, Wangmeng Zuo, Shuhang Gu, Debin Zhao, and David Zhang. Learning convolutional networks for content-weighted image compression. arXiv preprint arXiv:1703.10553, 2017.
+
+Jonathan Masci, Ueli Meier, Dan Cires¸an, and Jurgen Schmidhuber. ¨ Stacked Convolutional AutoEncoders for Hierarchical Feature Extraction, pp. 52–59. Springer Berlin Heidelberg, Berlin, Heidelberg, 2011. ISBN 978-3-642-21735-7. doi: 10.1007/978-3-642-21735-7 7. URL https: //doi.org/10.1007/978-3-642-21735-7_7.
+
+Salah Rifai, Pascal Vincent, Xavier Muller, Xavier Glorot, and Yoshua Bengio. Contractive autoencoders: Explicit invariance during feature extraction. In ICML, pp. 833–840. Omnipress, 2011.
+
+Oren Rippel and Lubomir Bourdev. Real-time adaptive image compression. arXiv preprint arXiv:1705.05823, 2017.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael S. Bernstein, Alexander C. Berg, and Fei-Fei Li. Imagenet large scale visual recognition challenge. CoRR, abs/1409.0575, 2014.
+
+David S. Taubman and Michael W. Marcellin. JPEG 2000: Image Compression Fundamentals, Standards and Practice. Kluwer Academic Publishers, Norwell, MA, USA, 2001. ISBN 079237519X.
+
+Lucas Theis, Wenzhe Shi, Andrew Cunningham, and Ferenc Huszar. Lossy image compression with compressive autoencoders. In ICLR 2017, 2017.
+
+George Toderici, Sean M O’Malley, Sung Jin Hwang, Damien Vincent, David Minnen, Shumeet Baluja, Michele Covell, and Rahul Sukthankar. Variable rate image compression with recurrent neural networks. arXiv preprint arXiv:1511.06085, 2015.
+
+George Toderici, Damien Vincent, Nick Johnston, Sung Jin Hwang, David Minnen, Joel Shor, and Michele Covell. Full resolution image compression with recurrent neural networks. arXiv preprint arXiv:1608.05148, 2016.
+
+Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In Proceedings of the 25th International Conference on Machine Learning, ICML $^ { \ ' 0 8 }$ , pp. 1096–1103, New York, NY, USA, 2008. ACM. ISBN 978-1-60558-205-4. doi: 10.1145/1390156.1390294. URL http://doi.acm.org/ 10.1145/1390156.1390294.
+
+Z. Wang, E. P. Simoncelli, and A. C. Bovik. Multiscale structural similarity for image quality assessment. In Asilomar Conference on Signals, Systems Computers, 2003, volume 2, pp. 1398– 1402 Vol.2, Nov 2003.
+
+Zhou Wang, A. C. Bovik, H. R. Sheikh, and E. P. Simoncelli. Image quality assessment: from error visibility to structural similarity. IEEE Transactions on Image Processing, 13(4):600–612, April 2004.
+
+Chuohao Yeo, Parvez Ahammad, Kannan Ramchandran, and S Shankar Sastry. High-speed action recognition and localization in compressed domain videos. IEEE Transactions on Circuits and Systems for Video Technology, 18(8):1006–1015, 2008.
+
+# A APPENDIX
+
+# A.1 COMPRESSION ARCHITECTURE AND TRAINING PROCEDURE
+
+The compression network is an autoencoder that takes an input image $x$ and outputs $\hat { x }$ as the approximation to the input (see Fig. 2 (a)). The encoder has the following structure: It starts with 2 convolutional layers with spatial subsampling by a factor of 2, followed by 3 residual units, and a final convolutional layer with spatial subsampling by a factor of 2. This results in a $w / 8 \times h / 8 \times C$ - dimensional representation, where $w$ and $h$ are the spatial dimensions of $x$ , and the number of channels $C$ is a hyperparameter related to the rate $R$ . This representation is then quantized to a discrete set of symbols, forming a compressed representation, $z$ .
+
+To get the reconstruction $\hat { x }$ , the compressed representation is fed into the decoder, which mirrors the encoder, but uses upsampling and deconvolutions instead of subsampling and convolutions.
+
+To handle the non-differentiability of the quantization step during training, Agustsson et al. (2017) employ a differentiable (soft) approximation of quantization and anneal it to the actual (hard) quantization during training to prevent inversion of the soft quantization approximation. Here, we replace this procedure by a different quantization step, $\bar { Q }$ , which behaves like $\hat { Q }$ in the forward pass but like $\bar { Q }$ in the backward pass (using the notation of (Agustsson et al., 2017)). Note that this is similar to the approach of Theis et al. (2017), who use rounding to integer in forward pass, and the identity function in the backward pass. Like annealing, $\bar { Q }$ prevents inversion of the soft quantization approximation, but facilitates joint training of the autoencoder for image compression with an inference task (see Section 6). Additionally, we chose to use scalar instead of vector quantization (i.e., $p _ { h } = p _ { w } = 1$ in the notation of Agustsson et al. (2017)) to further simplify joint training of compression and inference tasks. This means that each entry of the feature-map is quantized individually.
+
+We train compression networks for three different bpp operating points by choosing different values for $\beta$ , $H _ { t }$ and $C$ . In theory, changing $H _ { t }$ and $\beta$ is enough to change the resulting average bpp of the network, but we found it beneficial to also change $C$ . We obtain three operating points at $0 . 0 9 8 3 \mathrm { b p p }$ $C = 8$ ), 0.330 bpp $C = 1 6$ ) and 0.635 bpp $\bar { ( C = 3 2 ) } ^ { \bar { 1 } }$ 3. We use the Adam optimizer (Kingma & Ba, 2014) with learning rates of $1 e ^ { - 3 }$ , $1 e ^ { - 5 }$ , and $1 e ^ { - 3 }$ for the 0.0983, 0.330 and 0.635 bpp operating points, respectively. We train on the images from the ILSVRC2012 dataset (see Section 4.3), using a batch size of 30. We train each operating point for $6 0 0 \mathrm { k }$ iterations. Fig. 8 depicts the performance of our deep compression models vs. standard JPEG and JPEG2000 compression on ILSVRC2012 data.
+
+# A.2 IMAGE COMPRESSION METRICS, PERFORMANCE AND VISUALIZATION
+
+We use the following metrics to report performance of our image compression networks: PSNR (Peak Signal-to-Noise Ratio) is a standard measure, depending monotonically on mean squared error4. SSIM (Structural Similarity Index, Wang et al. (2004)) and MS-SSIM (Multi-Scale SSIM, Wang et al. (2003)) are metrics proposed to better measure the similarity of images as perceived by humans.
+
+Fig. 8 depicts the performance of our deep compression models vs. standard JPEG and JPEG2000 methods on ILSVRC2012 data on MS-SSIM, SSIM and PSNR. Higher values are always better.
+
+The compressed representations learned in the compression network are visualized in Fig. 9. The original RGB-image is shown along with compressed versions of the RGB image which reconstructed from the compressed representation. In the interest of space we only visualize 4 channels of the compressed representation for each image, even though each operating point has more than 4 channels. We choose the 4 channels with the highest entropy. These visualizations indicate how the networks compress an image, as the rate (bpp) gets lower the entropy cost of the network forces the compressed representation to use fewer quantization centers, as can clearly be seen in Fig. 9. For the most aggressive compression, the channel maps use only 2 centers for the compressed representation.
+
+![](images/859abf6a299d301cccda746d3082845ef6ed56891c1015e200fa4ac5e7291e80.jpg)  
+Figure 8: MS-SSIM, SSIM and PSNR as a function of rate in bpp. Shown for JPEG 2000, JPEG and the reported Deep Compression operating points. Higher is better.
+
+![](images/a96509f9f3f74b994d4a70b4e885475b1161b7f2addcccce9508950a1afb942e.jpg)  
+Figure 9: For each operating point we show the reconstructed/decoded image along with the 4 highest entropy channels of the compressed representation. The original RGB image is shown on the left for comparison. The channels of the compressed representation look like quantized downscaled versions of the original image, which motivates doing inference based on them instead of the reconstructed RGB images.
+
+# A.3 ARCHITECTURE TABLE
+
+Table 3 is a more detailed version of Table 1 and shows the detailed structure of the networks used, with the dimensions of the convolutions inside the network shown along with all layers.
+
+Table 3: Structure of the ResNet and the cResNet architectures. The numbers reported are for ResNet-networks where the inputs are RGB images with a spatial dimensions $2 2 4 \times 2 2 4$ and for cResNet-networks where the inputs are compressed representations with spatial dimensions $2 8 \times 2 8$ . Building blocks are shown in brackets, with the numbers of blocks stacked. Downsampling is performed by conv3 1, conv4 1, and conv5 1 with a stride of 2.   
+
+<table><tr><td rowspan=1 colspan=2></td><td rowspan=1 colspan=6>RGB</td><td rowspan=1 colspan=9>Compressed representation</td></tr><tr><td rowspan=1 colspan=1>layer name</td><td rowspan=1 colspan=1>output size</td><td rowspan=1 colspan=6>ResNet-71        ResNet-50</td><td rowspan=1 colspan=3>cResNet-72</td><td rowspan=1 colspan=3>cResNet-51</td><td rowspan=1 colspan=3>cResNet-39</td></tr><tr><td rowspan=2 colspan=1>conv2_x</td><td rowspan=2 colspan=1>56×56</td><td rowspan=1 colspan=6>3x3 max pool, stride 2</td><td rowspan=1 colspan=3></td><td rowspan=2 colspan=3>None</td><td rowspan=2 colspan=3>None</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,643×3,641×1,256</td><td rowspan=1 colspan=1>×3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,643×3,641×1,256</td><td rowspan=1 colspan=1>×3</td><td rowspan=1 colspan=3>None</td></tr><tr><td rowspan=1 colspan=1>conv3_x</td><td rowspan=1 colspan=1>28×28</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,1283×3,1281×1,512</td><td rowspan=1 colspan=1>×4</td><td></td><td rowspan=1 colspan=1>1×1,1283×3,1281×1,512</td><td rowspan=1 colspan=1>×4</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,1283×3,1281×1,512</td><td rowspan=1 colspan=1>×4</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,1283×3,1281×1,512</td><td rowspan=1 colspan=1>×4</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,1283×3,1281×1,512</td><td rowspan=1 colspan=1>×4</td></tr><tr><td rowspan=1 colspan=1>conv4_x</td><td rowspan=1 colspan=1>14×14</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,2563×3,2561×1,1024</td><td rowspan=1 colspan=1>×13</td><td></td><td rowspan=1 colspan=1>1×1,2563×3,2561×1,1024</td><td rowspan=1 colspan=1>×6</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,2563×3,2561×1,1024</td><td rowspan=1 colspan=1>×17</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,25633,2561×1,1024</td><td rowspan=1 colspan=1>×10</td><td></td><td rowspan=1 colspan=1>1×1,2563×3,2561×1,1024</td><td rowspan=1 colspan=1>×6</td></tr><tr><td rowspan=1 colspan=1>conv5_x</td><td rowspan=1 colspan=1>7×7</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,5123×3,5121×1,2048</td><td rowspan=1 colspan=1>×3</td><td></td><td rowspan=1 colspan=1>1×1,5123×3,5121×1,2048</td><td rowspan=1 colspan=1>×3</td><td></td><td rowspan=1 colspan=1>1×1,5123×3,5121×1,2048</td><td rowspan=1 colspan=1>×3</td><td></td><td rowspan=1 colspan=1>1×1,5123×3,5121×1,2048</td><td rowspan=1 colspan=1>×3</td><td></td><td rowspan=1 colspan=1>1×1,5123x3,5121×1,2048</td><td rowspan=1 colspan=1>×3</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1x1</td><td rowspan=1 colspan=15>average pool,1000-d fc,softmax</td></tr><tr><td rowspan=1 colspan=2>FLOPs</td><td rowspan=1 colspan=15>5.38×109         3.86×109        5.36×109         3.83×109        2.95×109</td></tr></table>
+
+# A.4 TRAINING CLASSIFICATION
+
+We use the ResNet implementation from the Slim library in TensorFlow5 with modifications for the custom architectures. For a fair comparison when using different settings we train all classifications networks from scratch in our experiments. For the training we use a batch size 64 and employ the linear scaling rule from Goyal et al. (2017) and use the learning rate 0.025. We employ the same learning rate schedule as in (He et al., 2015), but for faster training iterations we decay the learning rate $3 . 7 5 \times$ faster. We use a constant learning rate that is divided by a factor of 10 at 8, 16, and 24 epochs and we train for a total of 28 epochs.
+
+A stochastic gradient descent (SGD) optimizer is used with momentum 0.9. We use weight decay of 0.0001. For pre-processing we do random-mirroring of inputs, random-cropping of inputs $( 2 2 4 \times 2 2 4$ for RGB images, $2 8 \times 2 8$ for compressed representations) and center the images using per channel mean over the ImageNet dataset.
+
+# A.5 TRAINING SEGMENTATION
+
+For the training of the segmentation architecture we use the same settings as in Chen et al. (2016) with a slightly modified pre-processing procedure. We use batch size 10 and perform $2 0 \mathrm { k }$ iterations for training using SGD optimizer with momentum 0.9. The initial learning rate is 0.001 (0.01 for final classification layer) and the learning rate policy is as follows: at each step the initial learning rate is multiplied by $\begin{array} { r } { ( 1 - \frac { \mathrm { i t e r } } { \mathrm { m a x } \mathrm { . i t e r } } ) ^ { 0 . 9 } } \end{array}$ . We use a weight decay of 0.0005. For preprocessing we do random-mirroring of inputs, random-cropping of inputs $3 2 0 \times 3 2 0$ for RGB images, $4 0 \times 4 0$ for the compressed representation) and center the images using per channel mean over the dataset.
+
+# A.6 SEGMENTATION VISUALIZATION
+
+Fig. 10 shows visual results of segmentation from compressed representation and reconstructed RGB images as in Fig. 5. The performance is visually similar for all operating points except for the 0.0983 bpp operating point in Fig. 10 where the reconstructed RGB image fails to capture the back part of the train, while the compressed representation manages to capture that aspect of the image in the segmentation.
+
+![](images/5186cfc93b465645268f23be69c4820caea0415191593ba5bbb96daf9dbec0e4.jpg)  
+Figure 10: Top: Reconstructed/decoded RGB images at different compression operating points. Middle: Predicted segmentation mask starting from reconstructed/decoded RGB images using ResNet-50-d architecture. Bottom: Predicted segmentation mask starting from compressed representation using cResNet-51-d architecture. Left: Original RGB image and the ground truth segmentation mask.
+
+# A.7 IMAGE COMPRESSION METRICS FOR JOINT TRAINING
+
+In Fig. 11 the compression metric results of finetuning the whole joint network (joint ft.), are compared to finetuning only the compression network (compression ft.). In both cases the same learning rate schedule is used, namely the one described in Section 6.1 Each image shows 4 distinct points along with a baseline for JPEG-2000. These 4 points are:
+
+• joint-1: The joint ft. operating point at the beginning of the finetuning • joint-2: The joint ft. operating point at the end of finetuning • compression-1: the compression ft. operating point at the beginning of the finetuning • compression-2: the compression ft. operating point at the end of finetuning
+
+joint-1 and compression-1 are the same because both joint ft. and compression ft. are initialized from the same starting point. An arrow then shows how the operating point for the joint training moves from joint-1 to joint-2 after finetuning. In the same manner an arrow shows how point compression-1 moves to compression-2 after finetuning.
+
+Fig. 11 shows how the points move in the rate-vs.- $\{ \mathrm { M S S S I M , S S I M , P S N R } \}$ plane. When training, hitting an exact target bpp is difficult due to the noisy nature of the entropy loss. Therefore the points in Fig. 11 do not only move along the y-axis (MS-SSIM, SSIM or PSNR) but also move along the $\mathbf { X }$ -axis (rate). We show the final results for both joint ft. and compression ft. at the same bpp for a fair comparison.
+
+As is evident from Fig. 11 this finetuning procedure improves the image compression metrics in all cases, i.e., they converge at a higher value for a lower bpp. We re-iterate, for all metrics higher values are better. However for SSIM and MS-SSIM the joint ft. improves more than the compression ft. For PSNR, however, the joint ft. improves less than the compression ft. The same effect is consistent for both 0.0983 and the 0.635 bpp operating points.
+
+![](images/258b2d891be1bcf0db85ad493f6d29cc3bf166846a470538b8621f4eb5a4e43c.jpg)  
+Figure 11: Showing how the selected metrics move from the original compression operating point to a different point after finetuning. We show this change when finetuning the compression network only, and then when finetuning the compression network and the classification architecture jointly. Top: 0.635 bpp operating point Bottom: 0.0983 bpp operating point.
+
+# A.8 JOINT TRAINING TRAINING AND HYPERPARAMETERS
+
+For joint training we set the hyperparameters in Eq. 2 to $\gamma = 0 . 0 0 1$ , $\beta = 1 5 0$ and $H _ { t } = 1 . 2 6 5$ for the 0.635 bpp operating point and $\gamma = 0 . 0 0 1$ , $\beta = 6 0 0$ and $H _ { t } = 0 . 8$ for the 0.0983 bpp operating point.
+
+The learning rate schedule is similar to the one used in the image classification setting. It starts with an initial learning rate of 0.0025 that is divided by 10 every 3 epochs using a SGD optimizer with momentum 0.9. The joint network is then trained for a total of 9 epochs.
+
+# A.9 RUNTIMES BENCHMARKS
+
+In Fig. 12 we show the average runtimes (per image) for different setups. This complements Fig. 6 where we showed the theoretical computations for each setup. All benchmarks were run on a GeForce Titan X GPU in TensorFlow v1.3. We used batch size 256 for classification and batch size 20 for segmentation. For RGB images we used the image spatial dimension $2 2 4 \times 2 2 4$ and for the compressed representations we used spatial dimension $2 8 \times 2 8$ (corresponding to a $2 2 4 \times 2 2 4$ input image to the compression network).
+
+![](images/915029c679a8f77270ea6bbeebfdf47015a5949094dbe1d6c9094d62d2a656ae.jpg)  
+Figure 12: Inference performance at the 0.0983 bpp operating point for different architectures, for both compressed representations and reconstructed RGB images. We report the computational runtime (per image) of the inference networks only and for the reconstructed RGB images we also show the runtime for the inference network along with the decoding runtime.

parse/train/HkXWCMbRW/HkXWCMbRW_content_list.json

@@ -0,0 +1,2005 @@
+[
+    {
+        "type": "text",
+        "text": "TOWARDS IMAGE UNDERSTANDING FROM DEEP COMPRESSION WITHOUT DECODING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            684,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Robert Torfason ETH Zurich, Merantix robertto@ethz.ch ",
+        "bbox": [
+            183,
+            170,
+            333,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Fabian Mentzer ETH Zurich mentzerf@vision.ee.ethz.ch ",
+        "bbox": [
+            385,
+            170,
+            566,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Eirikur Agustsson ETH Zurich aeirikur@vision.ee.ethz.ch ",
+        "bbox": [
+            624,
+            170,
+            803,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Michael Tschannen ETH Zurich michaelt@nari.ee.ethz.ch ",
+        "bbox": [
+            183,
+            233,
+            349,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Radu Timofte ETH Zurich, Merantix radu.timofte@vision.ee.ethz.ch ",
+        "bbox": [
+            382,
+            233,
+            591,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Luc Van Gool ETH Zurich, KU Leuven vangool@vision.ee.ethz.ch ",
+        "bbox": [
+            622,
+            233,
+            799,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            313,
+            544,
+            327
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Motivated by recent work on deep neural network (DNN)-based image compression methods showing potential improvements in image quality, savings in storage, and bandwidth reduction, we propose to perform image understanding tasks such as classification and segmentation directly on the compressed representations produced by these compression methods. Since the encoders and decoders in DNN-based compression methods are neural networks with feature-maps as internal representations of the images, we directly integrate these with architectures for image understanding. This bypasses decoding of the compressed representation into RGB space and reduces computational cost. Our study shows that accuracies comparable to networks that operate on compressed RGB images can be achieved while reducing the computational complexity up to $2 \\times$ . Furthermore, we show that synergies are obtained by jointly training compression networks with classification networks on the compressed representations, improving image quality, classification accuracy, and segmentation performance. We find that inference from compressed representations is particularly advantageous compared to inference from compressed RGB images for aggressive compression rates. ",
+        "bbox": [
+            233,
+            343,
+            764,
+            566
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            592,
+            336,
+            608
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural network-based image compression methods have recently emerged as an active area of research. These methods leverage common neural network architectures such as convolutional autoencoders (Balle et al., 2016; Theis et al., 2017; Rippel & Bourdev, 2017; Agustsson et al., 2017; ´ Li et al., 2017) or recurrent neural networks (Toderici et al., 2015; 2016; Johnston et al., 2017) to compress and reconstruct RGB images, and were shown to outperform JPEG2000 (Taubman & Marcellin, 2001) and even BPG (Bellard) on perceptual metrics such as structural similarity ",
+        "bbox": [
+            173,
+            625,
+            825,
+            708
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/a46ded1bba554031b9e35011c7c2a8243894d381244e6fbe2cddba63bc2d7784.jpg",
+        "image_caption": [
+            "0.3 bits per pixel "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            729,
+            810,
+            881
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Figure 1: We do inference on the learned compressed representation (middle), without decoding. ",
+        "bbox": [
+            179,
+            905,
+            813,
+            920
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "index (SSIM) (Wang et al. (2004)) and multi-scale structural similarity index (MS-SSIM) (Wang et al. (2003)). In essence, these approaches encode an image $x$ to some feature-map (compressed representation), which is subsequently quantized to a set of symbols $z$ . These symbols are then (losslessly) compressed to a bitstream, from which a decoder reconstructs an image $\\hat { x }$ of the same dimensions as $x$ (see Fig. 1 and Fig. 2 (a)). ",
+        "bbox": [
+            173,
+            103,
+            823,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Besides their outstanding compression performance, learned compression algorithms can—in contrast to engineered compression algorithms—easily be adapted to specific target domains such as stereo images, medical images, or aerial images, leading to even better compression rates on the target domain. In this paper, we explore another promising advantage of learned compression algorithms compared to engineered ones, namely the amenability of the compressed representation they produce to learning and inference without reconstruction (see Fig. 2). Specifically, instead of reconstructing an RGB image from the (quantized) compressed representation and feeding it to a network for inference (e.g., classification or segmentation), one uses a modified network that bypasses reconstruction of the RGB image. ",
+        "bbox": [
+            174,
+            180,
+            612,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The rationale behind this approach is that the neural network architectures commonly used for learned compression (in particular the encoders) are similar to the ones commonly used for inference, and learned image encoders are hence, in principle, capable of extracting features relevant for inference tasks. The encoder might learn features relevant for inference purely by training on the compression task, and can be forced to learn these features by training on the compression and inference tasks jointly. ",
+        "bbox": [
+            174,
+            367,
+            612,
+            479
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/f865b99c8c8cee1a2b786d8fbb4cbc9781e46a7b3b487c565e8e366fba6dc086.jpg",
+        "image_caption": [
+            "Figure 2: We perform inference of some variable $\\hat { y }$ from the compressed representation $z$ instead of the decoded RGB $\\hat { x }$ . The grey blocks denote encoders/decoders of a learned compression network and the white block an inference network. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            637,
+            193,
+            833,
+            383
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The advantage of learning an encoder for image compression which produces compressed representation containing features relevant for inference is obvious in scenarios where images are transmitted (e.g. from a mobile device) before processing (e.g. in the cloud), as it saves reconstruction of the RGB image as well as part of the feature extraction and hence speeds up processing. A typical use case is a cloud photo storage application where every image is processed immediately upon upload for indexing and search purposes. ",
+        "bbox": [
+            173,
+            486,
+            612,
+            542
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            542,
+            821,
+            584
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions can be summarized as follows: ",
+        "bbox": [
+            176,
+            590,
+            495,
+            604
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We consider two diverse computer vision tasks from compressed image representations, namely image classification and semantic segmentation. Specifically, we use the image compression autoencoder described in (Theis et al., 2017), and adapt ResNet (He et al., 2015) as well as DeepLab (Chen et al., 2016) for inference from the compressed representations.   \n• We show that image classification from compressed representations is essentially as accurate as from the decompressed images (after re-training on decompressed images), while requiring $1 . 5 \\times -$ $2 \\times$ fewer operations than reconstructing the image and applying the original classifier.   \n• Further results indicate that semantic segmentation from compressed representations is as accurate as from decompressed images at moderate compression rate, while being more accurate at aggressive compression rates. This suggests that learned compression algorithms might learn semantic features at these aggressive rates or improve localization. Segmentation from compressed representation requires significantly fewer operations than segmentation from decompressed images.   \n• When jointly training for image compression and classification, we observe an increase in SSIM and MS-SSIM and, at the same time, an improved segmentation and classification accuracy.   \n• Our method only requires minor changes in the original image compression and classfication/segmentation networks, and slight changes in the corresponding training procedures. ",
+        "bbox": [
+            173,
+            611,
+            826,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The remainder of the paper is organized as follows. We give an overview over related work in Section 2. In Section 3, we introduce the deep compression architecture we use and in Section 4 we propose a variant of ResNet (He et al., 2015) amenable to compressed representations. We present and evaluate our methods for image classification and semantic segmentation from compressed representations in Sections 4 and 5, respectively, along with baselines on compressed RGB images. In Section 6, we then address joint training of image compression and classification from compressed representations. Finally, we discuss our findings in Section 7. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            183,
+            344,
+            199
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the literature there are a few examples of learning from features extracted from images compressed by engineered codecs. Classification of compressed hyperspectral images was studied in (Hahn et al., 2014; Aghagolzadeh & Radha, 2015). Recently, Fu & Guimaraes (2016) proposed an algorithm based on Discrete Cosine Transform (DCT) to compress the images before feeding them to a neural net for reportedly a 2 to $1 0 \\times$ speed up of the training with minor image classification accuracy loss. Javed et al. (2017) provide a critical review on document image analysis techniques directly in the compressed domain. To our knowledge, inference from compressed representations produced by learned image compression algorithms has not been considered before. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            328
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the context of video analysis, different approaches for inference directly from compressed video (obtained using engineered codecs) were proposed, see (Babu et al., 2016) for an overview. The temporal structure of compressed video streams naturally lends itself to feature extraction for many inference tasks. Examples include video classification (Biswas & Babu, 2013; Chadha et al., 2017) and action recognition (Yeo et al., 2008; Kantorov & Laptev, 2014). ",
+        "bbox": [
+            174,
+            334,
+            825,
+            404
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose a method that does inference on top of a learned feature representation and hence has a direct relation to unsupervised feature learning using autoencoders. Hinton & Salakhutdinov (2006) proposed a dimensionality reduction scheme using autoencoders to learn robust image features that can be used for classification and regression. A more robust dimensionality reduction was proposed by Vincent et al. (2008) and Rifai et al. (2011) by using denoising autoencoders and by penalizing the Jacobian of the learned representation, respectively, for more robust/stable features. Masci et al. (2011) proposed convolutional autoencoders to learn hierarchical features. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            508
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, compression artifacts from both learned and engineered compression algorithms will compromise the performance of inference algorithms. The effect of JPEG compression artifacts on image classification using neural networks was studied in (Dodge & Karam, 2016). ",
+        "bbox": [
+            176,
+            515,
+            821,
+            558
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 LEARNED DEEPLY COMPRESSED REPRESENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            580,
+            633,
+            597
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 DEEP COMPRESSION ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            614,
+            473,
+            628
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For image compression, we use the convolutional autoencoder proposed in (Theis et al., 2017) and a variant of the training procedure described in (Agustsson et al., 2017), using scalar quantization. We refer to Appendix A.1 for more details. We note here that the encoder of the convolutional autoencoder produces a compressed representation (feature map) of dimensions $w / 8 \\times h / 8 \\times C$ , where $w$ and $h$ are the spatial dimensions of the input image, and the number of channels $C$ is a hyperparameter related to the rate $R$ . For input RGB images with spatial dimensions $2 2 4 \\times 2 2 4$ the computational complexity of the encoder and the decoder is $3 . 5 6 \\cdot 1 0 ^ { 9 }$ and $2 . 8 5 \\cdot 1 0 ^ { 9 }$ FLOPs, respectively. ",
+        "bbox": [
+            173,
+            641,
+            825,
+            752
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Quantizing the compressed representation imposes a distortion $D$ on $\\hat { x }$ w.r.t. $x$ , i.e., it increases the reconstruction error. This is traded for a decrease in entropy of the quantized compressed representation $z$ which leads to a decrease of the length of the bitstream as measured by the rate $R$ . Thus, to train the image compression network, we minimize the classical rate-distortion trade-off $D + \\beta R$ . As a metric for $D$ , we use the mean squared error (MSE) between $x$ and $\\hat { x }$ and we estimate $R$ using $H ( q )$ . $H ( q )$ is the entropy of the probability distribution over the symbols and is estimated using a histogram of the probability distribution (see (Agustsson et al., 2017) for details). We control the trade-off between MSE and the entropy by adjusting $\\beta$ . For each $\\beta$ we get an operating point where the images have a certain bit rate, as measured by bits per pixel (bpp), and corresponding MSE. To better control the bpp, we introduce the target entropy $H _ { t }$ to formulate our loss: ",
+        "bbox": [
+            173,
+            758,
+            825,
+            898
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/67204f6c29f45fb778473c0524ef0eac65935f399c90d4365e743262e03d325a.jpg",
+        "text": "$$\n\\mathcal { L } _ { c } = \\mathbf { M S E } ( \\boldsymbol { x } , \\hat { \\boldsymbol { x } } ) + \\beta \\operatorname* { m a x } \\left( H ( \\boldsymbol { q } ) - H _ { t } , 0 \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            909,
+            642,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We train compression networks for three different bpp operating points by adjusting the compression network hyperparameters. We obtain three operating points at 0.0983 bpp, 0.330 bpp and 0.635 $\\mathsf { b p p } ^ { 1 }$ . On the ILSVRC2012 data, these operating points outperform JPEG and the newer JPEG2000 on the perceptual metrics SSIM and MS-SSIM. Appendix A.2 shows plots comparing the operating points to JPEG and JPEG2000 for different similarity metrics and discusses the metrics themselves. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A visualization of the learned compression can be seen in Fig. 1, where we show an RGB-image along with the visualization of the corresponding compressed representation (showing a subset of the channels). For more visualizations of the compressed representations see Appendix A.2. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            236
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 IMAGE CLASSIFICATION FROM COMPRESSED REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            257,
+            741,
+            273
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 RESNET FOR RGB IMAGES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            287,
+            403,
+            303
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For image classification from RGB images we use the ResNet-50 (V1) architecture (He et al., 2015). It is composed of so-called bottleneck residual units where each unit has the same computational cost regardless of the spatial dimension of the input tensor (with the exception of blocks that subsample spatially, and the root-block). The network is fully convolutional and its structure can be seen in Table 1 for inputs with spatial dimension $2 2 4 \\times 2 2 4$ . ",
+        "bbox": [
+            174,
+            314,
+            825,
+            385
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Following the architectural recipe of He et al. (2015), we adjust the number of 14x14 (conv4 x) blocks to obtain ResNet-71, an intermediate architecture between ResNet-50 and ResNet-101 (see Table 1). ",
+        "bbox": [
+            176,
+            391,
+            825,
+            433
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 RESNET FOR COMPRESSED REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            450,
+            542,
+            465
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For input images with spatial dimension $2 2 4 \\times 2 2 4$ , the encoder of the compression network outputs a compressed representation with dimensions $2 8 \\times 2 8 \\times C$ , where $C$ is the number of channels. We propose a simple variant of the ResNet architecture to use this compressed representation as input. We refer to this variant as cResNet- $k$ , where c stands for “compressed representation” and $k$ is the number of convolutional layers in the network. These networks are constructed by simply “cutting off” the front of the regular (RGB) ResNet. We simply remove the root-block and the residual layers that have a larger spatial dimension than $2 8 \\times 2 8$ . To adjust the number of layers $k$ , we again follow the architectural recipe of He et al. (2015) and only adjust the number of $1 4 \\times 1 4$ $\\bf { \\tau } ( o n v 4 . x )$ residual blocks. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            602
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Employing this method, we get 3 different architectures: (i) cResNet-39 is ResNet-50 with the first 11 layers removed as described above, significantly reducing computational cost; (ii) cResNet-51 and (iii) cResNet-72 are then obtained by adding $1 4 \\times 1 4$ residual blocks to match the computational cost of ResNet-50 and ResNet-71, respectively (see last column of Table 1). ",
+        "bbox": [
+            174,
+            609,
+            825,
+            665
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A description of these architectures and their computational complexity is given in Table 1 for inputs with spatial dimension $2 8 \\times 2 8$ . ",
+        "bbox": [
+            176,
+            671,
+            823,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/920d1582204b8a8384feadc3d85144f718ed6833ee66efd3cf2d615b1ca837ec.jpg",
+        "table_caption": [
+            "Table 1: Structure of the ResNet and the cResNet architectures in terms of of residual block types, their number, and their associated spatial dimension. Numbers are reported for ResNet-networks with RGB images of spatial dimensions $2 2 4 \\times 2 2 4$ as input, and for cResNet-networks with compressed representations of spatial dimensions $2 8 \\times 2 8$ as inputs. For a detailed description of the blocks see Appendix A.3 "
+        ],
+        "table_footnote": [
+            "1We obtain the bpp of an operating point by averaging the bpp of all images in the validation set. "
+        ],
+        "table_body": "<table><tr><td>Network</td><td></td><td></td><td>root conv2_x conv3_x conv4_x conv5_x FLOPs 56 × 56 28× 2814×147×7[×109]</td><td></td><td></td><td></td></tr><tr><td>ResNet-50</td><td>yes</td><td>3</td><td>4</td><td>6</td><td>3</td><td>3.86</td></tr><tr><td>ResNet-71</td><td>yes</td><td>3</td><td>4</td><td>13</td><td>3</td><td>5.38</td></tr><tr><td>cResNet-39</td><td>no</td><td>none</td><td>4</td><td>6</td><td>3</td><td>2.95</td></tr><tr><td>cResNet-51</td><td>no</td><td>none</td><td>4</td><td>10</td><td>3</td><td>3.83</td></tr><tr><td>cResNet-72</td><td>no</td><td>none</td><td>4</td><td>17</td><td>3</td><td>5.36</td></tr></table>",
+        "bbox": [
+            272,
+            795,
+            720,
+            906
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.3 BENCHMARK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            307,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use the ImageNet dataset from the Large Scale Visual Recognition Challenge 2012 (ILSVRC2012) (Russakovsky et al., 2014) to train our image classification networks and our compression network. It consists of 1.28 million training images and $5 0 \\mathrm { k }$ validation images. These images are distributed across 1000 diverse classes. For image classification we report top-1 classification accuracy and top-5 classification accuracy on the validation set on $2 2 4 \\times 2 2 4$ center crops for RGB images and $2 8 \\times 2 8$ center crops for the compressed representation. ",
+        "bbox": [
+            174,
+            131,
+            825,
+            215
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.4 TRAINING PROCEDURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            237,
+            377,
+            251
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given a trained compression network, we keep the compression network fixed while training the classification network, both when starting from compressed representations and from reconstructed compressed RGB images. For the compressed representations, we feed the output of the fixed encoder (the compressed representation) as input to the cResNets (decoder is not needed). When training on the reconstructed compressed RGB images, we feed the output of the fixed encoderdecoder (RGB image) to the ResNet. This is done for each operating point reported in Section 3.1. ",
+        "bbox": [
+            174,
+            265,
+            825,
+            348
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For training we use the standard hyperparameters and a slightly modified pre-processing procedure from He et al. (2015), described in detail in in Appendix A.4. To speed up training we decay the learning rate at a $3 . 7 5 \\times$ faster speed than in He et al. (2015). ",
+        "bbox": [
+            176,
+            356,
+            823,
+            397
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.5 CLASSIFICATION RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            420,
+            398,
+            433
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/2cfe3168b00a0ff67e1045a6568a68e71c067476d334d8d99aaa5dea260e76f2.jpg",
+        "image_caption": [
+            "Figure 3: Top-5 accuracy on the validation set for different architectures and input types at each operating point. Results are shown for ResNet-50 (where reconstructed/decoded RGB images are used as input) and for cResNet-51 and cResNet-39 (where compressed representations are used as input). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            227,
+            455,
+            769,
+            594
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In Table 2 and in Fig. 3 the results for the classification accuracy of the different architectures at each operating point is listed, both classifying from the compressed representation and the corresponding reconstructed compressed RGB images. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            728
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Fig. 3 shows validation curves for ResNet-50, cResNet-51, and cResNet-39. For the 2 classification architectures with the same computational complexity (ResNet-50 and cResNet-51), the validation curves at the 0.635 bpp compression operating point almost coincide, with ResNet-50 performing slightly better. As the rate (bpp) gets smaller this performance gap gets smaller. Table 2 shows the classification results when the different architectures have converged. At the 0.635 bpp operating point, ResNet-50 only performs $0 . 5 \\%$ better in top-5 accuracy than cResNet-51, while for the 0.0983 bpp operating point this difference is only $0 . 3 \\%$ . ",
+        "bbox": [
+            174,
+            734,
+            825,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using the same pre-processing and the same learning rate schedule but starting from the original uncompressed RGB images yields $8 9 . 9 6 \\%$ top-5 accuracy. The top-5 accuracy obtained from the compressed representation at the 0.635 bpp compression operating point, $8 7 . 8 \\bar { 5 } \\%$ , is even competitive with that obtained for the original images at a significantly lower storage cost. Specifically, at 0.635 bpp the ImageNet dataset requires 24.8 GB of storage space instead of $1 4 4 \\mathrm { G B }$ for the original version, a reduction by a factor $5 . 8 \\times$ . ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Image classification accuracies after 28 epochs for the $3 . 7 5 \\times$ training rate schedule employed and image segmentation performance for the Deeplab training rate schedule. For each operating point the inputs to ResNet-networks are reconstructed/decoded RGB images and inputs to cResNet-networks are compressed representations. For comparison we show the results with the same training settings, but starting from the original RGB images, in the top row. ",
+        "bbox": [
+            173,
+            101,
+            825,
+            170
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/66d0aa0812d54f4ac4ea2a459d86e2dc11674f01451964bb4ac25038981d015d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"4\">bpp Network architecture Top 5 acc.[%] Top1acc.[%] mIoU[%]</td></tr><tr><td></td><td>Resnet-50</td><td>89.96 71.06</td><td>65.75</td></tr><tr><td rowspan=\"3\">509.3</td><td>ResNet-50</td><td>88.34 68.26</td><td>62.97</td></tr><tr><td>cResNet-51</td><td>87.85 67.68</td><td>62.86</td></tr><tr><td>cResNet-39 87.47</td><td>67.17</td><td>61.85</td></tr><tr><td rowspan=\"3\">0050</td><td>ResNet-50</td><td>86.25 65.18</td><td>60.75</td></tr><tr><td>cResNet-51</td><td>85.87 64.78</td><td>61.12</td></tr><tr><td>cResNet-39</td><td>85.46 64.14</td><td>60.78</td></tr><tr><td rowspan=\"6\">£8600</td><td>ResNet-50</td><td>78.52 55.30</td><td>52.97</td></tr><tr><td>cResNet-51</td><td>78.20 55.18</td><td>54.62</td></tr><tr><td>cResNet-39</td><td>77.65 54.31</td><td>53.51</td></tr><tr><td>ResNet-71</td><td>79.28 56.23</td><td>54.55</td></tr><tr><td>cResNet-72</td><td>79.02 55.82</td><td>55.78</td></tr><tr><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            269,
+            189,
+            728,
+            373
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To show the computational gains, we plot the top-5 classification accuracy as a function of computational complexity for the 0.0983 bpp compression operating point in Fig. 6. This is done by classification using different architectures that each has an associated computational complexity. The top-5 accuracy of each of these architectures is then plotted as a function of their computational complexity. For the compressed representation we do this for the architectures cResNet-39, cResNet-51 and cResNet-72. For the reconstructed compressed RGB images we used the ResNet-50 and the ResNet-71 architectures. ",
+        "bbox": [
+            174,
+            417,
+            825,
+            515
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Looking at a fixed computational cost, the reconstructed compressed RGB images perform about $0 . 2 5 \\%$ better. Looking at a fixed classification cost, inference from the compressed representation costs about $0 . 6 \\cdot 1 0 ^ { 9 }$ FLOPs more. However when accounting for the decoding cost at a fixed classification performance, inference from the reconstructed compressed RGB images costs $2 . 2 \\cdot 1 0 ^ { 9 }$ FLOPs more than inference from the compressed representation. ",
+        "bbox": [
+            174,
+            522,
+            825,
+            590
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 SEMANTIC SEGMENTATION FROM COMPRESSED REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            625,
+            769,
+            641
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 DEEP METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            664,
+            320,
+            679
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For semantic segmentation we use the ResNet-based Deeplab architecture (Chen et al., 2016) and our implementation is adapted using the codes from DeepLab-ResNet-TensorFlow2. The cResNet and ResNet image classification architectures from Sections 4.1 and 4.2, are re-purposed with atrous convolutions, where the filters are upsampled instead of downsampling the feature maps. This is done to increase their receptive field and to prevent aggressive subsampling of the feature maps, as described in (Chen et al., 2016). For segmentation the ResNet architecture is restructured such that the output feature map has $8 \\times$ smaller spatial dimension than the original RGB image (instead subsampling by a factor $3 2 \\times$ like for classification). When using the cResNets the output feature map has the same spatial dimensions as the input compressed representation (instead of subsampling $4 \\times$ like for classification). This results in comparable sized feature maps for both the compressed representation and the reconstructed RGB images. Finally the last 1000-way classification layer of these classification architectures is replaced by an atrous spatial pyramid pooling (ASPP) with four parallel branches with rates $\\{ 6 , 1 2 , 1 \\bar { 8 } , 2 4 \\}$ , which provides the final pixel-wise classification. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            876
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 BENCHMARK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            307,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The PASCAL VOC-2012 dataset (Everingham et al. (2015)) for semantic segmentation was used for image segmentation tasks. It has 20 object foreground classes and 1 background class. The dataset consists of 1464 training and 1449 validation images. In every image, each pixel is annotated with one of the $2 0 + 1$ classes. The original dataset is furthermore augmented with extra annotations provided by Hariharan et al. (2011), so the final dataset has 10,582 images for training and 1449 images for validation. All performance is measured on pixelwise intersection-over-union (IoU) averaged over all the classes, or mean-intersection-over-union (mIoU) on the validation set. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            227
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 TRAINING PROCEDURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            243,
+            377,
+            257
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The cResNet/ResNet networks are pre-trained on the ImageNet dataset using the procedure described in Section 4.4 on the image classification task, the encoder and decoder are fixed as in Section 4.4. The architectures are then adapted with dilated convolutions, cResNet-d/ResNet-d, and finetuned on the semantic segmentation task. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            325
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the training of the segmentation architecture we use the same settings as in Chen et al. (2016) with a slightly modified pre-processing procedure as described in Appendix A.5. ",
+        "bbox": [
+            174,
+            332,
+            820,
+            361
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.4 SEGMENTATION RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            377,
+            393,
+            391
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9f0702481e57bc235bd172c7669ced5c132247161a090e6a17bd9e2229ca7196.jpg",
+        "image_caption": [
+            "Figure 4: mIoU performance on the validation set for different architectures and input types at each operating point. Results shown for ResNet-50-d (where reconstructed/decoded RGB images are used as input), and for cResNet-51-d and cResNet-39-d (where compressed representations are used as input). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            227,
+            406,
+            769,
+            546
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2 and Fig. 4 list the results of the different architectures for semantic segmentation at each operating point, both for segmentation from the compressed representation and the corresponding reconstructed compressed RGB images. Unlike classification, for semantic segmentation ResNet50-d and cResNet-51-d perform equally well at the 0.635 bpp compression operating point. For the 0.330 bpp operating point, segmentation from the compressed representation performs slightly better, $0 . 3 \\hat { 7 } \\%$ , and at the 0.0983 bpp operating point segmentation from the compressed representation performs considerably better than for the reconstructed compressed RGB images, by $1 . { \\bar { 6 } } 5 \\%$ . ",
+        "bbox": [
+            173,
+            631,
+            825,
+            728
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fig. 5 shows the predicted segmentation visually for both the cResNet-51-d and the ResNet-50-d architecture at each operating point. Along with the segmentation it also shows the original uncompressed RGB image and the reconstructed compressed RGB image. These images highlight the challenging nature of these segmentation tasks, but they can nevertheless be performed using the compressed representation. They also clearly indicate that the compression affects the segmentation, as lowering the rate (bpp) progressively removes details in the image. Comparing the segmentation from the reconstructed RGB images to the segmentation from the compressed representation visually, they perform similar. More visual examples are shown in Appendix A.6. ",
+        "bbox": [
+            173,
+            734,
+            825,
+            848
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 6 we report the mIoU validation performance as a function of computational complexity for the 0.0983 bpp compression operating point. This is done in the same way as in Section 4, using different architectures with different computational complexity, but for segmentation. Here, even without accounting for the decoding cost of the reconstructed images, the compressed representation performs better. At a fixed computational cost, segmentation from the compressed representation gives about $0 . 7 \\%$ better mIoU. And at a fixed mIoU the computational cost is about $3 . 3 \\cdot 1 0 ^ { 9 }$ FLOPs lower for compressed representations. Accounting for the decoding costs this difference becomes $6 . 1 \\cdot 1 0 ^ { 9 }$ FLOPs. due to the nature of the dilated convolutions and the increased feature map size the relative computational gains for segmentation are not as pronounced as for classification. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/e44de8ef63de2b87e55484cf04da4b14cd64fc6226bd5a4b8c283fc7eba37528.jpg",
+        "image_caption": [
+            "Figure 5: Top: Reconstructed/decoded RGB images at different compression operating points. Middle: Predicted segmentation mask starting from reconstructed/decoded RGB images using ResNet50-d architecture. Bottom: Predicted segmentation mask starting from compressed representation using cResNet-51-d architecture. Left: Original RGB image and the ground truth segmentation mask. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            251,
+            174,
+            754,
+            436
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 JOINT TRAINING FOR COMPRESSION AND IMAGE CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            553,
+            759,
+            570
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.1 FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            585,
+            318,
+            601
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To train for compression and classification jointly, we combine the compression network and the cResNet-51 architecture. An overview of the setup can be seen in Fig. 2 b) where all parts, encoder, decoder, and inference network, are trained at the same time. The compressed representation is fed to the decoder to optimize for mean-squared reconstruction error and to a cResNet-51 network to optimize for classification using a cross-entropy loss. The combined loss function takes the form ",
+        "bbox": [
+            173,
+            611,
+            825,
+            683
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4565e6a58b246662388d194949e9ea6cfc734f631fad49f12050554f12598253.jpg",
+        "text": "$$\n\\mathcal { L } _ { c } = \\gamma \\left( \\mathbf { M S E } ( x , \\hat { x } ) + \\beta \\operatorname* { m a x } { \\left( H ( q ) - H _ { t } , 0 \\right) } \\right) + \\ell _ { c e } ( y , \\hat { y } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            689,
+            692,
+            707
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where the loss terms for the compression network, $\\mathbf { M S E } ( x , \\hat { x } ) + \\beta \\operatorname* { m a x } \\left( H ( q ) - H _ { t } , 0 \\right)$ , are the same as in training for compression only (see Eq. 1). $\\ell _ { c e }$ is the cross-entropy loss for classification. $\\gamma$ controls the trade-off between the compression loss and the classification loss. ",
+        "bbox": [
+            178,
+            713,
+            821,
+            756
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "When training the cResNet-51 networks for image classification as described in Section 4.4 the compression network is fixed (after having been previously trained as described in Section 3.1). When doing joint training, we first initialize the compression network and the classification network from a trained state obtained as described in Section 3 and 4. After initialization the networks are both finetuned jointly. We initialize from a trained state and our learning rate schedule is short and does not perturb the weights too much from their initial state so we call this finetuning. For a detailed description of hyperparameters used and the training schedule see Appendix A.8. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            862
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To control that the change in classification accuracy is not only due to (1) a better compression operating point or (2) the fact that the cResNet is trained longer, we do the following. We obtain a new operating point by finetuning the compression network only using the schedule described above. We then train a cResNet-51 on top of this new operating point from scratch. Finally, keeping the compression network fixed at the new operating point, we train the cResNet-51 for 9 epochs according to the training schedule above. This procedure controls (1) and (2), and we use it to compare to the joint finetuning. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0b6d7e4230a132d4e546da6ed279ec3b78f5fed058d84a9dacd39fe1c8329f06.jpg",
+        "image_caption": [
+            "Figure 6: Inference performance at the 0.0983 bpp operating point at different computational complexities, for both compressed representations and RGB images. We report the computational cost of the inference networks only and for reconstructed RGB images we also show the inference cost along with the decoding cost. For runtime benchmarks see Appendix A.9 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            102,
+            490,
+            219
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/a9f9653f60d8aaba38d537e5dbeeee5571c30a23309af55d4fd2db0e36d3e0d2.jpg",
+        "image_caption": [
+            "Figure 7: Showing how classification and segmentation performance improves by finetuning (ft.) the compression network only and the compression network and the classification network jointly. The dots show how the performance “moves up” from the baseline performance when finetuning. The baseline is obtained using fixed compression operating points. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            504,
+            102,
+            812,
+            218
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            371,
+            825,
+            412
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To obtain segmentation results we take the jointly trained network, fix the compression operating point and adopt the jointly finetuned classification network for segmentation (cResNet-51-d). It is then trained the same way as in Section 5.3. The difference to Section 5.3 is therefore only the pre-trained network. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            476
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.2 JOINT TRAINING RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            494,
+            398,
+            508
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "First, we observe that training the compression and segmentation networks jointly as described in Section 6.1 does not affect the compression performance significantly. In more detail, joint training increases the compression performance on the perceptual metrics MS-SSIM and SSIM by a small amount and decreases the PSNR slightly (high is good for all these metrics), see Appendix A.7. ",
+        "bbox": [
+            174,
+            521,
+            823,
+            577
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 7 we show how the classification and segmentation metrics change when finetuning the networks (using cResNet-51). It can be seen that the classification and segmentation results “move up” from the baseline through finetuning. By finetuning the compression network only, we get a slight improvement in performance for the classification task but almost no improvements for the segmentation task. However, when training jointly the improvement for classification are larger and we get a significant improvement for segmentation. It is interesting to note that for the 0.635 bpp operating point the classification performance is similar for training the network jointly and training the compression network only, but when using these operating points for segmentation the difference is considerable. ",
+        "bbox": [
+            174,
+            584,
+            825,
+            708
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Considering the 0.0983 bpp operating point and looking at the improvements in terms of computational complexity shown in Fig. 6, we see that training the networks jointly, compared to the training only the compression network, we improve classification by $2 \\%$ , a performance gain which would require an additional $7 5 \\%$ of computational complexity of cResNet-51. In a similar way, the segmentation performance after training the networks jointly is $1 . 7 \\%$ better in mIoU than training only the compression network. Translating this to computational complexity using Fig. 6, to get this performance by adding layers to the netowork would require an additional $4 0 \\%$ of computational complexity of cResNet-51. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            827
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            849,
+            310,
+            864
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We proposed and explored inference when starting directly from learned compressed representations without the need to decode, for two fundamental computer vision tasks: classification and semantic segmentation of images. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In our experiments we departed from a very recent state-of-the-art deep compression architecture proposed by Theis et al. (2017) and showed that the obtained compressed representations can be easily fed to variants of standard state-of-the-art DNN architectures while achieving comparable performance to the unmodified DNN architectures working on the decoded/reconstructed RGB images (see Fig. 6). In particular, only minor changes in the training procedures and hyperparameters of the original compression and classification/segmentation networks were necessary to obtain our results. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The main strong points of the proposed method for image understanding from deep compression without decoding are the following: ",
+        "bbox": [
+            173,
+            208,
+            821,
+            236
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Runtime Our approach saves decoding time and also DNN inference time as the DNN adapted models can be of smaller depth than those using the decoded RGB images for comparable performance. ",
+        "bbox": [
+            165,
+            247,
+            825,
+            290
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Memory Removing the need for reconstructing the image is a feat with large potential for real-time memory constrained applications which use specialized hardware such as in the automotive industry. Complementary, we have the benefit of shallower DNN models and aggressive compression rates (low bpp) with good performance. ",
+        "bbox": [
+            163,
+            295,
+            825,
+            351
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Robustness The approach was successfully validated for image classification and semantic segmentation with minimal changes in the specialized DNN models, which make us to believe that the approach can be extended to most of the related image understanding tasks, such as object detection or structure-from-motion. ",
+        "bbox": [
+            148,
+            356,
+            825,
+            411
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Synergy The joint training of compression and inference DNN models led to synergistic improvements in both compression quality and classification/segmentation accuracy. ",
+        "bbox": [
+            156,
+            415,
+            820,
+            444
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Performance According to our experiments and the top performance achieved, compressed representations are a promising alternative to the largely common use of decoded images as starting point in image understanding tasks. ",
+        "bbox": [
+            137,
+            449,
+            825,
+            491
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "At the same time the approach has a couple of shortcomings: ",
+        "bbox": [
+            173,
+            502,
+            573,
+            517
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Complexity In comparison with the current standard compression methods (such as JPEG, JPEG2000) the deep encoder we used and the learning process have higher time and memory complexities. However, research on deep compression is in its infancy while techniques such as JPEG are matured. Recently, Rippel & Bourdev (2017) have shown that deep compression algorithms can achieve the same or higher (de)compression speeds as standard compression algorithms on GPUs. As more and more devices are being equipped with dedicated deep learning hardware, deep compression could become commonplace. ",
+        "bbox": [
+            142,
+            529,
+            825,
+            626
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Performance The proposed approach is particularly suited for aggressive compression rates (low bpp) and wherever the memory constraints and storage are critical. Medium and low bpp compression rates are also the regime where deep compression algorithms considerably outperform standard ones. ",
+        "bbox": [
+            137,
+            631,
+            823,
+            685
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Extending our method for learning from compressed representation to other computer vision tasks is an interesting direction for future work. Furthermore, gaining a better understanding of the features/compressed representations learned by image compression networks might lead to interesting applications in the context of unsupervised/semisupervised learning. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            755
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            776,
+            356,
+            791
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was partly supported by ETH Zurich General Fund (OK) and by NVIDIA through a hardware grant. ",
+        "bbox": [
+            174,
+            806,
+            823,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Aghagolzadeh and Hayder Radha. On hyperspectral classification in the compressed domain. arXiv preprint arXiv:1508.00282, 2015. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eirikur Agustsson, Fabian Mentzer, Michael Tschannen, Lukas Cavigelli, Radu Timofte, Luca Benini, and Luc Van Gool. Soft-to-hard vector quantization for end-to-end learned compression of images and neural networks. CoRR, abs/1704.00648, 2017. ",
+        "bbox": [
+            176,
+            165,
+            823,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "R Venkatesh Babu, Manu Tom, and Paras Wadekar. A survey on compressed domain video analysis techniques. Multimedia Tools and Applications, 75(2):1043–1078, 2016. ",
+        "bbox": [
+            176,
+            218,
+            825,
+            248
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Johannes Balle, Valero Laparra, and Eero P Simoncelli. End-to-end optimization of nonlinear trans- ´ form codes for perceptual quality. arXiv preprint arXiv:1607.05006, 2016. ",
+        "bbox": [
+            174,
+            257,
+            823,
+            287
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fabrice Bellard. BPG Image format. https://bellard.org/bpg/. ",
+        "bbox": [
+            174,
+            297,
+            660,
+            313
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sovan Biswas and R Venkatesh Babu. H. 264 compressed video classification using histogram of oriented motion vectors (homv). In Acoustics, Speech and Signal Processing (ICASSP), 2013 IEEE International Conference on, pp. 2040–2044. IEEE, 2013. ",
+        "bbox": [
+            174,
+            323,
+            826,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aaron Chadha, Alhabib Abbas, and Yiannis Andreopoulos. Video classification with cnns: Using the codec as a spatio-temporal activity sensor. arXiv preprint arXiv:1710.05112, 2017. ",
+        "bbox": [
+            171,
+            376,
+            825,
+            405
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L. Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. CoRR, abs/1606.00915, 2016. URL http://arxiv.org/abs/1606. 00915. ",
+        "bbox": [
+            174,
+            416,
+            825,
+            472
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Samuel Dodge and Lina Karam. Understanding how image quality affects deep neural networks. In Quality of Multimedia Experience (QoMEX), 2016 Eighth International Conference on, pp. 1–6. IEEE, 2016. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            525
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mark Everingham, S. M. Eslami, Luc Gool, Christopher K. Williams, John Winn, and Andrew Zisserman. The pascal visual object classes challenge: A retrospective. Int. J. Comput. Vision, 111(1):98–136, January 2015. ISSN 0920-5691. doi: 10.1007/s11263-014-0733-5. URL http: //dx.doi.org/10.1007/s11263-014-0733-5. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            593
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Fu and Gabriel Guimaraes. Using compression to speed up image classification in artificial neural networks. 2016. ",
+        "bbox": [
+            169,
+            603,
+            823,
+            632
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Piotr Dollar, Ross B. Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, ´ Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: training imagenet in 1 hour. CoRR, abs/1706.02677, 2017. URL http://arxiv.org/abs/1706. 02677. ",
+        "bbox": [
+            173,
+            642,
+            825,
+            699
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jurgen Hahn, Simon Rosenkranz, and Abdelhak M Zoubir. Adaptive compressed classification for hyperspectral imagery. In Acoustics, Speech and Signal Processing (ICASSP), 2014 IEEE International Conference on, pp. 1020–1024. IEEE, 2014. ",
+        "bbox": [
+            173,
+            709,
+            825,
+            752
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B. Hariharan, P. Arbelez, L. Bourdev, S. Maji, and J. Malik. Semantic contours from inverse detectors. In 2011 International Conference on Computer Vision, pp. 991–998, Nov 2011. doi: 10.1109/ICCV.2011.6126343. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            805
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CoRR, abs/1512.03385, 2015. URL http://arxiv.org/abs/1512.03385. ",
+        "bbox": [
+            169,
+            816,
+            823,
+            845
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton and Ruslan Salakhutdinov. Reducing the dimensionality of data with neural networks. Science, 313(5786):504 – 507, 2006. ",
+        "bbox": [
+            171,
+            856,
+            821,
+            885
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mohammed Javed, P Nagabhushan, and Bidyut B Chaudhuri. A review on document image analysis techniques directly in the compressed domain. Artificial Intelligence Review, pp. 1–30, 2017. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nick Johnston, Damien Vincent, David Minnen, Michele Covell, Saurabh Singh, Troy Chinen, Sung Jin Hwang, Joel Shor, and George Toderici. Improved lossy image compression with priming and spatially adaptive bit rates for recurrent networks. arXiv preprint arXiv:1703.10114, 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Vadim Kantorov and Ivan Laptev. Efficient feature extraction, encoding and classification for action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2593–2600, 2014. ",
+        "bbox": [
+            174,
+            155,
+            823,
+            196
+        ],
+        "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,
+            207,
+            823,
+            234
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mu Li, Wangmeng Zuo, Shuhang Gu, Debin Zhao, and David Zhang. Learning convolutional networks for content-weighted image compression. arXiv preprint arXiv:1703.10553, 2017. ",
+        "bbox": [
+            171,
+            243,
+            823,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Masci, Ueli Meier, Dan Cires¸an, and Jurgen Schmidhuber. ¨ Stacked Convolutional AutoEncoders for Hierarchical Feature Extraction, pp. 52–59. Springer Berlin Heidelberg, Berlin, Heidelberg, 2011. ISBN 978-3-642-21735-7. doi: 10.1007/978-3-642-21735-7 7. URL https: //doi.org/10.1007/978-3-642-21735-7_7. ",
+        "bbox": [
+            173,
+            281,
+            825,
+            338
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Salah Rifai, Pascal Vincent, Xavier Muller, Xavier Glorot, and Yoshua Bengio. Contractive autoencoders: Explicit invariance during feature extraction. In ICML, pp. 833–840. Omnipress, 2011. ",
+        "bbox": [
+            173,
+            347,
+            821,
+            377
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Oren Rippel and Lubomir Bourdev. Real-time adaptive image compression. arXiv preprint arXiv:1705.05823, 2017. ",
+        "bbox": [
+            171,
+            385,
+            823,
+            414
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael S. Bernstein, Alexander C. Berg, and Fei-Fei Li. Imagenet large scale visual recognition challenge. CoRR, abs/1409.0575, 2014. ",
+        "bbox": [
+            173,
+            422,
+            825,
+            465
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David S. Taubman and Michael W. Marcellin. JPEG 2000: Image Compression Fundamentals, Standards and Practice. Kluwer Academic Publishers, Norwell, MA, USA, 2001. ISBN 079237519X. ",
+        "bbox": [
+            173,
+            473,
+            825,
+            517
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lucas Theis, Wenzhe Shi, Andrew Cunningham, and Ferenc Huszar. Lossy image compression with compressive autoencoders. In ICLR 2017, 2017. ",
+        "bbox": [
+            168,
+            526,
+            825,
+            555
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "George Toderici, Sean M O’Malley, Sung Jin Hwang, Damien Vincent, David Minnen, Shumeet Baluja, Michele Covell, and Rahul Sukthankar. Variable rate image compression with recurrent neural networks. arXiv preprint arXiv:1511.06085, 2015. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            607
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "George Toderici, Damien Vincent, Nick Johnston, Sung Jin Hwang, David Minnen, Joel Shor, and Michele Covell. Full resolution image compression with recurrent neural networks. arXiv preprint arXiv:1608.05148, 2016. ",
+        "bbox": [
+            173,
+            614,
+            825,
+            659
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In Proceedings of the 25th International Conference on Machine Learning, ICML $^ { \\ ' 0 8 }$ , pp. 1096–1103, New York, NY, USA, 2008. ACM. ISBN 978-1-60558-205-4. doi: 10.1145/1390156.1390294. URL http://doi.acm.org/ 10.1145/1390156.1390294. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            737
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Z. Wang, E. P. Simoncelli, and A. C. Bovik. Multiscale structural similarity for image quality assessment. In Asilomar Conference on Signals, Systems Computers, 2003, volume 2, pp. 1398– 1402 Vol.2, Nov 2003. ",
+        "bbox": [
+            173,
+            746,
+            825,
+            789
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhou Wang, A. C. Bovik, H. R. Sheikh, and E. P. Simoncelli. Image quality assessment: from error visibility to structural similarity. IEEE Transactions on Image Processing, 13(4):600–612, April 2004. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            840
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chuohao Yeo, Parvez Ahammad, Kannan Ramchandran, and S Shankar Sastry. High-speed action recognition and localization in compressed domain videos. IEEE Transactions on Circuits and Systems for Video Technology, 18(8):1006–1015, 2008. ",
+        "bbox": [
+            173,
+            849,
+            825,
+            892
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 COMPRESSION ARCHITECTURE AND TRAINING PROCEDURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            635,
+            147
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The compression network is an autoencoder that takes an input image $x$ and outputs $\\hat { x }$ as the approximation to the input (see Fig. 2 (a)). The encoder has the following structure: It starts with 2 convolutional layers with spatial subsampling by a factor of 2, followed by 3 residual units, and a final convolutional layer with spatial subsampling by a factor of 2. This results in a $w / 8 \\times h / 8 \\times C$ - dimensional representation, where $w$ and $h$ are the spatial dimensions of $x$ , and the number of channels $C$ is a hyperparameter related to the rate $R$ . This representation is then quantized to a discrete set of symbols, forming a compressed representation, $z$ . ",
+        "bbox": [
+            174,
+            160,
+            825,
+            257
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "To get the reconstruction $\\hat { x }$ , the compressed representation is fed into the decoder, which mirrors the encoder, but uses upsampling and deconvolutions instead of subsampling and convolutions. ",
+        "bbox": [
+            174,
+            263,
+            821,
+            292
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "To handle the non-differentiability of the quantization step during training, Agustsson et al. (2017) employ a differentiable (soft) approximation of quantization and anneal it to the actual (hard) quantization during training to prevent inversion of the soft quantization approximation. Here, we replace this procedure by a different quantization step, $\\bar { Q }$ , which behaves like $\\hat { Q }$ in the forward pass but like $\\bar { Q }$ in the backward pass (using the notation of (Agustsson et al., 2017)). Note that this is similar to the approach of Theis et al. (2017), who use rounding to integer in forward pass, and the identity function in the backward pass. Like annealing, $\\bar { Q }$ prevents inversion of the soft quantization approximation, but facilitates joint training of the autoencoder for image compression with an inference task (see Section 6). Additionally, we chose to use scalar instead of vector quantization (i.e., $p _ { h } = p _ { w } = 1$ in the notation of Agustsson et al. (2017)) to further simplify joint training of compression and inference tasks. This means that each entry of the feature-map is quantized individually. ",
+        "bbox": [
+            173,
+            299,
+            825,
+            469
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We train compression networks for three different bpp operating points by choosing different values for $\\beta$ , $H _ { t }$ and $C$ . In theory, changing $H _ { t }$ and $\\beta$ is enough to change the resulting average bpp of the network, but we found it beneficial to also change $C$ . We obtain three operating points at $0 . 0 9 8 3 \\mathrm { b p p }$ $C = 8$ ), 0.330 bpp $C = 1 6$ ) and 0.635 bpp $\\bar { ( C = 3 2 ) } ^ { \\bar { 1 } }$ 3. We use the Adam optimizer (Kingma & Ba, 2014) with learning rates of $1 e ^ { - 3 }$ , $1 e ^ { - 5 }$ , and $1 e ^ { - 3 }$ for the 0.0983, 0.330 and 0.635 bpp operating points, respectively. We train on the images from the ILSVRC2012 dataset (see Section 4.3), using a batch size of 30. We train each operating point for $6 0 0 \\mathrm { k }$ iterations. Fig. 8 depicts the performance of our deep compression models vs. standard JPEG and JPEG2000 compression on ILSVRC2012 data. ",
+        "bbox": [
+            173,
+            477,
+            825,
+            601
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 IMAGE COMPRESSION METRICS, PERFORMANCE AND VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            618,
+            705,
+            632
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We use the following metrics to report performance of our image compression networks: PSNR (Peak Signal-to-Noise Ratio) is a standard measure, depending monotonically on mean squared error4. SSIM (Structural Similarity Index, Wang et al. (2004)) and MS-SSIM (Multi-Scale SSIM, Wang et al. (2003)) are metrics proposed to better measure the similarity of images as perceived by humans. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            714
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Fig. 8 depicts the performance of our deep compression models vs. standard JPEG and JPEG2000 methods on ILSVRC2012 data on MS-SSIM, SSIM and PSNR. Higher values are always better. ",
+        "bbox": [
+            174,
+            722,
+            823,
+            750
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The compressed representations learned in the compression network are visualized in Fig. 9. The original RGB-image is shown along with compressed versions of the RGB image which reconstructed from the compressed representation. In the interest of space we only visualize 4 channels of the compressed representation for each image, even though each operating point has more than 4 channels. We choose the 4 channels with the highest entropy. These visualizations indicate how the networks compress an image, as the rate (bpp) gets lower the entropy cost of the network forces the compressed representation to use fewer quantization centers, as can clearly be seen in Fig. 9. For the most aggressive compression, the channel maps use only 2 centers for the compressed representation. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            881
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/859abf6a299d301cccda746d3082845ef6ed56891c1015e200fa4ac5e7291e80.jpg",
+        "image_caption": [
+            "Figure 8: MS-SSIM, SSIM and PSNR as a function of rate in bpp. Shown for JPEG 2000, JPEG and the reported Deep Compression operating points. Higher is better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            152,
+            767,
+            292
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/a96509f9f3f74b994d4a70b4e885475b1161b7f2addcccce9508950a1afb942e.jpg",
+        "image_caption": [
+            "Figure 9: For each operating point we show the reconstructed/decoded image along with the 4 highest entropy channels of the compressed representation. The original RGB image is shown on the left for comparison. The channels of the compressed representation look like quantized downscaled versions of the original image, which motivates doing inference based on them instead of the reconstructed RGB images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            441,
+            820,
+            784
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.3 ARCHITECTURE TABLE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            382,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Table 3 is a more detailed version of Table 1 and shows the detailed structure of the networks used, with the dimensions of the convolutions inside the network shown along with all layers. ",
+        "bbox": [
+            173,
+            130,
+            823,
+            159
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/081d2474b2fe87138be72fa96437e48f3d59f68a91c3990974d7950aa0a01dfe.jpg",
+        "table_caption": [
+            "Table 3: Structure of the ResNet and the cResNet architectures. The numbers reported are for ResNet-networks where the inputs are RGB images with a spatial dimensions $2 2 4 \\times 2 2 4$ and for cResNet-networks where the inputs are compressed representations with spatial dimensions $2 8 \\times 2 8$ . Building blocks are shown in brackets, with the numbers of blocks stacked. Downsampling is performed by conv3 1, conv4 1, and conv5 1 with a stride of 2. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=2></td><td rowspan=1 colspan=6>RGB</td><td rowspan=1 colspan=9>Compressed representation</td></tr><tr><td rowspan=1 colspan=1>layer name</td><td rowspan=1 colspan=1>output size</td><td rowspan=1 colspan=6>ResNet-71        ResNet-50</td><td rowspan=1 colspan=3>cResNet-72</td><td rowspan=1 colspan=3>cResNet-51</td><td rowspan=1 colspan=3>cResNet-39</td></tr><tr><td rowspan=2 colspan=1>conv2_x</td><td rowspan=2 colspan=1>56×56</td><td rowspan=1 colspan=6>3x3 max pool, stride 2</td><td rowspan=1 colspan=3></td><td rowspan=2 colspan=3>None</td><td rowspan=2 colspan=3>None</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,643×3,641×1,256</td><td rowspan=1 colspan=1>×3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,643×3,641×1,256</td><td rowspan=1 colspan=1>×3</td><td rowspan=1 colspan=3>None</td></tr><tr><td rowspan=1 colspan=1>conv3_x</td><td rowspan=1 colspan=1>28×28</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,1283×3,1281×1,512</td><td rowspan=1 colspan=1>×4</td><td></td><td rowspan=1 colspan=1>1×1,1283×3,1281×1,512</td><td rowspan=1 colspan=1>×4</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,1283×3,1281×1,512</td><td rowspan=1 colspan=1>×4</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,1283×3,1281×1,512</td><td rowspan=1 colspan=1>×4</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,1283×3,1281×1,512</td><td rowspan=1 colspan=1>×4</td></tr><tr><td rowspan=1 colspan=1>conv4_x</td><td rowspan=1 colspan=1>14×14</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,2563×3,2561×1,1024</td><td rowspan=1 colspan=1>×13</td><td></td><td rowspan=1 colspan=1>1×1,2563×3,2561×1,1024</td><td rowspan=1 colspan=1>×6</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,2563×3,2561×1,1024</td><td rowspan=1 colspan=1>×17</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,25633,2561×1,1024</td><td rowspan=1 colspan=1>×10</td><td></td><td rowspan=1 colspan=1>1×1,2563×3,2561×1,1024</td><td rowspan=1 colspan=1>×6</td></tr><tr><td rowspan=1 colspan=1>conv5_x</td><td rowspan=1 colspan=1>7×7</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1,5123×3,5121×1,2048</td><td rowspan=1 colspan=1>×3</td><td></td><td rowspan=1 colspan=1>1×1,5123×3,5121×1,2048</td><td rowspan=1 colspan=1>×3</td><td></td><td rowspan=1 colspan=1>1×1,5123×3,5121×1,2048</td><td rowspan=1 colspan=1>×3</td><td></td><td rowspan=1 colspan=1>1×1,5123×3,5121×1,2048</td><td rowspan=1 colspan=1>×3</td><td></td><td rowspan=1 colspan=1>1×1,5123x3,5121×1,2048</td><td rowspan=1 colspan=1>×3</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1x1</td><td rowspan=1 colspan=15>average pool,1000-d fc,softmax</td></tr><tr><td rowspan=1 colspan=2>FLOPs</td><td rowspan=1 colspan=15>5.38×109         3.86×109        5.36×109         3.83×109        2.95×109</td></tr></table>",
+        "bbox": [
+            176,
+            171,
+            823,
+            361
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.4 TRAINING CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            457,
+            411,
+            470
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We use the ResNet implementation from the Slim library in TensorFlow5 with modifications for the custom architectures. For a fair comparison when using different settings we train all classifications networks from scratch in our experiments. For the training we use a batch size 64 and employ the linear scaling rule from Goyal et al. (2017) and use the learning rate 0.025. We employ the same learning rate schedule as in (He et al., 2015), but for faster training iterations we decay the learning rate $3 . 7 5 \\times$ faster. We use a constant learning rate that is divided by a factor of 10 at 8, 16, and 24 epochs and we train for a total of 28 epochs. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            580
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A stochastic gradient descent (SGD) optimizer is used with momentum 0.9. We use weight decay of 0.0001. For pre-processing we do random-mirroring of inputs, random-cropping of inputs $( 2 2 4 \\times 2 2 4$ for RGB images, $2 8 \\times 2 8$ for compressed representations) and center the images using per channel mean over the ImageNet dataset. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            643
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.5 TRAINING SEGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            661,
+            405,
+            675
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For the training of the segmentation architecture we use the same settings as in Chen et al. (2016) with a slightly modified pre-processing procedure. We use batch size 10 and perform $2 0 \\mathrm { k }$ iterations for training using SGD optimizer with momentum 0.9. The initial learning rate is 0.001 (0.01 for final classification layer) and the learning rate policy is as follows: at each step the initial learning rate is multiplied by $\\begin{array} { r } { ( 1 - \\frac { \\mathrm { i t e r } } { \\mathrm { m a x } \\mathrm { . i t e r } } ) ^ { 0 . 9 } } \\end{array}$ . We use a weight decay of 0.0005. For preprocessing we do random-mirroring of inputs, random-cropping of inputs $3 2 0 \\times 3 2 0$ for RGB images, $4 0 \\times 4 0$ for the compressed representation) and center the images using per channel mean over the dataset. ",
+        "bbox": [
+            173,
+            688,
+            825,
+            785
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.6 SEGMENTATION VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            803,
+            444,
+            816
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Fig. 10 shows visual results of segmentation from compressed representation and reconstructed RGB images as in Fig. 5. The performance is visually similar for all operating points except for the 0.0983 bpp operating point in Fig. 10 where the reconstructed RGB image fails to capture the back part of the train, while the compressed representation manages to capture that aspect of the image in the segmentation. ",
+        "bbox": [
+            173,
+            828,
+            825,
+            898
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/5186cfc93b465645268f23be69c4820caea0415191593ba5bbb96daf9dbec0e4.jpg",
+        "image_caption": [
+            "Figure 10: Top: Reconstructed/decoded RGB images at different compression operating points. Middle: Predicted segmentation mask starting from reconstructed/decoded RGB images using ResNet-50-d architecture. Bottom: Predicted segmentation mask starting from compressed representation using cResNet-51-d architecture. Left: Original RGB image and the ground truth segmentation mask. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            99,
+            818,
+            388
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.7 IMAGE COMPRESSION METRICS FOR JOINT TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            507,
+            594,
+            521
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 11 the compression metric results of finetuning the whole joint network (joint ft.), are compared to finetuning only the compression network (compression ft.). In both cases the same learning rate schedule is used, namely the one described in Section 6.1 Each image shows 4 distinct points along with a baseline for JPEG-2000. These 4 points are: ",
+        "bbox": [
+            173,
+            535,
+            825,
+            592
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "• joint-1: The joint ft. operating point at the beginning of the finetuning • joint-2: The joint ft. operating point at the end of finetuning • compression-1: the compression ft. operating point at the beginning of the finetuning • compression-2: the compression ft. operating point at the end of finetuning ",
+        "bbox": [
+            215,
+            608,
+            790,
+            698
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "joint-1 and compression-1 are the same because both joint ft. and compression ft. are initialized from the same starting point. An arrow then shows how the operating point for the joint training moves from joint-1 to joint-2 after finetuning. In the same manner an arrow shows how point compression-1 moves to compression-2 after finetuning. ",
+        "bbox": [
+            176,
+            714,
+            825,
+            770
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Fig. 11 shows how the points move in the rate-vs.- $\\{ \\mathrm { M S S S I M , S S I M , P S N R } \\}$ plane. When training, hitting an exact target bpp is difficult due to the noisy nature of the entropy loss. Therefore the points in Fig. 11 do not only move along the y-axis (MS-SSIM, SSIM or PSNR) but also move along the $\\mathbf { X }$ -axis (rate). We show the final results for both joint ft. and compression ft. at the same bpp for a fair comparison. ",
+        "bbox": [
+            173,
+            776,
+            825,
+            847
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "As is evident from Fig. 11 this finetuning procedure improves the image compression metrics in all cases, i.e., they converge at a higher value for a lower bpp. We re-iterate, for all metrics higher values are better. However for SSIM and MS-SSIM the joint ft. improves more than the compression ft. For PSNR, however, the joint ft. improves less than the compression ft. The same effect is consistent for both 0.0983 and the 0.635 bpp operating points. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/258b2d891be1bcf0db85ad493f6d29cc3bf166846a470538b8621f4eb5a4e43c.jpg",
+        "image_caption": [
+            "Figure 11: Showing how the selected metrics move from the original compression operating point to a different point after finetuning. We show this change when finetuning the compression network only, and then when finetuning the compression network and the classification architecture jointly. Top: 0.635 bpp operating point Bottom: 0.0983 bpp operating point. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            264,
+            99,
+            730,
+            368
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "A.8 JOINT TRAINING TRAINING AND HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            464,
+            593,
+            479
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "For joint training we set the hyperparameters in Eq. 2 to $\\gamma = 0 . 0 0 1$ , $\\beta = 1 5 0$ and $H _ { t } = 1 . 2 6 5$ for the 0.635 bpp operating point and $\\gamma = 0 . 0 0 1$ , $\\beta = 6 0 0$ and $H _ { t } = 0 . 8$ for the 0.0983 bpp operating point. ",
+        "bbox": [
+            176,
+            491,
+            823,
+            534
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "The learning rate schedule is similar to the one used in the image classification setting. It starts with an initial learning rate of 0.0025 that is divided by 10 every 3 epochs using a SGD optimizer with momentum 0.9. The joint network is then trained for a total of 9 epochs. ",
+        "bbox": [
+            176,
+            540,
+            823,
+            582
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "A.9 RUNTIMES BENCHMARKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            602,
+            397,
+            616
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 12 we show the average runtimes (per image) for different setups. This complements Fig. 6 where we showed the theoretical computations for each setup. All benchmarks were run on a GeForce Titan X GPU in TensorFlow v1.3. We used batch size 256 for classification and batch size 20 for segmentation. For RGB images we used the image spatial dimension $2 2 4 \\times 2 2 4$ and for the compressed representations we used spatial dimension $2 8 \\times 2 8$ (corresponding to a $2 2 4 \\times 2 2 4$ input image to the compression network). ",
+        "bbox": [
+            173,
+            627,
+            826,
+            712
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/915029c679a8f77270ea6bbeebfdf47015a5949094dbe1d6c9094d62d2a656ae.jpg",
+        "image_caption": [
+            "Figure 12: Inference performance at the 0.0983 bpp operating point for different architectures, for both compressed representations and reconstructed RGB images. We report the computational runtime (per image) of the inference networks only and for the reconstructed RGB images we also show the runtime for the inference network along with the decoding runtime. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            334,
+            727,
+            660,
+            852
+        ],
+        "page_idx": 16
+    }
+]

parse/train/SJ1nzBeA-/SJ1nzBeA-.md

@@ -0,0 +1,330 @@
+# MULTI-TASK LEARNING FOR DOCUMENT RANKING AND QUERY SUGGESTION
+
+Wasi Uddin Ahmad & Kai-Wei Chang
+
+Department of Computer Science University of California, Los Angeles {wasiahmad,kwchang}@cs.ucla.edu
+
+Hongning Wang Department of Computer Science University of Virginia hw5x@virginia.edu
+
+# ABSTRACT
+
+We propose a multi-task learning framework to jointly learn document ranking and query suggestion for web search. It consists of two major components, a document ranker and a query recommender. Document ranker combines current query and session information and compares the combined representation with document representation to rank the documents. Query recommender tracks users’ query reformulation sequence considering all previous in-session queries using a sequence to sequence approach. As both tasks are driven by the users’ underlying search intent, we perform joint learning of these two components through session recurrence, which encodes search context and intent. Extensive comparisons against state-of-the-art document ranking and query suggestion algorithms are performed on the public AOL search log, and the promising results endorse the effectiveness of the joint learning framework.
+
+# 1 INTRODUCTION
+
+Understanding users’ information need is the key to optimize a search engine for providing relevant search results. Search engine logs have been extensively used to mine users’ search intent, reflected in their search result click preferences and query reformulations (Baeza-Yates et al., 2004; Croft et al., 2010). Typically, user query logs are partitioned into search sessions, i.e., sequences of queries and clicks issued by the same user and within a short time interval. Search sessions provide useful contextual information about user intent and help to narrow down ambiguity while ranking documents for the current query and predicting next query that users will submit, a.k.a. contextawareness (Jiang et al., 2014). Since both a user’s click behavior and query reformulation are driven by the underlying search intent, we argue that jointly modeling both tasks can benefit each other.
+
+In this work, we propose a joint learning framework, called multi-task neural session relevance framework (M-NSRF), to predict users’ result clicks and future queries in search sessions. We model search context within a session via a recurrent latent state in a deep neural network (Collobert & Weston, 2008; Liu et al., 2015), which governs the generation of result clicks in the current query and formation of next query. By sharing the latent states across the tasks of document ranking and query suggestion, we learn the representations of queries, documents and user intent carrying over the whole session jointly, i.e., multi-task learning. This multi-task learning framework is flexible and can be incorporated with existing approaches for representing query and documents.
+
+The general workflow of M-NSRF is illustrated in Figure 1. Given a sequence of queries from the same search session, e.g., “cheap furniture” and “craig list virginia”, M-NSRF is trained to predict both the result clicks under the current query and the next query “cheap furniture for sale.” It is evident that in this search session the user kept reformulating the queries because his/her information need has not been met by the result clicks in the previously submitted queries, reflected in the added and removed query terms. And such revisions suggest what he/she might want to click next. As a result, the modeling of result clicks and query reformulations mutually reinforce each other to reveal users’ underlying search intent. In M-NSRF, we model user search intent as a session-level recurrent state, the learning of which is aided by both document ranking and query prediction tasks.
+
+We evaluate the effectiveness of the proposed framework using the publicly available AOL search log and compare with several well-known classical retrieval models, as well as various neural retrieval models specifically designed for ad-hoc retrieval. We also compare M-NSRF with several baseline models for the query prediction task. The empirical results show that by leveraging information in both tasks, the proposed approach outperforms existing models significantly on ad-hoc document retrieval task and exhibits competitive performance in query suggestion.
+
+![](images/a9ef5193be3a238f5aa45bb7d710b1d9d8cd61450f8192781d008424c2eef408.jpg)  
+Figure 1: General workflow of the proposed multi-task neural session relevance framework. The framework is trained on search sessions to jointly predict next query and rank corresponding documents. The model encodes the current query in the session, “craig list virginia”, updates corresponding session-level recurrent state, maximizes the probability of the next query, “cheap furniture for sale” (i.e., the task of query suggestion), encodes the candidate documents for the following query and minimizes loss for clicked documents (i.e., the task of document ranking).
+
+To summarize, the key contributions of this work include:
+
+1. We propose a novel multi-task neural session relevance model that is jointly trained on document ranking and query suggestion tasks by utilizing in-session queries and clicks in a holistic way.   
+2. We provide detailed experiment analysis, and release the implementation1 and the data processing tool to facilitate future research.
+
+# 2 RELATED WORK AND BACKGROUND
+
+Ad-hoc Retrieval. Traditional retrieval models such as query likelihood (Ponte & Croft, 1998) and BM25 (Robertson et al., 2009) are based on exact matching of query and document words with a variety of smoothing, weighting and normalization techniques. Recently, deep neural network based approaches demonstrate strong advance in ad-hoc retrieval. Existing neural ranking models fall into two categories: representation focused (Huang et al., 2013; Gao et al., 2014) and interaction focused (Guo et al., 2016b). The earlier focus of neural ranking models was mainly on representation based models (Hu et al., 2014; Shen et al., 2014), in which the query and documents are first embedded into continuous vectors, and the ranking is calculated based on their embeddings’ similarity. The interaction focused neural models (Hu et al., 2014; Pang et al., 2016; Guo et al., 2016a), on the other hand, learn query-document matching patterns from word-level interactions. Both the interaction and representation focused models can be combined for further improvements (Mitra et al., 2017). Similarly, Jaech et al. (2017) captures both local relevance matching and global topicality signals when computing relevance of a document to a query. Our work falls into the representation focused approach to form query and document representations and jointly models the two tasks through session representation learning.
+
+Query Suggestion. In general, query suggestion algorithms define various distance metrics between queries to find the most similar ones as suggestions for one another (Wen et al., 2001; Baeza-Yates et al., 2004). The closest work to ours is the end-to-end hierarchical recurrent encoder-decoder architecture (HRED-qs) (Sordoni et al., 2015), which ranks candidates for context-aware query suggestion. Our proposed framework differs from HRED-qs as it integrates another important type of user search behavior, i.e., result clicks, into the joint modeling, which provides additional contextual information for query suggestion. Mitra & Craswell (2015) proposed a candidate generation approach for rare prefixes using frequently observed query suffixes and suggested a neural model to generate ranking features along with n-gram features. Similarly, a large pool of previous works investigated task or context-aware approaches (Cao et al., 2008; He et al., 2009; Feild & Allan, 2013; Chen et al., 2017; Garigliotti & Balog, 2017) for query suggestion.
+
+Multi-task Learning. The goal of multi-task learning is to improve generalization on the target task by leveraging the domain-specific information contained in the training signals of related tasks (Caruana, 1998). Multi-task learning in combination with deep neural networks has been successfully used in many application scenarios, including natural language processing (Collobert & Weston, 2008; Liu et al., 2016a;b; Peng & Dredze, 2017; Peng et al., 2017), speech recognition (Deng et al., 2013; Thanda & Venkatesan, 2017) and computer vision (Girshick, 2015). However, it has been less explored in the information retrieval domain. Liu et al. (2015) proposed a multi-task deep neural approach to combine query classification and document ranking, and reported improvement on both the tasks. Bai et al. (2009) used multi-task learning in learning to rank for web search. We propose to jointly learn document ranking and query suggestion via multi-task learning to better capture latent intent embedded in users’ search behaviors.
+
+# 3 MULTI-TASK NEURAL SESSION RELEVANCE FRAMEWORK
+
+We define a session to be a sequence of queries, $Q = \{ Q _ { 1 } , \ldots , Q _ { n } \}$ , submitted by a user in a short time interval in a chronological order to satisfy a specific search intent. Every query $Q _ { i }$ in a session is associated with a set of related documents $\boldsymbol { D } \doteq \{ D _ { 1 } , \ldots , D _ { m } \}$ which need to be ranked by its relevance to the query, and $o = \{ o _ { 1 } , \ldots , o _ { m } \}$ is the set of relevance labels for each document in $D$ . In typical search engine logs, $o _ { j }$ is usually approximated via user clicks, e.g., $o _ { j } = 1$ if and only if the document $D _ { j }$ is clicked. A query $Q _ { i }$ and a document $D _ { j }$ consist of a sequence of words, i.e., $Q _ { i } = \{ w _ { i } ^ { 1 } , . . . , \bar { w } _ { i } ^ { q } \}$ and ${ D } _ { j } = \{ w _ { j } ^ { 1 } , . . . , w _ { j } ^ { d } \}$ , where $q = | Q _ { i } |$ and $d = | D _ { j } |$ are the query and document lengths respectively. $V$ is the size of vocabulary constructed over queries and relevant documents.
+
+The document ranking refers to the task of ordering the retrieved results with respect to their relevance to the given query under the users’ search intent. Accurate modeling of relevance between a document and a query is the key in this task. In this work, we model ranking of related documents as a pointwise classification problem where the goal is to predict the relevance label between a query and a document. But our developed solution can be extended to pairwise or list-wise ranking models (Liu et al., 2009). On the other hand, query suggestion refers to the task of predicting next query $Q _ { i }$ based on previous queries $Q _ { 1 } \ldots Q _ { i - 1 }$ by users in the same session, so as to help them explore the search space. The key challenge is to maintain the semantic consistency between the suggested queries and users’ original queries, with respect to their search intent.
+
+Traditional IR approaches consider document ranking and query suggestion tasks separately (Huang et al., 2013; Shen et al., 2014; Sordoni et al., 2015), although both the tasks are driven by users’ underlying search intent. In contrast, M-NSRF is designed to jointly learn a document ranker and a query recommender by modeling shared search context embedding in a session. Based on the latent session state inferred from all the previous queries and clicks in the same session, the document ranker is trained to predict user clicks from the candidate documents for the current query and the query recommender is trained in a sequence to sequence fashion (Sutskever et al., 2014) to predict the user’s next query. The process is repeated sequentially for all the queries in the same session. The detailed architecture of the proposed multi-task neural session relevance framework (M-NSRF) is provided in Appendix A. In the following, we discuss each component of M-NSRF.
+
+# 3.1 DOCUMENT RANKER
+
+Ranking the retrieved documents for an input query requires encoding the query and documents into a shared representation space. In addition to the search intent carried by the current query, search context, which is reflected in the previously submitted queries in the same session, should also be accounted in ranking the documents. In M-NSRF, we model the latent user search intent in a sequence of queries via a series of session recurrent states. As a result, the document ranker component in M-NSRF consists of a query encoder, a document encoder, a session encoder and a ranker. The ranker sub-component combines the latent representations of query and session and match them with document representations to generate the ranking score of documents, based on which the documents are ordered. The technical details of each constituent element are given as follows.
+
+Query Encoder. The query encoder encodes a query into a vector. To encode a sequence of words, various approaches have been studied. We follow (Conneau et al., 2017) to adopt a bidirectional LSTM with max pooling (BiLSTM-max), due to its superior practical performance. Considering query as a sequence of words $Q _ { i } = \{ w _ { i } ^ { 1 } , \ldots , w _ { i } ^ { q } \}$ , the encoder composed of forward and backward LSTM reads the sequence in two opposite directions,
+
+$$
+\vec { h } _ { t } = L S T M _ { t } ( \vec { h } _ { t - 1 } , w _ { i } ^ { t } ) , \quad \overleftarrow { h } _ { t } = L S T M _ { t } ( \overleftarrow { h } _ { t + 1 } , w _ { i } ^ { t } ) , \quad h _ { t } = [ \overrightarrow { h } _ { t } , \overleftarrow { h } _ { t } ]
+$$
+
+where $h _ { t } \in R ^ { 2 d }$ is the query-level recurrent state, $d$ is the dimensionality of the LSTM hidden unit initialized to a zero vector. To form a fixed-size vector representation of variable length queries, maximum value is selected over each dimension of the hidden units,
+
+$$
+Q _ { i , k } = \operatorname* { m a x } _ { q } \ h _ { k , q } , \ k = 1 , \ldots , d
+$$
+
+where $Q _ { i , k }$ is the $k$ -th element of the latent vector $Q _ { i }$ .
+
+Document Encoder. The goal of the document encoder is to encode documents into continuous vectors. We use the same BiLSTM-max technique that is utilized in encoding queries as the document encoder. The only difference is in the dimensionality of the LSTM hidden units. In general, because a document (body or title) is longer than a query, we consider dense vector of a larger size as the continuous representations of the documents.
+
+Session Encoder. The session encoder generates a representation to encode the queries that the system has received so far. Unlike query and document encoders that can read the complete encoded queries and documents, the session encoder does not have information from the future queries. Therefore, we use a unidirectional LSTM (Hochreiter & Schmidhuber, 1997) for session encoding. The session encoder takes the sequence of query representations $Q _ { 1 } , . . . , Q _ { n }$ as input and computes the sequence of session-level recurrent states.
+
+$$
+S _ { i } = L S T M _ { i } ( S _ { i - 1 } , Q _ { i } ) ,
+$$
+
+where $S _ { i } \in R ^ { d }$ is the session-level recurrent state initialized to a zero vector. As a result, each query in the session has its session-level recurrent state, summarizing the user’s information need that has been processed up to query $Q _ { i }$ .
+
+Ranker. We first concatenate the current query representation $Q _ { i }$ with previous session-level recurrent state $S _ { i - 1 }$ via a non-linear transformation. This combined representation reflects the search intent reflected in the current query and the past ones in the same session. Then we compute the ranking score of document $D _ { j }$ under the query as its probability of being relevant via a sigmoid function (with binary relevance labels),
+
+$$
+P ( D _ { j } | Q _ { i } , S _ { i - 1 } ) = \sigma \big ( D _ { j } ^ { T } \operatorname { t a n h } ( W _ { r } [ Q _ { i } , S _ { i - 1 } ] + b _ { r } ) \big ) , \ j = 1 , \dots , m
+$$
+
+where $W _ { r } \in \textit { R } ^ { ( d _ { q } + d _ { s } ) \times d _ { d } }$ , $b _ { r } ~ \in ~ R ^ { d _ { d } }$ , and $d _ { q } , \ d _ { s }$ and $d _ { d }$ are the dimensionality of the query encoder, session encoder and document encoder hidden units and $\sigma$ is the sigmoid function. A list of retrieved documents can therefore be ordered by this ranking score.
+
+# 3.2 QUERY RECOMMENDER
+
+Query recommender suggests related queries to users by inferring the underlying search intent through utilizing in-session previous queries embedded in latent vectors. Following Sutskever et al. (2014) and Bahdanau et al. (2015), the query recommender in M-NSRF predicts users’ next query in a sequence to sequence manner. Basically the query recommender module estimates the probability of the next query $\mathbf { \ddot { \cal Q } } _ { i } = \{ w _ { i } ^ { 1 } , \dots , w _ { i } ^ { q } \}$ , given all the previous queries up to position $i - 1$ in a session as follows,
+
+$$
+P ( Q _ { i } | Q _ { 1 : i - 1 } ) = \prod _ { t = 1 } ^ { q } P ( w _ { i } ^ { t } | w _ { i } ^ { 1 : t - 1 } , Q _ { 1 : i - 1 } )
+$$
+
+We use LSTM as a basic building block for the query recommender. Information about all the previous queries represented through a session vector $S _ { i }$ is passed to the query recommender. To this end, the recurrent state of the query recommender is initialized with a non-linear transformation of $S _ { i }$ , $h _ { 0 } = \operatorname { t a n h } ( W _ { q } S _ { i } + b _ { q } )$ , where $h _ { 0 } ~ \in ~ R ^ { d }$ is the initial recurrent state. Then the query recommender’s recurrence is computed by $h _ { t } = L S T M _ { t } ( h _ { t - 1 } , w _ { i } ^ { t } )$ , where $h _ { t - 1 }$ is the previous hidden state, $w _ { i } ^ { t - 1 }$ is the previous query term. Finally, each recurrent state is mapped to a probability distribution over the vocabulary of size $V$ using a combination of linear transformation and the softmax function. Word with the highest probability is chosen as the next word in sequence.
+
+$$
+P ( w | w _ { i } ^ { 1 : t - 1 } , Q _ { 1 : i - 1 } ) = g ( W _ { p } h _ { t } + b ) ,
+$$
+
+where $g$ is the softmax function that outputs a vector to represent the distribution of next words, where the probability assigned to the $j$ -th element is defined as $\begin{array} { r } { g ( z ) _ { j } = \frac { e ^ { z _ { j } } } { \sum _ { k = 1 } ^ { K } e ^ { z _ { k } } } } \end{array}$ e j PKk=1 ezk , j = 1, ..., K .
+
+Query Suggestion. In the decoding phase, similar to (Sordoni et al., 2015), we use greedy decoding algorithm for suggesting next query. Given a sequence of queries up to position $i - 1$ , a suggested query $Q _ { i }$ is:
+
+$$
+Q ^ { * } = \arg \operatorname* { m a x } _ { Q ^ { \prime } \in \mathcal { Q } } P ( Q ^ { \prime } | Q _ { 1 : i - 1 } )
+$$
+
+where $\mathcal { Q }$ is the space of all possible queries. To generate $Q ^ { * } = \{ w ^ { 1 } , \ldots , w ^ { q } \}$ , we use a greedy approach like in (Sordoni et al., 2015) where $\begin{array} { r } { w ^ { t } = \arg \operatorname* { m a x } _ { w } P ( w | w ^ { 1 : t - 1 } , Q _ { 1 : i - 1 } ) } \end{array}$ To provide query suggestions of variable lengths, we use standard word-level decoding techniques. We iteratively consider the best prefix $w _ { 1 : t }$ up to length $t$ and extend it by sampling the most probable word given the distribution in Eq. (2). The process ends when we obtain a well-formed query containing the special end-of-query token.
+
+# 3.3 LEARNING END-TO-END
+
+Within a session, M-NSRF ranks documents in a set of candidates and predicts next query given the current query sequence. Therefore, the training objective of M-NSRF consists of two terms. The first term is the binary cross entropy loss from the document ranker,
+
+$$
+\mathcal { L } _ { 1 } \equiv - \frac { 1 } { m } \sum _ { j } ^ { m } o _ { j } \times \log \ P ( D _ { j } | Q _ { i } ) + ( 1 - o _ { j } ) \times \log ( 1 - P ( D _ { j } | Q _ { i } ) )
+$$
+
+where $o _ { j }$ represents binary click label for $D _ { j }$ . The second term is the regularized negative loglikelihood loss from the query suggestion model,
+
+$$
+\mathcal { L } _ { 2 } \equiv - \sum _ { t } ^ { q } \log P ( w _ { i } ^ { t } | w _ { i } ^ { 1 : i - 1 } , Q _ { 1 : i - 1 } ) + L _ { R } ,
+$$
+
+where $\begin{array} { r } { \mathcal { L } _ { R } \equiv - \lambda \sum _ { w \in V } P ( w | w _ { i } ^ { 1 : t - 1 } , Q _ { 1 : i - 1 } ) \log P ( w | w _ { i } ^ { 1 : t - 1 } , Q _ { 1 : i - 1 } ) } \end{array}$ is the regularization term to avoid the distribution of words in Eq. (2) from being highly skewed, and $\lambda$ is a hyper-parameter to control the regularization term. The final objective is the summation of $L _ { 1 }$ and $L _ { 2 }$ over all the queries.2
+
+Note that the document ranker and query recommender share the same document, query, and session encoders, and the training of M-NSRF can be done in an online manner using the following procedure. In the forward pass, M-NSRF computes the query and corresponding document encodings, updates session-level recurrent states, click probability for each candidate document and the log-likelihood of each query in the session given the previous ones. In the backward pass, the gradients are computed and the parameters are updated based on the ADAM update rule (Kingma & Ba, 2014). Details of implementation can be found in Section 4.2
+
+# 3.4 GENERALIZING M-NSRF FOR NEURAL IR MODELS
+
+The proposed multi-task learning framework is general and the query encoder, document encoder, document ranker, and query recommender can be replaced by other designed architecture. In general, any neural query suggestion model working in the sequence to sequence fashion can be readily incorporated with the proposed multi-task learning framework. Similarly, most neural IR models that built on the notion of learning query and document representations in a latent space for relevance modeling can be Incorporated in our framework as well. However, due to distinctive nature of different neural IR models, careful study is required while adding context-awareness into the final architecture.
+
+In this paper, we take the Match-Tensor model (Jaech et al., 2017), a recently proposed neural relevance model for document ranking as an example and extend it to a multi-task Match-Tensor (M-Match-Tensor) model by incorporating the query recommender component within our proposed multi-task learning framework. Different from NSRF, which embeds queries and documents into vectors, Match-Tensor learns a contextual representation for each word in the queries and documents. Therefore, documents and queries are represented as matrices. The document ranker in Match-Tensor then computes the relevant score based on the following formulation:
+
+$$
+P ( D _ { j } | Q _ { i } ) = \sigma \big ( W _ { r } C ( Q _ { i } , D _ { j } ) + b _ { r } \big ) , i = 1 , \ldots , m
+$$
+
+where $C$ represents a sequence of convolutional operation (Lawrence et al., 1997) and max-pooling on the $2 d$ product of the query and document vectors. The detailed architecture of the M-MatchTensor model (M-Match-Tensor) is provided in Appendix B. To incorporate the match-tensor in our mulit-task learning framework, we can replace the document encoder, query encoder, and the document ranker in M-NSRF with the ones specified in the Match-Tensor model. However, as the computations involve in the document ranker is substantial, we do not increase the computational complexity further by adding session recurrence in the document ranking. The query decoding component in M-Match-Tensor is identical to M-NSRF. In the experiment, we will show that multitask Match-Tensor achieves better performance than Match-Tensor in document ranking task.
+
+# 4 EXPERIMENTS
+
+# 4.1 DATA SETS AND EVALUATION METHODOLOGY
+
+We conduct our experiments on the publicly available AOL search log (Pass et al., 2006). The queries in this dataset were sampled between 1 March, 2006 and 31 May, 2006. In total there are 16,946,938 queries submitted by 657,426 unique users. We removed all non-alphanumeric characters from the queries, applied word segmentation and lowercasing. We followed (Jansen Bernard et al., 2007) to define a session by a 30-minute window of inactive time, and filtered sessions by their lengths (minimum 2, maximum 10). We only kept the most frequent $| V | = 1 0 0 k$ words and mapped all other words to an $< u n k >$ token when constructing the vocabulary. We randomly selected 1,032,459 sessions for training, 129,053 sessions for development and 91,108 sessions for testing, with no overlapping. In total, there are 2,987,486 queries for training, 287,138 for development, and 259,117 for testing. The average length of the queries and documents (only the title field) are 3.15 and 6.77 respectively. In our experiments, we set maximum allowable length of query and document to 10 and 20 respectively.
+
+In the document ranking task, we need to rank the most relevant (e.g., most clickable) document on top. We used three standard ranking metrics, mean average precision (MAP), mean reciprocal rank (MRR) and normalized discounted cumulative gain (NDCG) metric computed at positions one, three, five and ten, to measure the performance. Since AOL search log only contains clicked documents, we constructed the ranking candidates by the top ranked documents by BM25 (Robertson et al., 2009). Each query in the test set consists of 50 candidate documents including the clicked ones. However, to reduce the training time and memory use, each query in training and development set only contains 5 candidates.
+
+In the query suggestion task, we need to suggest the most semantically related query to users. As we do not have user feedback on the suggested queries, we treated the users’ next submitted query as ground-truth (Sordoni et al., 2015), and used the BLEU scores (Papineni et al., 2002) as the evaluation metric, which is a popularly used metric in machine translation and text generation tasks. In addition, following (Santos et al., 2013; Sordoni et al., 2015), we evaluated the query suggestion quality by mean reciprocal rank (MRR), i.e., to test if the algorithm can rank the users’ next query on top of its recommendation list. In this set of experiments, given a set of candidate queries, query suggestion models give a likelihood score of generating the candidates. We follow Sordoni et al. (2015) for dataset split and generate candidates using a co-occurrence based suggestion model. Like Sordoni et al. (2015), we give the anchor queries (second last query of a session) as an input to the query suggestion model and evaluates the rank of the next query among the candidates.
+
+# 4.2 BASELINES AND IMPLEMENTATION DETAILS
+
+Document Ranking Baselines. We compared M-NSRF and M-Match Tensor with word-based baselines and neural network-based baselines. Word-based baselines include query likelihood model based on Dirichlet smoothing (QL) (Ponte & Croft, 1998) and BM25 (Robertson et al., 2009). In addition, following (Mitra et al., 2016), we investigated the ranking performance of a simple word embedding-based model using GloVe word embeddings (Pennington et al., 2014). To compare with neural models, we consider baselines broadly categorized in representation-focused, interactionfocused and a combination of both. Representation-focused neural baselines include: DSSM (Huang et al., 2013), CLSM (Shen et al., 2014), ARC-I (Hu et al., 2014) and interaction-focused baselines include: ARC-II (Hu et al., 2014) and DRMM (Guo et al., 2016a). A combination of representation and interaction focused models include: DUET (Mitra et al., 2017) and Match Tensor (Jaech et al., 2017). Details of these models are provided in Appendix C. We implemented all the baseline models in PyTorch.
+
+Table 1: Comparison of document ranking models over the AOL search log.   
+
+<table><tr><td rowspan=2 colspan=1>Model Type</td><td rowspan=2 colspan=1>Model Name</td><td rowspan=2 colspan=1>MAP</td><td rowspan=2 colspan=1>MRR</td><td rowspan=1 colspan=4>NDCG</td></tr><tr><td rowspan=1 colspan=1>@1</td><td rowspan=1 colspan=1>@3</td><td rowspan=1 colspan=1>@5</td><td rowspan=1 colspan=1>@10</td></tr><tr><td rowspan=2 colspan=1>TraditionalIR-models</td><td rowspan=2 colspan=1>BM25QL</td><td rowspan=2 colspan=1>0.1640.139</td><td rowspan=1 colspan=1>0.172</td><td rowspan=1 colspan=1>0.121</td><td rowspan=1 colspan=1>0.136</td><td rowspan=1 colspan=1>0.141</td><td rowspan=1 colspan=1>0.156</td></tr><tr><td rowspan=1 colspan=1>0.146</td><td rowspan=1 colspan=1>0.088</td><td rowspan=1 colspan=1>0.108</td><td rowspan=1 colspan=1>0.122</td><td rowspan=1 colspan=1>0.133</td></tr><tr><td rowspan=1 colspan=1>Embedding-based</td><td rowspan=1 colspan=1>ESM</td><td rowspan=1 colspan=1>0.214</td><td rowspan=1 colspan=1>0.179</td><td rowspan=1 colspan=1>0.118</td><td rowspan=1 colspan=1>0.127</td><td rowspan=1 colspan=1>0.139</td><td rowspan=1 colspan=1>0.158</td></tr><tr><td rowspan=2 colspan=1>RepresentationFocused</td><td rowspan=2 colspan=1>DSSMCLSMARC-I</td><td rowspan=2 colspan=1>0.2630.4650.383</td><td rowspan=2 colspan=1>0.2870.5050.413</td><td rowspan=1 colspan=1>0.152</td><td rowspan=2 colspan=1>0.2060.4410.343</td><td rowspan=2 colspan=1>0.2480.4820.404</td><td rowspan=2 colspan=1>0.3150.5230.467</td></tr><tr><td rowspan=1 colspan=1>0.3690.238</td></tr><tr><td rowspan=1 colspan=1>InteractionFocused</td><td rowspan=1 colspan=1>DRMMARC-II</td><td rowspan=1 colspan=1>0.2770.423</td><td rowspan=1 colspan=1>0.3160.455</td><td rowspan=1 colspan=1>0.2210.294</td><td rowspan=1 colspan=1>0.2420.386</td><td rowspan=1 colspan=1>0.2670.442</td><td rowspan=1 colspan=1>0.3040.501</td></tr><tr><td rowspan=1 colspan=1>Representation andInteraction Focused</td><td rowspan=1 colspan=1>DUETMatch-Tensor</td><td rowspan=1 colspan=1>0.2720.613</td><td rowspan=1 colspan=1>0.3010.621</td><td rowspan=1 colspan=1>0.1520.568</td><td rowspan=1 colspan=1>0.2120.572</td><td rowspan=1 colspan=1>0.2630.596</td><td rowspan=1 colspan=1>0.3410.618</td></tr><tr><td rowspan=1 colspan=1>Neural Session Model(this paper)</td><td rowspan=1 colspan=1>NSRF</td><td rowspan=1 colspan=1>0.553</td><td rowspan=1 colspan=1>0.568</td><td rowspan=1 colspan=1>0.481</td><td rowspan=1 colspan=1>0.526</td><td rowspan=1 colspan=1>0.555</td><td rowspan=1 colspan=1>0.574</td></tr><tr><td rowspan=1 colspan=1>Multi-task Model(this paper)</td><td rowspan=1 colspan=1>M-NSRFM-Match-Tensor</td><td rowspan=1 colspan=1>0.5810.621</td><td rowspan=1 colspan=1>0.6030.634</td><td rowspan=1 colspan=1>0.5230.572</td><td rowspan=1 colspan=1>0.5680.578</td><td rowspan=1 colspan=1>0.5830.602</td><td rowspan=1 colspan=1>0.6140.632</td></tr></table>
+
+Query Suggestion Baselines. To evaluate the performance on query suggestion task, we consider three baseline methods including Seq2seq model proposed by Bahdanau et al. (2015), Seq2seq with global attention mechanism (Luong et al., 2015) and HRED-qs (Sordoni et al., 2015). Details of these models are provided in appendix D. We implemented all three baselines in PyTorch and optimized using negative log-likelihood loss as in Eq. (3).
+
+Implementation Details of M-NSRF. The model was trained end-to-end and we used mini-batch SGD with Adam (Kingma & Ba, 2014) for optimization. with the two momentum parameters set to 0.9 and 0.999 respectively. We use 300-dimensional word vectors trained with GloVe (Pennington et al., 2014) on 840 billion of tokens to initialize the word embeddings. Out-of-vocabulary words were randomly initialized by sampling values from a zero-mean unit-variance normal distribution. All training used a mini-batch size of 32 to fit in single GPU memory. Learning rate was fixed to 0.001. We used dropout (0.20) (Srivastava et al., 2014) and early stopping with a patience of 5 epochs for regularization. We set $\lambda = 0 . 1$ for entropy regularization in Eq. (3). M-NSRF is implemented in PyTorch and it runs on a single GPU (TITAN X) with roughly a runtime of 90 minutes per epoch. In general, M-NSRF runs up to 20 epochs and we select the model that achieves the minimum loss on the development set.
+
+# 4.3 EVALUATION RESULTS
+
+Document Ranking Quality. Table 1 shows the performance of NSRF, M-NSRF, M-Match-Tensor and other baseline models. NSRF significantly outperforms all the baselines except the MatchTensor model. However, the model size of NSRF is much smaller than Match-Tensor. With multitask learning, both M-NSRF and M-Match-Tensor outperform NSRF and Match-Tensor, respectively. To study the advantage of multi-task learning on our proposed approach, we trained M-NSRF only on document ranking task (noted as NSRF in Table 1) and observed significant performance drop which endorses the mutual benefit of joint learning of these two tasks via multi-task learning.
+
+Existing neural ranking models, like DRMM and DUET architecture, achieved sub-optimal performance in our experiments. We believe because of the simple architecture of DRMM with few hundreds of parameters, the model fell behind to show competitive performance on the evaluation dataset. On the other hand, we believe that the use of smaller number of top character $n$ -graphs (in our case, 5000) by the DUET architecture limits its effectiveness in modeling representation and interaction focused features to compute matching quality between query and document. We have to note that, some negative results have been reported for document title-based ad-hoc retrieval tasks (Guo et al., 2016a); and thus in our future work, we plan to investigate M-NSRF and all baseline models’ performance with document body content considered.
+
+Table 2: Examples of next query suggested by M-NSRF given all previous queries in a session.   
+
+<table><tr><td>Previous session queries Next user query Suggested next query</td><td>types of weapons of mass destruction, weapons of mass destruc- tion, nuclear weapons biological weapons destructive nuclear weapons</td></tr><tr><td>Previous session queries Next user query Suggested next query</td><td>resume template,resume template free,resume word perfect template free, wordperfect com wordperfect resume templates free free microsoft word templates</td></tr></table>
+
+Table 3: Comparison of different query suggestion models.   
+
+<table><tr><td rowspan=2 colspan=1>Model Name</td><td rowspan=1 colspan=4>BLEU</td><td rowspan=2 colspan=1>MRR²</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>4</td></tr><tr><td rowspan=1 colspan=1>Seq2seq</td><td rowspan=1 colspan=1>24.5</td><td rowspan=1 colspan=1>9.7</td><td rowspan=1 colspan=1>4.5</td><td rowspan=1 colspan=1>1.9</td><td rowspan=1 colspan=1>0.229</td></tr><tr><td rowspan=1 colspan=1>Seq2seq with attention</td><td rowspan=1 colspan=1>28.1</td><td rowspan=1 colspan=1>15.7</td><td rowspan=1 colspan=1>10.4</td><td rowspan=1 colspan=1>8.5</td><td rowspan=1 colspan=1>0.252</td></tr><tr><td rowspan=1 colspan=1>HRED-qsHRED-qs w/ entropy regularizer</td><td rowspan=1 colspan=1>26.427.6</td><td rowspan=1 colspan=1>13.615.1</td><td rowspan=1 colspan=1>7.99.2</td><td rowspan=1 colspan=1>5.86.7</td><td rowspan=1 colspan=1>0.2310.233</td></tr><tr><td rowspan=2 colspan=1>M-NSRFM-NSRF w/ entropy regularizer</td><td rowspan=2 colspan=1>26.828.6</td><td rowspan=1 colspan=1>14.1</td><td rowspan=1 colspan=1>8.4</td><td rowspan=1 colspan=1>6.1</td><td rowspan=2 colspan=1>0.2350.238</td></tr><tr><td rowspan=1 colspan=1>16.7</td><td rowspan=1 colspan=1>10.2</td><td rowspan=1 colspan=1>8.3</td></tr></table>
+
+Query Suggestion Accuracy. Examples of the predicted queries by M-NSRF given preceding queries from the same session is presented in Table 2 (more examples are provided in Appendix E). The quantitative comparison results in this task between our proposed framework and baseline models are presented in Table 3. While M-NSRF and HRED-qs consider information from all preceding queries in the same session, the other two baselines only consider the current query to predict the next one. Table 3 shows that M-NSRF outperformed seq2seq and HRED-qs baselines in all measured BLUE scores, and MRR; but the Seq2seq with attention baseline performed better than M-NSRF in terms of BLEU-3, BLEU-4 and $\mathbf { M R R } ^ { 3 }$ .
+
+We investigated the advantage of attention mechanism in this particular task and found it performs well when there is a considerable overlap between the input and output queries. Specifically, in more than $2 5 \%$ of the test sessions, the input queries and their next queries are exactly the same; and the attention mechanism encourages the model to repeat words from the input query. When we restrict the experiment on test sessions that have no overlap between the input and its next query, the Seq2seq with attention baseline encountered significant performance drop, while M-NSRF provided improved performance compared to all baselines (approx. $5 \%$ , $10 \%$ and $1 \%$ improvement in terms of MRR over Seq2seq, Seq2seq with attention and HRED-qs model). The major reason for this improvement is that our model leverages the global session information and is therefore not restricted by the input query and is able to generate related but totally new queries (as shown in Appendix E).
+
+We also observed that entropy-based regularization helped M-NSRF in predicting the next query, as shown in Table 3 that M-NSRF without regularization achieved worse performance in all measured BLUE scores. We further investigated the utility of regularization for the baselines. We found significant $( \sim 1 . 2 \% )$ improvement for the HRED-qs, but the performance improvement for the seq2seq and seq2seq with attention mechanism is rather marginal $( \sim 0 . 2 \% )$ . However, the regularization technique does not introduce any significant difference to the ranking based evaluation.
+
+Table 4: Ablation study for performance analysis of M-NSRF. Statistical significances are compared with NSRF’s full model and presented in bold-faced. $\dagger$ indicates M-NSRF is trained to learn word embeddings, no pre-trained embeddings were used.   
+
+<table><tr><td rowspan=1 colspan=1>NSRF Variant</td><td rowspan=1 colspan=1>MAP</td><td rowspan=1 colspan=1>NDCG@1</td><td rowspan=1 colspan=1>NDCG@3</td><td rowspan=1 colspan=1>NDCG@10</td></tr><tr><td rowspan=1 colspan=1>Full model</td><td rowspan=1 colspan=1>0.581</td><td rowspan=1 colspan=1>0.523</td><td rowspan=1 colspan=1>0.568</td><td rowspan=1 colspan=1>0.614</td></tr><tr><td rowspan=2 colspan=1>Fixed embeddingsLearned embeddingst</td><td rowspan=1 colspan=1>0.252 (-0.329)</td><td rowspan=1 colspan=1>0.182 (-0.341)</td><td rowspan=1 colspan=1>0.216(-0.352)</td><td rowspan=1 colspan=1>0.289(-0.325)</td></tr><tr><td rowspan=1 colspan=1>0.302 (-0.279)</td><td rowspan=1 colspan=1>0.222 (-0.301)</td><td rowspan=1 colspan=1>0.261(-0.307)</td><td rowspan=1 colspan=1>0.297 (-0.317)</td></tr><tr><td rowspan=1 colspan=1>Mean-poolBiLSTM-last</td><td rowspan=1 colspan=1>0.576(-0.005)0.563 (-0.018)</td><td rowspan=1 colspan=1>0.515 (-0.008)0.505 (-0.018)</td><td rowspan=1 colspan=1>0.561(-0.007)0.541(-0.027)</td><td rowspan=1 colspan=1>0.608(-0.006)0.594(-0.020)</td></tr><tr><td rowspan=1 colspan=1>M-NRF</td><td rowspan=1 colspan=1>0.553 (-0.028)</td><td rowspan=1 colspan=1>0.494 (-0.029)</td><td rowspan=1 colspan=1>0.544 (-0.024)</td><td rowspan=1 colspan=1>0.582 (-0.032)</td></tr><tr><td rowspan=1 colspan=1>GloVe 6B 50dGloVe 6B 100dGloVe 6B 200d</td><td rowspan=1 colspan=1>0.247 (-0.324)0.312 (-0.269)0.378 (-0.203)</td><td rowspan=1 colspan=1>0.196(-0.329)0.241 (-0.282)0.356(-0.167)</td><td rowspan=1 colspan=1>0.232 (-0.336)0.273 (-0.295)0.447 (-0.121)</td><td rowspan=1 colspan=1>0.296(-0.348)0.306(-0.308)0.498 (-0.116)</td></tr><tr><td rowspan=2 colspan=1>Q128D256S512Q512D1024S2048</td><td rowspan=2 colspan=1>0.562 (-0.019)0.586 (+0.005)</td><td rowspan=1 colspan=1>0.507 (-0.016)</td><td rowspan=1 colspan=1>0.544 (-0.024)</td><td rowspan=1 colspan=1>0.582 (-0.032)</td></tr><tr><td rowspan=1 colspan=1>0.528 (+0.005)</td><td rowspan=1 colspan=1>0.571 (+0.003)</td><td rowspan=1 colspan=1>0.617 (+0.003)</td></tr></table>
+
+Comparing to HRED-qs, we conclude multi-task learning also helps M-NSRF achieve improved performance in query suggestion task, as the baseline employs a very similar model as ours for query suggestion. The comparison with Seq2seq with attention suggests adding attention over session information is a promising direction to further improve query suggestions quality as it emphasizes the information carried by the immediately previous query. We will pursue this in our future work.
+
+# 4.4 ABLATION STUDY ON M-NSRF
+
+We conducted experiments to better understand the effectiveness of different components in the MNSRF. We also analyzed the impact of word embeddings and hidden units dimension in M-NSRF’s performance. Our findings are presented in Table 4.
+
+Impact of Different Model Components. To study the effect of different model components, we compared the full M-NSRF with several simpler versions of the model. At first, we turned off training for word embeddings and found a significant decrease in performance. In our training dataset, we have roughly $\vert O O V \vert = 2 6 k$ out-of-vocabulary words and thus, training the word embeddings turned out to be very important on this data set. Also, we investigated the role of pre-trained word embeddings (ex., GloVe embeddings) and found significant performance decrease $( 2 7 . 9 \%$ drop in MAP) if we train M-NSRF without any pre-trained word embeddings. Hence, we can conclude that the use of pre-trained word embeddings and training them further is important to achieve better performance in M-NSRF. Second, we investigated the advantages of using max-pooling over mean-pooling and considering the last hidden recurrent state for query and document representation. We observed that max-pooling and mean-pooling provide almost the same performance while biLSTM-last approach lags slightly. To further analyze the features identified by the query and document encoders using the max-pooling technique, we followed the idea of visualization proposed in (Conneau et al., 2017). We provide an example in Figure 2 where document $^ { l }$ is clicked by the user (a positive example) and document 2, 3 is retrieved by BM25 but not clicked (negative examples). We observed that the query and document encoders identified distinct features (e.g., the word priceline in the first document’s title is most important) which help differentiate between clicked and unclicked documents.
+
+In another variant of M-NSRF, we did not use the session recurrent state when computing relevance score for the candidate documents to examine the influence of previous queries from the same session on the ranking performance. We refer to this variant of M-NSRF as multi-task neural relevance model (M-NRF). From Table 4 we can find that without session information the performance drops by $2 . 8 \%$ in terms of MAP. We further investigated and found the session information helps particularly for longer sessions (session length $> 5$ ). In our evaluation dataset, we have roughly 5000 sessions of length greater than 5 (91 thousands in total).
+
+Impact of Dimensionality. We further study the impact of dimensionality of the word embeddings, query, document and session latent vectors. In M-NSRF, we set the dimension of query, document and session latent vectors to 256, 512 and 1024 respectively. As shown in Table 4, decreasing the dimensions of latent vectors, decreases the performance; while increasing the dimensions further, does not affect the performance significantly. We also experimented with different dimensions of pre-trained word embeddings (50d, 100d and 200d GloVe (Pennington et al., 2014) embeddings). Word embeddings of different dimensions provide different granularity of semantic similarity; with lower dimensionality, the similarity between word embeddings might be coarse and thus hard to capture matching between two text sequences. In our experiment, we found 300 dimension for embeddings works significantly better than other dimensionality on this data set.
+
+![](images/4792b6954c35a387bbd976dc8f77d0b640e5d417b101e7d7027427a8517f7987.jpg)  
+Figure 2: Example showing query and document term importance identified by M-NSRF while ranking candidate documents for the given query.
+
+# 5 CONCLUSIONS
+
+Existing deep neural models for ad-hoc retrieval often omit session information and are only trained on individual query-document pairs. In this work, we propose a context-aware multi-task neural session relevance framework which works in a sequence to sequence fashion, and show that sharing session-level latent recurrent states across document ranking and query suggestion tasks benefits each other. Our experiments and analysis not only demonstrate the effectiveness of the proposed framework, but also provide useful intuitions about the advantages of multi-task learning involving deep neural networks for two different information retrieval tasks.
+
+As our future work, we would like to leverage the content from document body and click sequence to update M-NSRF (especially the session-level recurrent states) so that we can further explore the potential of the proposed framework for ad-hoc retrieval. As attention mechanism shows promise in improving query suggestion performance, we also also explore it in our multi-task learning setting. In addition, a broad research direction is to go beyond session boundaries to model users’ long-term search goals to enhance personalized search results and query suggestions.
+
+Acknowledgement. This work was supported in part by National Science Foundation Grant IIS1760523, IIS-1553568, IIS-1618948, and the NVIDIA Hardware Grant.
+
+# REFERENCES
+
+Ricardo A Baeza-Yates, Carlos A Hurtado, Marcelo Mendoza, et al. Query recommendation using query logs in search engines. In EDBT workshops, volume 3268, pp. 588–596. Springer, 2004.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. International Conference on Learning Representations, 2015.
+
+Jing Bai, Ke Zhou, Guirong Xue, Hongyuan Zha, Gordon Sun, Belle Tseng, Zhaohui Zheng, and Yi Chang. Multi-task learning for learning to rank in web search. In Proceedings of the 18th ACM International on Conference on Information and Knowledge Management, pp. 1549–1552. ACM, 2009.
+
+Huanhuan Cao, Daxin Jiang, Jian Pei, Qi He, Zhen Liao, Enhong Chen, and Hang Li. Context-aware query suggestion by mining click-through and session data. In Proceedings of the 14th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 875–883. ACM, 2008.
+
+Rich Caruana. Multitask learning. In Learning to learn, pp. 95–133. Springer, 1998.
+
+Wanyu Chen, Fei Cai, Honghui Chen, and Maarten de Rijke. Personalized query suggestion diversification. Proceedings of the 37th ACM SIGIR conference on Research and development in information retrieval, 2017.
+
+Ronan Collobert and Jason Weston. A unified architecture for natural language processing: Deep neural networks with multitask learning. In Proceedings of the 25th international conference on Machine learning, pp. 160–167. ACM, 2008.
+
+Alexis Conneau, Douwe Kiela, Holger Schwenk, Lo¨ıc Barrault, and Antoine Bordes. Supervised learning of universal sentence representations from natural language inference data. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 670–680. Association for Computational Linguistics, 2017.
+
+W Bruce Croft, Donald Metzler, and Trevor Strohman. Search engines: Information retrieval in practice, volume 283. Addison-Wesley Reading, 2010.
+
+Li Deng, Geoffrey Hinton, and Brian Kingsbury. New types of deep neural network learning for speech recognition and related applications: An overview. In Acoustics, Speech and Signal Processing (ICASSP), 2013 IEEE International Conference on, pp. 8599–8603. IEEE, 2013.
+
+Henry Feild and James Allan. Task-aware query recommendation. In Proceedings of the 36th ACM SIGIR conference on Research and development in information retrieval, pp. 83–92. ACM, 2013.
+
+Jianfeng Gao, Li Deng, Michael Gamon, Xiaodong He, and Patrick Pantel. Modeling interestingness with deep neural networks, June 13 2014. US Patent App. 14/304,863.
+
+Dario Garigliotti and Krisztian Balog. Generating query suggestions to support task-based search. In Proceedings of the 40th ACM SIGIR conference on Research and development in information retrieval, pp. 1153–1156. ACM, 2017.
+
+Ross Girshick. Fast r-cnn. In Proceedings of the IEEE international conference on computer vision, pp. 1440– 1448, 2015.
+
+Jiafeng Guo, Yixing Fan, Qingyao Ai, and W Bruce Croft. A deep relevance matching model for ad-hoc retrieval. In Proceedings of the 25th ACM International on Conference on Information and Knowledge Management, pp. 55–64. ACM, 2016a.
+
+Jiafeng Guo, Yixing Fan, Qingyao Ai, and W Bruce Croft. Semantic matching by non-linear word transportation for information retrieval. In Proceedings of the 25th ACM International on Conference on Information and Knowledge Management, pp. 701–710. ACM, 2016b.
+
+Qi He, Daxin Jiang, Zhen Liao, Steven CH Hoi, Kuiyu Chang, Ee-Peng Lim, and Hang Li. Web query recommendation via sequential query prediction. In Data Engineering, 2009. ICDE’09. IEEE 25th International Conference on, pp. 1443–1454. IEEE, 2009.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8):1735–1780, 1997.
+
+Baotian Hu, Zhengdong Lu, Hang Li, and Qingcai Chen. Convolutional neural network architectures for matching natural language sentences. In Advances in neural information processing systems, pp. 2042– 2050, 2014.
+
+Po-Sen Huang, Xiaodong He, Jianfeng Gao, Li Deng, Alex Acero, and Larry Heck. Learning deep structured semantic models for web search using clickthrough data. Proceedings of the 22nd ACM International on Conference on Information and Knowledge Management, pp. 2333–2338, 2013.
+
+Aaron Jaech, Hetunandan Kamisetty, Eric Ringger, and Charlie Clarke. Match-tensor: a deep relevance model for search. arXiv preprint arXiv:1701.07795, 2017.
+
+J Jansen Bernard, Amanda Spink, Chris Blakely, and Sherry Koshman. Defining a session on web search engines: Research articles. Journal of the American Society for Information Science and Technology, 58(6): 862–871, 2007.
+
+Jyun-Yu Jiang, Yen-Yu Ke, Pao-Yu Chien, and Pu-Jen Cheng. Learning user reformulation behavior for query auto-completion. In Proceedings of the 37th ACM SIGIR conference on Research and development in information retrieval, pp. 445–454. ACM, 2014.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Steve Lawrence, C Lee Giles, Ah Chung Tsoi, and Andrew D Back. Face recognition: A convolutional neuralnetwork approach. IEEE transactions on neural networks, 8(1):98–113, 1997.
+
+Pengfei Liu, Xipeng Qiu, and Xuanjing Huang. Deep multi-task learning with shared memory for text classification. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pp. 118–127, 2016a.
+
+Pengfei Liu, Xipeng Qiu, and Xuanjing Huang. Recurrent neural network for text classification with multi-task learning. Proceedings of the Twenty-Fifth International Joint Conference on Artificial Intelligence, 2016b.
+
+Tie-Yan Liu et al. Learning to rank for information retrieval. Foundations and Trends $\textsuperscript { \textregistered }$ in Information Retrieval, 3(3):225–331, 2009.
+
+Xiaodong Liu, Jianfeng Gao, Xiaodong He, Li Deng, Kevin Duh, and Ye-Yi Wang. Representation learning using multi-task deep neural networks for semantic classification and information retrieval. In Proceedings of the 2015 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 912–921, 2015.
+
+Thang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches to attention-based neural machine translation. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pp. 1412–1421, 2015.
+
+Bhaskar Mitra and Nick Craswell. Query auto-completion for rare prefixes. In Proceedings of the 24th ACM International on Conference on Information and Knowledge Management, pp. 1755–1758. ACM, 2015.
+
+Bhaskar Mitra, Eric Nalisnick, Nick Craswell, and Rich Caruana. A dual embedding space model for document ranking. arXiv preprint arXiv:1602.01137, 2016.
+
+Bhaskar Mitra, Fernando Diaz, and Nick Craswell. Learning to match using local and distributed representations of text for web search. pp. 1291–1299. International World Wide Web Conferences Steering Committee, 2017.
+
+Liang Pang, Yanyan Lan, Jiafeng Guo, Jun Xu, Shengxian Wan, and Xueqi Cheng. Text matching as image recognition. Association for the Advancement of Artificial Intelligence, pp. 2793–2799, 2016.
+
+Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. Bleu: a method for automatic evaluation of machine translation. In Proceedings of the 40th annual meeting on association for computational linguistics, pp. 311–318. Association for Computational Linguistics, 2002.
+
+Greg Pass, Abdur Chowdhury, and Cayley Torgeson. A picture of search. In InfoScale, volume 152, pp. 1, 2006.
+
+Nanyun Peng and Mark Dredze. Multi-task domain adaptation for sequence tagging. In Proceedings of the 2nd Workshop on Representation Learning for NLP, pp. 91–100, 2017.
+
+Nanyun Peng, Hoifung Poon, Chris Quirk, Kristina Toutanova, and Wen-tau Yih. Cross-sentence n-ary relation extraction with graph lstms. Transactions of the Association for Computational Linguistics, 5:101–115, 2017.
+
+Jeffrey Pennington, Richard Socher, and Christopher Manning. Glove: Global vectors for word representation. Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pp. 1532–1543, 2014.
+
+Jay M Ponte and W Bruce Croft. A language modeling approach to information retrieval. In Proceedings of the 21st ACM SIGIR conference on Research and development in information retrieval, pp. 275–281. ACM, 1998.
+
+Stephen Robertson, Hugo Zaragoza, et al. The probabilistic relevance framework: Bm25 and beyond. Foundations and Trends $\textsuperscript { \textregistered }$ in Information Retrieval, 3(4):333–389, 2009.
+
+Rodrygo LT Santos, Craig Macdonald, and Iadh Ounis. Learning to rank query suggestions for adhoc and diversity search. Information Retrieval, 16(4):429–451, 2013.
+
+Yelong Shen, Xiaodong He, Jianfeng Gao, Li Deng, and Gregoire Mesnil. A latent semantic model with´ convolutional-pooling structure for information retrieval. In Proceedings of the 23rd ACM International on Conference on Information and Knowledge Management, pp. 101–110. ACM, 2014.
+
+Alessandro Sordoni, Yoshua Bengio, Hossein Vahabi, Christina Lioma, Jakob Grue Simonsen, and Jian-Yun Nie. A hierarchical recurrent encoder-decoder for generative context-aware query suggestion. Proceedings of the 24th ACM International on Conference on Information and Knowledge Management, pp. 553–562, 2015.
+
+Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of machine learning research, 15(1): 1929–1958, 2014.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104–3112, 2014.
+
+Abhinav Thanda and Shankar M Venkatesan. Multi-task learning of deep neural networks for audio visual automatic speech recognition. arXiv preprint arXiv:1701.02477, 2017.
+
+Ji-Rong Wen, Jian-Yun Nie, and Hong-Jiang Zhang. Clustering user queries of a search engine. In Proceedings of the 10th international conference on World Wide Web, pp. 162–168. acm, 2001.
+
+# A MULTITASK NEURAL SESSION RELEVANCE FRAMEWORK
+
+![](images/83c46148e4e6af4c9d203864f201eaf5920e678a89b0c13d367bcdc4a99f8beb.jpg)  
+Figure 3: Architecture of the Multi-task Neural Session Relevance Framework (M-NSRF). M-NSRF uses bi-LSTM with max pooling to form query and document representations and use LSTM to gather session-level information. These recurrent states (current query representation and sessionlevel recurrent state, which summarizes all previous queries) are used by query decoder and document ranker for predicting next query and computing relevance scores.
+
+# B MULTITASK MATCH-TENSOR ARCHITECTURE
+
+![](images/fd777dc795cce8647616e23db141d0ddd6ab1bc7d9e4204093caf79b2101c00e.jpg)  
+Figure 4: Architecture of the Multi-task Match-Tensor Model (M-Match-Tensor).
+
+# C DOCUMENT RANKING BASELINES
+
+Deep semantic similarity model, DSSM (Huang et al., 2013) maps words to letter tri-grams using a word-hashing technique and uses a feed-forward neural network to build representations for both query and document. Similarity, convolutional latent semantic model, CLSM (Shen et al., 2014) uses word-hashing technique and uses convolutional neural networks (CNN) to build query and document representations. To compute relevance between query and document, both DSSM and
+
+CLSM uses cosine similarity. ARC-I (Hu et al., 2014) uses CNN to form query and document representations and employs a multi-layer perceptron to compute relevance score. In our implementation, we used 128 convolution filters of size 1, 2 and 256 filters of size 3.
+
+ARC-II (Hu et al., 2014) was proposed by focusing on learning hierarchical matching patterns from local interactions using a CNN. To keep the ARC-II model simple, we use two layers of 2d convolution and max-pooling each and two-layer feed forward neural network to compute relevance score. DRMM (Guo et al., 2016a) aims to perform term matching over histogram-based features ignoring the actual position of matches. In DRMM, histogram-based features are computed using exact term matching and pretrained word embeddings based cosine similarities. In principal, the histogram counts the number of word pairs at different similarity levels. The counts are combined by a feed forward network to produce final ranking scores.
+
+The DUET (Mitra et al., 2017) model composed of a local and distributed model where the distributed model projects the query and the document text into an embedding space before matching, while the local model operates over an interaction matrix comparing every query term to every document term. Similarly, Match-Tensor (Jaech et al., 2017) model incorporates both immediate and larger contexts in a given document when comparing document to a query.
+
+# D QUERY SUGGESTION BASELINES
+
+Seq2seq model proposed by Bahdanau et al. (2015) is a general neural network architecture that can be applied to the task where both input and output consist of a sequence of tokens. This method have been shown successful in machine translation and sequential tagging. Because different input tokens may contribute to each output token differently, attention mechanism which learns a weight between each input-output token pair can further improve the Seq2seq model. In this paper, we consider a Seq2seq with global attention method proposed by Luong et al. (2015), which is suitable for short text such as web queries. HRED-qs suggested by Sordoni et al. (2015) is very close to our work which proposed to use a hierarhical recurrent encoder-decoder approach by considering session information for context-aware query suggestion.
+
+# E MORE EXAMPLES OF QUERY SUGGESTION BY M-NSRF
+
+<table><tr><td rowspan=1 colspan=1>Previous session queriesNext user querySuggested next query</td><td rowspan=1 colspan=1>discount pet supplies, homes for rent smyrna georgiahomes for rent atlanta georgiapet friendly rentals in georgia</td></tr><tr><td rowspan=1 colspan=1>Previous session queriesNext user querySuggested next query</td><td rowspan=1 colspan=1>language aptitude test, foreign language aptitude testamerican idolamerican language association</td></tr><tr><td rowspan=1 colspan=1>Previous session queriesNext user query Suggested next query</td><td rowspan=1 colspan=1>saturday night fever, saturday night fever nj bandnew jersey cover bandsaturday night live</td></tr><tr><td rowspan=1 colspan=1>Previous session queriesNext user querySuggested next query</td><td rowspan=1 colspan=1>pregnancy, abortion, abortion clinicstampa abortionabortionclinics in florida</td></tr><tr><td rowspan=1 colspan=1>Previous session queriesNext user querySuggested next query</td><td rowspan=1 colspan=1> ncaa basketball, ncaa basketball trees, ncaa mens basketball bracket,sportscentermens ncaa basketball oddsespn</td></tr><tr><td rowspan=1 colspan=1>Previous session queriesNext user querySuggested next query</td><td rowspan=1 colspan=1>childhood autism rating scale, childhood autism rating scale free,autism screening questionnairepervasive developmental disorderhow to do questionnaire</td></tr></table>

parse/train/SJ1nzBeA-/SJ1nzBeA-_content_list.json

@@ -0,0 +1,1798 @@
+[
+    {
+        "type": "text",
+        "text": "MULTI-TASK LEARNING FOR DOCUMENT RANKING AND QUERY SUGGESTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wasi Uddin Ahmad & Kai-Wei Chang ",
+        "bbox": [
+            186,
+            171,
+            452,
+            186
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Department of Computer Science University of California, Los Angeles {wasiahmad,kwchang}@cs.ucla.edu ",
+        "bbox": [
+            184,
+            188,
+            485,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hongning Wang Department of Computer Science University of Virginia hw5x@virginia.edu ",
+        "bbox": [
+            547,
+            172,
+            767,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            263,
+            544,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a multi-task learning framework to jointly learn document ranking and query suggestion for web search. It consists of two major components, a document ranker and a query recommender. Document ranker combines current query and session information and compares the combined representation with document representation to rank the documents. Query recommender tracks users’ query reformulation sequence considering all previous in-session queries using a sequence to sequence approach. As both tasks are driven by the users’ underlying search intent, we perform joint learning of these two components through session recurrence, which encodes search context and intent. Extensive comparisons against state-of-the-art document ranking and query suggestion algorithms are performed on the public AOL search log, and the promising results endorse the effectiveness of the joint learning framework. ",
+        "bbox": [
+            233,
+            294,
+            764,
+            455
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            479,
+            336,
+            496
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Understanding users’ information need is the key to optimize a search engine for providing relevant search results. Search engine logs have been extensively used to mine users’ search intent, reflected in their search result click preferences and query reformulations (Baeza-Yates et al., 2004; Croft et al., 2010). Typically, user query logs are partitioned into search sessions, i.e., sequences of queries and clicks issued by the same user and within a short time interval. Search sessions provide useful contextual information about user intent and help to narrow down ambiguity while ranking documents for the current query and predicting next query that users will submit, a.k.a. contextawareness (Jiang et al., 2014). Since both a user’s click behavior and query reformulation are driven by the underlying search intent, we argue that jointly modeling both tasks can benefit each other. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            632
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose a joint learning framework, called multi-task neural session relevance framework (M-NSRF), to predict users’ result clicks and future queries in search sessions. We model search context within a session via a recurrent latent state in a deep neural network (Collobert & Weston, 2008; Liu et al., 2015), which governs the generation of result clicks in the current query and formation of next query. By sharing the latent states across the tasks of document ranking and query suggestion, we learn the representations of queries, documents and user intent carrying over the whole session jointly, i.e., multi-task learning. This multi-task learning framework is flexible and can be incorporated with existing approaches for representing query and documents. ",
+        "bbox": [
+            173,
+            638,
+            823,
+            747
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The general workflow of M-NSRF is illustrated in Figure 1. Given a sequence of queries from the same search session, e.g., “cheap furniture” and “craig list virginia”, M-NSRF is trained to predict both the result clicks under the current query and the next query “cheap furniture for sale.” It is evident that in this search session the user kept reformulating the queries because his/her information need has not been met by the result clicks in the previously submitted queries, reflected in the added and removed query terms. And such revisions suggest what he/she might want to click next. As a result, the modeling of result clicks and query reformulations mutually reinforce each other to reveal users’ underlying search intent. In M-NSRF, we model user search intent as a session-level recurrent state, the learning of which is aided by both document ranking and query prediction tasks. ",
+        "bbox": [
+            174,
+            753,
+            823,
+            876
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the effectiveness of the proposed framework using the publicly available AOL search log and compare with several well-known classical retrieval models, as well as various neural retrieval models specifically designed for ad-hoc retrieval. We also compare M-NSRF with several baseline models for the query prediction task. The empirical results show that by leveraging information in both tasks, the proposed approach outperforms existing models significantly on ad-hoc document retrieval task and exhibits competitive performance in query suggestion. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/a9ef5193be3a238f5aa45bb7d710b1d9d8cd61450f8192781d008424c2eef408.jpg",
+        "image_caption": [
+            "Figure 1: General workflow of the proposed multi-task neural session relevance framework. The framework is trained on search sessions to jointly predict next query and rank corresponding documents. The model encodes the current query in the session, “craig list virginia”, updates corresponding session-level recurrent state, maximizes the probability of the next query, “cheap furniture for sale” (i.e., the task of query suggestion), encodes the candidate documents for the following query and minimizes loss for clicked documents (i.e., the task of document ranking). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            813,
+            359
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            477,
+            825,
+            517
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To summarize, the key contributions of this work include: ",
+        "bbox": [
+            174,
+            523,
+            552,
+            539
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We propose a novel multi-task neural session relevance model that is jointly trained on document ranking and query suggestion tasks by utilizing in-session queries and clicks in a holistic way.   \n2. We provide detailed experiment analysis, and release the implementation1 and the data processing tool to facilitate future research. ",
+        "bbox": [
+            174,
+            550,
+            826,
+            611
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK AND BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            631,
+            511,
+            646
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Ad-hoc Retrieval. Traditional retrieval models such as query likelihood (Ponte & Croft, 1998) and BM25 (Robertson et al., 2009) are based on exact matching of query and document words with a variety of smoothing, weighting and normalization techniques. Recently, deep neural network based approaches demonstrate strong advance in ad-hoc retrieval. Existing neural ranking models fall into two categories: representation focused (Huang et al., 2013; Gao et al., 2014) and interaction focused (Guo et al., 2016b). The earlier focus of neural ranking models was mainly on representation based models (Hu et al., 2014; Shen et al., 2014), in which the query and documents are first embedded into continuous vectors, and the ranking is calculated based on their embeddings’ similarity. The interaction focused neural models (Hu et al., 2014; Pang et al., 2016; Guo et al., 2016a), on the other hand, learn query-document matching patterns from word-level interactions. Both the interaction and representation focused models can be combined for further improvements (Mitra et al., 2017). Similarly, Jaech et al. (2017) captures both local relevance matching and global topicality signals when computing relevance of a document to a query. Our work falls into the representation focused approach to form query and document representations and jointly models the two tasks through session representation learning. ",
+        "bbox": [
+            173,
+            662,
+            825,
+            864
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Query Suggestion. In general, query suggestion algorithms define various distance metrics between queries to find the most similar ones as suggestions for one another (Wen et al., 2001; Baeza-Yates et al., 2004). The closest work to ours is the end-to-end hierarchical recurrent encoder-decoder architecture (HRED-qs) (Sordoni et al., 2015), which ranks candidates for context-aware query suggestion. Our proposed framework differs from HRED-qs as it integrates another important type of user search behavior, i.e., result clicks, into the joint modeling, which provides additional contextual information for query suggestion. Mitra & Craswell (2015) proposed a candidate generation approach for rare prefixes using frequently observed query suffixes and suggested a neural model to generate ranking features along with n-gram features. Similarly, a large pool of previous works investigated task or context-aware approaches (Cao et al., 2008; He et al., 2009; Feild & Allan, 2013; Chen et al., 2017; Garigliotti & Balog, 2017) for query suggestion. ",
+        "bbox": [
+            176,
+            871,
+            821,
+            898
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            226
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multi-task Learning. The goal of multi-task learning is to improve generalization on the target task by leveraging the domain-specific information contained in the training signals of related tasks (Caruana, 1998). Multi-task learning in combination with deep neural networks has been successfully used in many application scenarios, including natural language processing (Collobert & Weston, 2008; Liu et al., 2016a;b; Peng & Dredze, 2017; Peng et al., 2017), speech recognition (Deng et al., 2013; Thanda & Venkatesan, 2017) and computer vision (Girshick, 2015). However, it has been less explored in the information retrieval domain. Liu et al. (2015) proposed a multi-task deep neural approach to combine query classification and document ranking, and reported improvement on both the tasks. Bai et al. (2009) used multi-task learning in learning to rank for web search. We propose to jointly learn document ranking and query suggestion via multi-task learning to better capture latent intent embedded in users’ search behaviors. ",
+        "bbox": [
+            174,
+            232,
+            825,
+            380
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 MULTI-TASK NEURAL SESSION RELEVANCE FRAMEWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            401,
+            691,
+            416
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We define a session to be a sequence of queries, $Q = \\{ Q _ { 1 } , \\ldots , Q _ { n } \\}$ , submitted by a user in a short time interval in a chronological order to satisfy a specific search intent. Every query $Q _ { i }$ in a session is associated with a set of related documents $\\boldsymbol { D } \\doteq \\{ D _ { 1 } , \\ldots , D _ { m } \\}$ which need to be ranked by its relevance to the query, and $o = \\{ o _ { 1 } , \\ldots , o _ { m } \\}$ is the set of relevance labels for each document in $D$ . In typical search engine logs, $o _ { j }$ is usually approximated via user clicks, e.g., $o _ { j } = 1$ if and only if the document $D _ { j }$ is clicked. A query $Q _ { i }$ and a document $D _ { j }$ consist of a sequence of words, i.e., $Q _ { i } = \\{ w _ { i } ^ { 1 } , . . . , \\bar { w } _ { i } ^ { q } \\}$ and ${ D } _ { j } = \\{ w _ { j } ^ { 1 } , . . . , w _ { j } ^ { d } \\}$ , where $q = | Q _ { i } |$ and $d = | D _ { j } |$ are the query and document lengths respectively. $V$ is the size of vocabulary constructed over queries and relevant documents. ",
+        "bbox": [
+            173,
+            431,
+            825,
+            556
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The document ranking refers to the task of ordering the retrieved results with respect to their relevance to the given query under the users’ search intent. Accurate modeling of relevance between a document and a query is the key in this task. In this work, we model ranking of related documents as a pointwise classification problem where the goal is to predict the relevance label between a query and a document. But our developed solution can be extended to pairwise or list-wise ranking models (Liu et al., 2009). On the other hand, query suggestion refers to the task of predicting next query $Q _ { i }$ based on previous queries $Q _ { 1 } \\ldots Q _ { i - 1 }$ by users in the same session, so as to help them explore the search space. The key challenge is to maintain the semantic consistency between the suggested queries and users’ original queries, with respect to their search intent. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            685
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Traditional IR approaches consider document ranking and query suggestion tasks separately (Huang et al., 2013; Shen et al., 2014; Sordoni et al., 2015), although both the tasks are driven by users’ underlying search intent. In contrast, M-NSRF is designed to jointly learn a document ranker and a query recommender by modeling shared search context embedding in a session. Based on the latent session state inferred from all the previous queries and clicks in the same session, the document ranker is trained to predict user clicks from the candidate documents for the current query and the query recommender is trained in a sequence to sequence fashion (Sutskever et al., 2014) to predict the user’s next query. The process is repeated sequentially for all the queries in the same session. The detailed architecture of the proposed multi-task neural session relevance framework (M-NSRF) is provided in Appendix A. In the following, we discuss each component of M-NSRF. ",
+        "bbox": [
+            174,
+            691,
+            825,
+            827
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 DOCUMENT RANKER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            843,
+            361,
+            858
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Ranking the retrieved documents for an input query requires encoding the query and documents into a shared representation space. In addition to the search intent carried by the current query, search context, which is reflected in the previously submitted queries in the same session, should also be accounted in ranking the documents. In M-NSRF, we model the latent user search intent in a sequence of queries via a series of session recurrent states. As a result, the document ranker component in M-NSRF consists of a query encoder, a document encoder, a session encoder and a ranker. The ranker sub-component combines the latent representations of query and session and match them with document representations to generate the ranking score of documents, based on which the documents are ordered. The technical details of each constituent element are given as follows. ",
+        "bbox": [
+            174,
+            869,
+            823,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            185
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Query Encoder. The query encoder encodes a query into a vector. To encode a sequence of words, various approaches have been studied. We follow (Conneau et al., 2017) to adopt a bidirectional LSTM with max pooling (BiLSTM-max), due to its superior practical performance. Considering query as a sequence of words $Q _ { i } = \\{ w _ { i } ^ { 1 } , \\ldots , w _ { i } ^ { q } \\}$ , the encoder composed of forward and backward LSTM reads the sequence in two opposite directions, ",
+        "bbox": [
+            173,
+            191,
+            825,
+            260
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/26470b682926fe6a745077ceb890ea417cee88f65476aeaf80bbd6a85130ea90.jpg",
+        "text": "$$\n\\vec { h } _ { t } = L S T M _ { t } ( \\vec { h } _ { t - 1 } , w _ { i } ^ { t } ) , \\quad \\overleftarrow { h } _ { t } = L S T M _ { t } ( \\overleftarrow { h } _ { t + 1 } , w _ { i } ^ { t } ) , \\quad h _ { t } = [ \\overrightarrow { h } _ { t } , \\overleftarrow { h } _ { t } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            262,
+            750,
+            285
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $h _ { t } \\in R ^ { 2 d }$ is the query-level recurrent state, $d$ is the dimensionality of the LSTM hidden unit initialized to a zero vector. To form a fixed-size vector representation of variable length queries, maximum value is selected over each dimension of the hidden units, ",
+        "bbox": [
+            173,
+            290,
+            823,
+            332
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7f61b84c113ba25cae9a96f16256fe82e5185e6f6d330c1c816e65722c373135.jpg",
+        "text": "$$\nQ _ { i , k } = \\operatorname* { m a x } _ { q } \\ h _ { k , q } , \\ k = 1 , \\ldots , d\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            337,
+            609,
+            353
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $Q _ { i , k }$ is the $k$ -th element of the latent vector $Q _ { i }$ . ",
+        "bbox": [
+            173,
+            357,
+            529,
+            372
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Document Encoder. The goal of the document encoder is to encode documents into continuous vectors. We use the same BiLSTM-max technique that is utilized in encoding queries as the document encoder. The only difference is in the dimensionality of the LSTM hidden units. In general, because a document (body or title) is longer than a query, we consider dense vector of a larger size as the continuous representations of the documents. ",
+        "bbox": [
+            173,
+            377,
+            825,
+            445
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Session Encoder. The session encoder generates a representation to encode the queries that the system has received so far. Unlike query and document encoders that can read the complete encoded queries and documents, the session encoder does not have information from the future queries. Therefore, we use a unidirectional LSTM (Hochreiter & Schmidhuber, 1997) for session encoding. The session encoder takes the sequence of query representations $Q _ { 1 } , . . . , Q _ { n }$ as input and computes the sequence of session-level recurrent states. ",
+        "bbox": [
+            173,
+            452,
+            825,
+            534
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf9324e651b55889e1ccc6e19f9eab110469a7c4fe5b1e8e04310570f02c961d.jpg",
+        "text": "$$\nS _ { i } = L S T M _ { i } ( S _ { i - 1 } , Q _ { i } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            537,
+            583,
+            555
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $S _ { i } \\in R ^ { d }$ is the session-level recurrent state initialized to a zero vector. As a result, each query in the session has its session-level recurrent state, summarizing the user’s information need that has been processed up to query $Q _ { i }$ . ",
+        "bbox": [
+            174,
+            560,
+            825,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Ranker. We first concatenate the current query representation $Q _ { i }$ with previous session-level recurrent state $S _ { i - 1 }$ via a non-linear transformation. This combined representation reflects the search intent reflected in the current query and the past ones in the same session. Then we compute the ranking score of document $D _ { j }$ under the query as its probability of being relevant via a sigmoid function (with binary relevance labels), ",
+        "bbox": [
+            173,
+            608,
+            825,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d40464598aa92097fc6fc83b1ab6b1b8689430ede7c22a9320e9ed842cc44704.jpg",
+        "text": "$$\nP ( D _ { j } | Q _ { i } , S _ { i - 1 } ) = \\sigma \\big ( D _ { j } ^ { T } \\operatorname { t a n h } ( W _ { r } [ Q _ { i } , S _ { i - 1 } ] + b _ { r } ) \\big ) , \\ j = 1 , \\dots , m\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            680,
+            725,
+            702
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { r } \\in \\textit { R } ^ { ( d _ { q } + d _ { s } ) \\times d _ { d } }$ , $b _ { r } ~ \\in ~ R ^ { d _ { d } }$ , and $d _ { q } , \\ d _ { s }$ and $d _ { d }$ are the dimensionality of the query encoder, session encoder and document encoder hidden units and $\\sigma$ is the sigmoid function. A list of retrieved documents can therefore be ordered by this ranking score. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            750
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 QUERY RECOMMENDER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            765,
+            382,
+            779
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Query recommender suggests related queries to users by inferring the underlying search intent through utilizing in-session previous queries embedded in latent vectors. Following Sutskever et al. (2014) and Bahdanau et al. (2015), the query recommender in M-NSRF predicts users’ next query in a sequence to sequence manner. Basically the query recommender module estimates the probability of the next query $\\mathbf { \\ddot { \\cal Q } } _ { i } = \\{ w _ { i } ^ { 1 } , \\dots , w _ { i } ^ { q } \\}$ , given all the previous queries up to position $i - 1$ in a session as follows, ",
+        "bbox": [
+            173,
+            790,
+            825,
+            871
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6e1caee19e3eaa4260ee6c78e386166dcf7cfec1547331ecc9ff46e17258653d.jpg",
+        "text": "$$\nP ( Q _ { i } | Q _ { 1 : i - 1 } ) = \\prod _ { t = 1 } ^ { q } P ( w _ { i } ^ { t } | w _ { i } ^ { 1 : t - 1 } , Q _ { 1 : i - 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            868,
+            653,
+            895
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use LSTM as a basic building block for the query recommender. Information about all the previous queries represented through a session vector $S _ { i }$ is passed to the query recommender. To this end, the recurrent state of the query recommender is initialized with a non-linear transformation of $S _ { i }$ , $h _ { 0 } = \\operatorname { t a n h } ( W _ { q } S _ { i } + b _ { q } )$ , where $h _ { 0 } ~ \\in ~ R ^ { d }$ is the initial recurrent state. Then the query recommender’s recurrence is computed by $h _ { t } = L S T M _ { t } ( h _ { t - 1 } , w _ { i } ^ { t } )$ , where $h _ { t - 1 }$ is the previous hidden state, $w _ { i } ^ { t - 1 }$ is the previous query term. Finally, each recurrent state is mapped to a probability distribution over the vocabulary of size $V$ using a combination of linear transformation and the softmax function. Word with the highest probability is chosen as the next word in sequence. ",
+        "bbox": [
+            171,
+            896,
+            826,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            189
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/775fe9062a023cbe0c4a0ca03d18e8d3e00fc4e9e558de2ea009f57c0f72b4b1.jpg",
+        "text": "$$\nP ( w | w _ { i } ^ { 1 : t - 1 } , Q _ { 1 : i - 1 } ) = g ( W _ { p } h _ { t } + b ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            193,
+            625,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $g$ is the softmax function that outputs a vector to represent the distribution of next words, where the probability assigned to the $j$ -th element is defined as $\\begin{array} { r } { g ( z ) _ { j } = \\frac { e ^ { z _ { j } } } { \\sum _ { k = 1 } ^ { K } e ^ { z _ { k } } } } \\end{array}$ e j PKk=1 ezk , j = 1, ..., K . ",
+        "bbox": [
+            176,
+            215,
+            820,
+            251
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Query Suggestion. In the decoding phase, similar to (Sordoni et al., 2015), we use greedy decoding algorithm for suggesting next query. Given a sequence of queries up to position $i - 1$ , a suggested query $Q _ { i }$ is: ",
+        "bbox": [
+            174,
+            256,
+            820,
+            296
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fa76d590bbdf330ae25a4f7da52edd005e50ba93da4a70533df70fe4fed124b5.jpg",
+        "text": "$$\nQ ^ { * } = \\arg \\operatorname* { m a x } _ { Q ^ { \\prime } \\in \\mathcal { Q } } P ( Q ^ { \\prime } | Q _ { 1 : i - 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            295,
+            616,
+            314
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { Q }$ is the space of all possible queries. To generate $Q ^ { * } = \\{ w ^ { 1 } , \\ldots , w ^ { q } \\}$ , we use a greedy approach like in (Sordoni et al., 2015) where $\\begin{array} { r } { w ^ { t } = \\arg \\operatorname* { m a x } _ { w } P ( w | w ^ { 1 : t - 1 } , Q _ { 1 : i - 1 } ) } \\end{array}$ To provide query suggestions of variable lengths, we use standard word-level decoding techniques. We iteratively consider the best prefix $w _ { 1 : t }$ up to length $t$ and extend it by sampling the most probable word given the distribution in Eq. (2). The process ends when we obtain a well-formed query containing the special end-of-query token. ",
+        "bbox": [
+            173,
+            315,
+            825,
+            398
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 LEARNING END-TO-END ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            415,
+            388,
+            429
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Within a session, M-NSRF ranks documents in a set of candidates and predicts next query given the current query sequence. Therefore, the training objective of M-NSRF consists of two terms. The first term is the binary cross entropy loss from the document ranker, ",
+        "bbox": [
+            176,
+            440,
+            823,
+            482
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0168939a27e1f541518627e022ef54614c6d810df523c5759425c987d5cae577.jpg",
+        "text": "$$\n\\mathcal { L } _ { 1 } \\equiv - \\frac { 1 } { m } \\sum _ { j } ^ { m } o _ { j } \\times \\log \\ P ( D _ { j } | Q _ { i } ) + ( 1 - o _ { j } ) \\times \\log ( 1 - P ( D _ { j } | Q _ { i } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            486,
+            735,
+            517
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $o _ { j }$ represents binary click label for $D _ { j }$ . The second term is the regularized negative loglikelihood loss from the query suggestion model, ",
+        "bbox": [
+            173,
+            520,
+            820,
+            547
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c58de7a04f2bcab7bcf4f3b948b79112c69cfa36acfb8bba6ba94aca75f6af71.jpg",
+        "text": "$$\n\\mathcal { L } _ { 2 } \\equiv - \\sum _ { t } ^ { q } \\log P ( w _ { i } ^ { t } | w _ { i } ^ { 1 : i - 1 } , Q _ { 1 : i - 1 } ) + L _ { R } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            551,
+            650,
+            578
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\mathcal { L } _ { R } \\equiv - \\lambda \\sum _ { w \\in V } P ( w | w _ { i } ^ { 1 : t - 1 } , Q _ { 1 : i - 1 } ) \\log P ( w | w _ { i } ^ { 1 : t - 1 } , Q _ { 1 : i - 1 } ) } \\end{array}$ is the regularization term to avoid the distribution of words in Eq. (2) from being highly skewed, and $\\lambda$ is a hyper-parameter to control the regularization term. The final objective is the summation of $L _ { 1 }$ and $L _ { 2 }$ over all the queries.2 ",
+        "bbox": [
+            174,
+            582,
+            825,
+            637
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that the document ranker and query recommender share the same document, query, and session encoders, and the training of M-NSRF can be done in an online manner using the following procedure. In the forward pass, M-NSRF computes the query and corresponding document encodings, updates session-level recurrent states, click probability for each candidate document and the log-likelihood of each query in the session given the previous ones. In the backward pass, the gradients are computed and the parameters are updated based on the ADAM update rule (Kingma & Ba, 2014). Details of implementation can be found in Section 4.2 ",
+        "bbox": [
+            173,
+            645,
+            825,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 GENERALIZING M-NSRF FOR NEURAL IR MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            756,
+            576,
+            770
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The proposed multi-task learning framework is general and the query encoder, document encoder, document ranker, and query recommender can be replaced by other designed architecture. In general, any neural query suggestion model working in the sequence to sequence fashion can be readily incorporated with the proposed multi-task learning framework. Similarly, most neural IR models that built on the notion of learning query and document representations in a latent space for relevance modeling can be Incorporated in our framework as well. However, due to distinctive nature of different neural IR models, careful study is required while adding context-awareness into the final architecture. ",
+        "bbox": [
+            173,
+            781,
+            825,
+            890
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we take the Match-Tensor model (Jaech et al., 2017), a recently proposed neural relevance model for document ranking as an example and extend it to a multi-task Match-Tensor (M-Match-Tensor) model by incorporating the query recommender component within our proposed multi-task learning framework. Different from NSRF, which embeds queries and documents into vectors, Match-Tensor learns a contextual representation for each word in the queries and documents. Therefore, documents and queries are represented as matrices. The document ranker in Match-Tensor then computes the relevant score based on the following formulation: ",
+        "bbox": [
+            173,
+            103,
+            825,
+            198
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2590c1e84e2d6b56d3a276690515f3f164935944c18a77c35546cf52c8350097.jpg",
+        "text": "$$\nP ( D _ { j } | Q _ { i } ) = \\sigma \\big ( W _ { r } C ( Q _ { i } , D _ { j } ) + b _ { r } \\big ) , i = 1 , \\ldots , m\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            202,
+            673,
+            220
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $C$ represents a sequence of convolutional operation (Lawrence et al., 1997) and max-pooling on the $2 d$ product of the query and document vectors. The detailed architecture of the M-MatchTensor model (M-Match-Tensor) is provided in Appendix B. To incorporate the match-tensor in our mulit-task learning framework, we can replace the document encoder, query encoder, and the document ranker in M-NSRF with the ones specified in the Match-Tensor model. However, as the computations involve in the document ranker is substantial, we do not increase the computational complexity further by adding session recurrence in the document ranking. The query decoding component in M-Match-Tensor is identical to M-NSRF. In the experiment, we will show that multitask Match-Tensor achieves better performance than Match-Tensor in document ranking task. ",
+        "bbox": [
+            174,
+            223,
+            825,
+            345
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            364,
+            326,
+            381
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATA SETS AND EVALUATION METHODOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            396,
+            539,
+            410
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We conduct our experiments on the publicly available AOL search log (Pass et al., 2006). The queries in this dataset were sampled between 1 March, 2006 and 31 May, 2006. In total there are 16,946,938 queries submitted by 657,426 unique users. We removed all non-alphanumeric characters from the queries, applied word segmentation and lowercasing. We followed (Jansen Bernard et al., 2007) to define a session by a 30-minute window of inactive time, and filtered sessions by their lengths (minimum 2, maximum 10). We only kept the most frequent $| V | = 1 0 0 k$ words and mapped all other words to an $< u n k >$ token when constructing the vocabulary. We randomly selected 1,032,459 sessions for training, 129,053 sessions for development and 91,108 sessions for testing, with no overlapping. In total, there are 2,987,486 queries for training, 287,138 for development, and 259,117 for testing. The average length of the queries and documents (only the title field) are 3.15 and 6.77 respectively. In our experiments, we set maximum allowable length of query and document to 10 and 20 respectively. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            583
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the document ranking task, we need to rank the most relevant (e.g., most clickable) document on top. We used three standard ranking metrics, mean average precision (MAP), mean reciprocal rank (MRR) and normalized discounted cumulative gain (NDCG) metric computed at positions one, three, five and ten, to measure the performance. Since AOL search log only contains clicked documents, we constructed the ranking candidates by the top ranked documents by BM25 (Robertson et al., 2009). Each query in the test set consists of 50 candidate documents including the clicked ones. However, to reduce the training time and memory use, each query in training and development set only contains 5 candidates. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            698
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the query suggestion task, we need to suggest the most semantically related query to users. As we do not have user feedback on the suggested queries, we treated the users’ next submitted query as ground-truth (Sordoni et al., 2015), and used the BLEU scores (Papineni et al., 2002) as the evaluation metric, which is a popularly used metric in machine translation and text generation tasks. In addition, following (Santos et al., 2013; Sordoni et al., 2015), we evaluated the query suggestion quality by mean reciprocal rank (MRR), i.e., to test if the algorithm can rank the users’ next query on top of its recommendation list. In this set of experiments, given a set of candidate queries, query suggestion models give a likelihood score of generating the candidates. We follow Sordoni et al. (2015) for dataset split and generate candidates using a co-occurrence based suggestion model. Like Sordoni et al. (2015), we give the anchor queries (second last query of a session) as an input to the query suggestion model and evaluates the rank of the next query among the candidates. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            853
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 BASELINES AND IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            871,
+            524,
+            885
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Document Ranking Baselines. We compared M-NSRF and M-Match Tensor with word-based baselines and neural network-based baselines. Word-based baselines include query likelihood model based on Dirichlet smoothing (QL) (Ponte & Croft, 1998) and BM25 (Robertson et al., 2009). In addition, following (Mitra et al., 2016), we investigated the ranking performance of a simple word embedding-based model using GloVe word embeddings (Pennington et al., 2014). To compare with neural models, we consider baselines broadly categorized in representation-focused, interactionfocused and a combination of both. Representation-focused neural baselines include: DSSM (Huang et al., 2013), CLSM (Shen et al., 2014), ARC-I (Hu et al., 2014) and interaction-focused baselines include: ARC-II (Hu et al., 2014) and DRMM (Guo et al., 2016a). A combination of representation and interaction focused models include: DUET (Mitra et al., 2017) and Match Tensor (Jaech et al., 2017). Details of these models are provided in Appendix C. We implemented all the baseline models in PyTorch. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/4904cdda72dfd9bc4a3369b9537f526c8d7a221b8bbceed8b72526858a827320.jpg",
+        "table_caption": [
+            "Table 1: Comparison of document ranking models over the AOL search log. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Model Type</td><td rowspan=2 colspan=1>Model Name</td><td rowspan=2 colspan=1>MAP</td><td rowspan=2 colspan=1>MRR</td><td rowspan=1 colspan=4>NDCG</td></tr><tr><td rowspan=1 colspan=1>@1</td><td rowspan=1 colspan=1>@3</td><td rowspan=1 colspan=1>@5</td><td rowspan=1 colspan=1>@10</td></tr><tr><td rowspan=2 colspan=1>TraditionalIR-models</td><td rowspan=2 colspan=1>BM25QL</td><td rowspan=2 colspan=1>0.1640.139</td><td rowspan=1 colspan=1>0.172</td><td rowspan=1 colspan=1>0.121</td><td rowspan=1 colspan=1>0.136</td><td rowspan=1 colspan=1>0.141</td><td rowspan=1 colspan=1>0.156</td></tr><tr><td rowspan=1 colspan=1>0.146</td><td rowspan=1 colspan=1>0.088</td><td rowspan=1 colspan=1>0.108</td><td rowspan=1 colspan=1>0.122</td><td rowspan=1 colspan=1>0.133</td></tr><tr><td rowspan=1 colspan=1>Embedding-based</td><td rowspan=1 colspan=1>ESM</td><td rowspan=1 colspan=1>0.214</td><td rowspan=1 colspan=1>0.179</td><td rowspan=1 colspan=1>0.118</td><td rowspan=1 colspan=1>0.127</td><td rowspan=1 colspan=1>0.139</td><td rowspan=1 colspan=1>0.158</td></tr><tr><td rowspan=2 colspan=1>RepresentationFocused</td><td rowspan=2 colspan=1>DSSMCLSMARC-I</td><td rowspan=2 colspan=1>0.2630.4650.383</td><td rowspan=2 colspan=1>0.2870.5050.413</td><td rowspan=1 colspan=1>0.152</td><td rowspan=2 colspan=1>0.2060.4410.343</td><td rowspan=2 colspan=1>0.2480.4820.404</td><td rowspan=2 colspan=1>0.3150.5230.467</td></tr><tr><td rowspan=1 colspan=1>0.3690.238</td></tr><tr><td rowspan=1 colspan=1>InteractionFocused</td><td rowspan=1 colspan=1>DRMMARC-II</td><td rowspan=1 colspan=1>0.2770.423</td><td rowspan=1 colspan=1>0.3160.455</td><td rowspan=1 colspan=1>0.2210.294</td><td rowspan=1 colspan=1>0.2420.386</td><td rowspan=1 colspan=1>0.2670.442</td><td rowspan=1 colspan=1>0.3040.501</td></tr><tr><td rowspan=1 colspan=1>Representation andInteraction Focused</td><td rowspan=1 colspan=1>DUETMatch-Tensor</td><td rowspan=1 colspan=1>0.2720.613</td><td rowspan=1 colspan=1>0.3010.621</td><td rowspan=1 colspan=1>0.1520.568</td><td rowspan=1 colspan=1>0.2120.572</td><td rowspan=1 colspan=1>0.2630.596</td><td rowspan=1 colspan=1>0.3410.618</td></tr><tr><td rowspan=1 colspan=1>Neural Session Model(this paper)</td><td rowspan=1 colspan=1>NSRF</td><td rowspan=1 colspan=1>0.553</td><td rowspan=1 colspan=1>0.568</td><td rowspan=1 colspan=1>0.481</td><td rowspan=1 colspan=1>0.526</td><td rowspan=1 colspan=1>0.555</td><td rowspan=1 colspan=1>0.574</td></tr><tr><td rowspan=1 colspan=1>Multi-task Model(this paper)</td><td rowspan=1 colspan=1>M-NSRFM-Match-Tensor</td><td rowspan=1 colspan=1>0.5810.621</td><td rowspan=1 colspan=1>0.6030.634</td><td rowspan=1 colspan=1>0.5230.572</td><td rowspan=1 colspan=1>0.5680.578</td><td rowspan=1 colspan=1>0.5830.602</td><td rowspan=1 colspan=1>0.6140.632</td></tr></table>",
+        "bbox": [
+            186,
+            127,
+            812,
+            347
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            372,
+            825,
+            507
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Query Suggestion Baselines. To evaluate the performance on query suggestion task, we consider three baseline methods including Seq2seq model proposed by Bahdanau et al. (2015), Seq2seq with global attention mechanism (Luong et al., 2015) and HRED-qs (Sordoni et al., 2015). Details of these models are provided in appendix D. We implemented all three baselines in PyTorch and optimized using negative log-likelihood loss as in Eq. (3). ",
+        "bbox": [
+            174,
+            515,
+            825,
+            583
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details of M-NSRF. The model was trained end-to-end and we used mini-batch SGD with Adam (Kingma & Ba, 2014) for optimization. with the two momentum parameters set to 0.9 and 0.999 respectively. We use 300-dimensional word vectors trained with GloVe (Pennington et al., 2014) on 840 billion of tokens to initialize the word embeddings. Out-of-vocabulary words were randomly initialized by sampling values from a zero-mean unit-variance normal distribution. All training used a mini-batch size of 32 to fit in single GPU memory. Learning rate was fixed to 0.001. We used dropout (0.20) (Srivastava et al., 2014) and early stopping with a patience of 5 epochs for regularization. We set $\\lambda = 0 . 1$ for entropy regularization in Eq. (3). M-NSRF is implemented in PyTorch and it runs on a single GPU (TITAN X) with roughly a runtime of 90 minutes per epoch. In general, M-NSRF runs up to 20 epochs and we select the model that achieves the minimum loss on the development set. ",
+        "bbox": [
+            173,
+            589,
+            825,
+            738
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 EVALUATION RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            755,
+            372,
+            770
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Document Ranking Quality. Table 1 shows the performance of NSRF, M-NSRF, M-Match-Tensor and other baseline models. NSRF significantly outperforms all the baselines except the MatchTensor model. However, the model size of NSRF is much smaller than Match-Tensor. With multitask learning, both M-NSRF and M-Match-Tensor outperform NSRF and Match-Tensor, respectively. To study the advantage of multi-task learning on our proposed approach, we trained M-NSRF only on document ranking task (noted as NSRF in Table 1) and observed significant performance drop which endorses the mutual benefit of joint learning of these two tasks via multi-task learning. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            876
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Existing neural ranking models, like DRMM and DUET architecture, achieved sub-optimal performance in our experiments. We believe because of the simple architecture of DRMM with few hundreds of parameters, the model fell behind to show competitive performance on the evaluation dataset. On the other hand, we believe that the use of smaller number of top character $n$ -graphs (in our case, 5000) by the DUET architecture limits its effectiveness in modeling representation and interaction focused features to compute matching quality between query and document. We have to note that, some negative results have been reported for document title-based ad-hoc retrieval tasks (Guo et al., 2016a); and thus in our future work, we plan to investigate M-NSRF and all baseline models’ performance with document body content considered. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/bcf39123c7a81f4cf4c435fa97d4790f6415427dd2092eff231787509eded574.jpg",
+        "table_caption": [
+            "Table 2: Examples of next query suggested by M-NSRF given all previous queries in a session. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Previous session queries Next user query Suggested next query</td><td>types of weapons of mass destruction, weapons of mass destruc- tion, nuclear weapons biological weapons destructive nuclear weapons</td></tr><tr><td>Previous session queries Next user query Suggested next query</td><td>resume template,resume template free,resume word perfect template free, wordperfect com wordperfect resume templates free free microsoft word templates</td></tr></table>",
+        "bbox": [
+            189,
+            126,
+            808,
+            239
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/3347dea2f4420a57f9038efc1d7f4e0b0958f8a26584e4d1d368cfe64c029de2.jpg",
+        "table_caption": [
+            "Table 3: Comparison of different query suggestion models. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Model Name</td><td rowspan=1 colspan=4>BLEU</td><td rowspan=2 colspan=1>MRR²</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>4</td></tr><tr><td rowspan=1 colspan=1>Seq2seq</td><td rowspan=1 colspan=1>24.5</td><td rowspan=1 colspan=1>9.7</td><td rowspan=1 colspan=1>4.5</td><td rowspan=1 colspan=1>1.9</td><td rowspan=1 colspan=1>0.229</td></tr><tr><td rowspan=1 colspan=1>Seq2seq with attention</td><td rowspan=1 colspan=1>28.1</td><td rowspan=1 colspan=1>15.7</td><td rowspan=1 colspan=1>10.4</td><td rowspan=1 colspan=1>8.5</td><td rowspan=1 colspan=1>0.252</td></tr><tr><td rowspan=1 colspan=1>HRED-qsHRED-qs w/ entropy regularizer</td><td rowspan=1 colspan=1>26.427.6</td><td rowspan=1 colspan=1>13.615.1</td><td rowspan=1 colspan=1>7.99.2</td><td rowspan=1 colspan=1>5.86.7</td><td rowspan=1 colspan=1>0.2310.233</td></tr><tr><td rowspan=2 colspan=1>M-NSRFM-NSRF w/ entropy regularizer</td><td rowspan=2 colspan=1>26.828.6</td><td rowspan=1 colspan=1>14.1</td><td rowspan=1 colspan=1>8.4</td><td rowspan=1 colspan=1>6.1</td><td rowspan=2 colspan=1>0.2350.238</td></tr><tr><td rowspan=1 colspan=1>16.7</td><td rowspan=1 colspan=1>10.2</td><td rowspan=1 colspan=1>8.3</td></tr></table>",
+        "bbox": [
+            253,
+            282,
+            740,
+            410
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            439,
+            825,
+            521
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Query Suggestion Accuracy. Examples of the predicted queries by M-NSRF given preceding queries from the same session is presented in Table 2 (more examples are provided in Appendix E). The quantitative comparison results in this task between our proposed framework and baseline models are presented in Table 3. While M-NSRF and HRED-qs consider information from all preceding queries in the same session, the other two baselines only consider the current query to predict the next one. Table 3 shows that M-NSRF outperformed seq2seq and HRED-qs baselines in all measured BLUE scores, and MRR; but the Seq2seq with attention baseline performed better than M-NSRF in terms of BLEU-3, BLEU-4 and $\\mathbf { M R R } ^ { 3 }$ . ",
+        "bbox": [
+            174,
+            527,
+            825,
+            636
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We investigated the advantage of attention mechanism in this particular task and found it performs well when there is a considerable overlap between the input and output queries. Specifically, in more than $2 5 \\%$ of the test sessions, the input queries and their next queries are exactly the same; and the attention mechanism encourages the model to repeat words from the input query. When we restrict the experiment on test sessions that have no overlap between the input and its next query, the Seq2seq with attention baseline encountered significant performance drop, while M-NSRF provided improved performance compared to all baselines (approx. $5 \\%$ , $10 \\%$ and $1 \\%$ improvement in terms of MRR over Seq2seq, Seq2seq with attention and HRED-qs model). The major reason for this improvement is that our model leverages the global session information and is therefore not restricted by the input query and is able to generate related but totally new queries (as shown in Appendix E). ",
+        "bbox": [
+            174,
+            642,
+            825,
+            777
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also observed that entropy-based regularization helped M-NSRF in predicting the next query, as shown in Table 3 that M-NSRF without regularization achieved worse performance in all measured BLUE scores. We further investigated the utility of regularization for the baselines. We found significant $( \\sim 1 . 2 \\% )$ improvement for the HRED-qs, but the performance improvement for the seq2seq and seq2seq with attention mechanism is rather marginal $( \\sim 0 . 2 \\% )$ . However, the regularization technique does not introduce any significant difference to the ranking based evaluation. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            866
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/cd59b3cd3c1a6e05c31e062a13404e836176dd83ce679b5fe5a5de3993404ee0.jpg",
+        "table_caption": [
+            "Table 4: Ablation study for performance analysis of M-NSRF. Statistical significances are compared with NSRF’s full model and presented in bold-faced. $\\dagger$ indicates M-NSRF is trained to learn word embeddings, no pre-trained embeddings were used. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>NSRF Variant</td><td rowspan=1 colspan=1>MAP</td><td rowspan=1 colspan=1>NDCG@1</td><td rowspan=1 colspan=1>NDCG@3</td><td rowspan=1 colspan=1>NDCG@10</td></tr><tr><td rowspan=1 colspan=1>Full model</td><td rowspan=1 colspan=1>0.581</td><td rowspan=1 colspan=1>0.523</td><td rowspan=1 colspan=1>0.568</td><td rowspan=1 colspan=1>0.614</td></tr><tr><td rowspan=2 colspan=1>Fixed embeddingsLearned embeddingst</td><td rowspan=1 colspan=1>0.252 (-0.329)</td><td rowspan=1 colspan=1>0.182 (-0.341)</td><td rowspan=1 colspan=1>0.216(-0.352)</td><td rowspan=1 colspan=1>0.289(-0.325)</td></tr><tr><td rowspan=1 colspan=1>0.302 (-0.279)</td><td rowspan=1 colspan=1>0.222 (-0.301)</td><td rowspan=1 colspan=1>0.261(-0.307)</td><td rowspan=1 colspan=1>0.297 (-0.317)</td></tr><tr><td rowspan=1 colspan=1>Mean-poolBiLSTM-last</td><td rowspan=1 colspan=1>0.576(-0.005)0.563 (-0.018)</td><td rowspan=1 colspan=1>0.515 (-0.008)0.505 (-0.018)</td><td rowspan=1 colspan=1>0.561(-0.007)0.541(-0.027)</td><td rowspan=1 colspan=1>0.608(-0.006)0.594(-0.020)</td></tr><tr><td rowspan=1 colspan=1>M-NRF</td><td rowspan=1 colspan=1>0.553 (-0.028)</td><td rowspan=1 colspan=1>0.494 (-0.029)</td><td rowspan=1 colspan=1>0.544 (-0.024)</td><td rowspan=1 colspan=1>0.582 (-0.032)</td></tr><tr><td rowspan=1 colspan=1>GloVe 6B 50dGloVe 6B 100dGloVe 6B 200d</td><td rowspan=1 colspan=1>0.247 (-0.324)0.312 (-0.269)0.378 (-0.203)</td><td rowspan=1 colspan=1>0.196(-0.329)0.241 (-0.282)0.356(-0.167)</td><td rowspan=1 colspan=1>0.232 (-0.336)0.273 (-0.295)0.447 (-0.121)</td><td rowspan=1 colspan=1>0.296(-0.348)0.306(-0.308)0.498 (-0.116)</td></tr><tr><td rowspan=2 colspan=1>Q128D256S512Q512D1024S2048</td><td rowspan=2 colspan=1>0.562 (-0.019)0.586 (+0.005)</td><td rowspan=1 colspan=1>0.507 (-0.016)</td><td rowspan=1 colspan=1>0.544 (-0.024)</td><td rowspan=1 colspan=1>0.582 (-0.032)</td></tr><tr><td rowspan=1 colspan=1>0.528 (+0.005)</td><td rowspan=1 colspan=1>0.571 (+0.003)</td><td rowspan=1 colspan=1>0.617 (+0.003)</td></tr></table>",
+        "bbox": [
+            173,
+            154,
+            825,
+            340
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Comparing to HRED-qs, we conclude multi-task learning also helps M-NSRF achieve improved performance in query suggestion task, as the baseline employs a very similar model as ours for query suggestion. The comparison with Seq2seq with attention suggests adding attention over session information is a promising direction to further improve query suggestions quality as it emphasizes the information carried by the immediately previous query. We will pursue this in our future work. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            438
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 ABLATION STUDY ON M-NSRF ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            457,
+            434,
+            470
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We conducted experiments to better understand the effectiveness of different components in the MNSRF. We also analyzed the impact of word embeddings and hidden units dimension in M-NSRF’s performance. Our findings are presented in Table 4. ",
+        "bbox": [
+            176,
+            484,
+            825,
+            525
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Impact of Different Model Components. To study the effect of different model components, we compared the full M-NSRF with several simpler versions of the model. At first, we turned off training for word embeddings and found a significant decrease in performance. In our training dataset, we have roughly $\\vert O O V \\vert = 2 6 k$ out-of-vocabulary words and thus, training the word embeddings turned out to be very important on this data set. Also, we investigated the role of pre-trained word embeddings (ex., GloVe embeddings) and found significant performance decrease $( 2 7 . 9 \\%$ drop in MAP) if we train M-NSRF without any pre-trained word embeddings. Hence, we can conclude that the use of pre-trained word embeddings and training them further is important to achieve better performance in M-NSRF. Second, we investigated the advantages of using max-pooling over mean-pooling and considering the last hidden recurrent state for query and document representation. We observed that max-pooling and mean-pooling provide almost the same performance while biLSTM-last approach lags slightly. To further analyze the features identified by the query and document encoders using the max-pooling technique, we followed the idea of visualization proposed in (Conneau et al., 2017). We provide an example in Figure 2 where document $^ { l }$ is clicked by the user (a positive example) and document 2, 3 is retrieved by BM25 but not clicked (negative examples). We observed that the query and document encoders identified distinct features (e.g., the word priceline in the first document’s title is most important) which help differentiate between clicked and unclicked documents. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            773
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In another variant of M-NSRF, we did not use the session recurrent state when computing relevance score for the candidate documents to examine the influence of previous queries from the same session on the ranking performance. We refer to this variant of M-NSRF as multi-task neural relevance model (M-NRF). From Table 4 we can find that without session information the performance drops by $2 . 8 \\%$ in terms of MAP. We further investigated and found the session information helps particularly for longer sessions (session length $> 5$ ). In our evaluation dataset, we have roughly 5000 sessions of length greater than 5 (91 thousands in total). ",
+        "bbox": [
+            174,
+            781,
+            825,
+            876
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Impact of Dimensionality. We further study the impact of dimensionality of the word embeddings, query, document and session latent vectors. In M-NSRF, we set the dimension of query, document and session latent vectors to 256, 512 and 1024 respectively. As shown in Table 4, decreasing the dimensions of latent vectors, decreases the performance; while increasing the dimensions further, does not affect the performance significantly. We also experimented with different dimensions of pre-trained word embeddings (50d, 100d and 200d GloVe (Pennington et al., 2014) embeddings). Word embeddings of different dimensions provide different granularity of semantic similarity; with lower dimensionality, the similarity between word embeddings might be coarse and thus hard to capture matching between two text sequences. In our experiment, we found 300 dimension for embeddings works significantly better than other dimensionality on this data set. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/4792b6954c35a387bbd976dc8f77d0b640e5d417b101e7d7027427a8517f7987.jpg",
+        "image_caption": [
+            "Figure 2: Example showing query and document term importance identified by M-NSRF while ranking candidate documents for the given query. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            823,
+            199
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            262,
+            825,
+            357
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            376,
+            328,
+            392
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Existing deep neural models for ad-hoc retrieval often omit session information and are only trained on individual query-document pairs. In this work, we propose a context-aware multi-task neural session relevance framework which works in a sequence to sequence fashion, and show that sharing session-level latent recurrent states across document ranking and query suggestion tasks benefits each other. Our experiments and analysis not only demonstrate the effectiveness of the proposed framework, but also provide useful intuitions about the advantages of multi-task learning involving deep neural networks for two different information retrieval tasks. ",
+        "bbox": [
+            174,
+            407,
+            825,
+            502
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As our future work, we would like to leverage the content from document body and click sequence to update M-NSRF (especially the session-level recurrent states) so that we can further explore the potential of the proposed framework for ad-hoc retrieval. As attention mechanism shows promise in improving query suggestion performance, we also also explore it in our multi-task learning setting. In addition, a broad research direction is to go beyond session boundaries to model users’ long-term search goals to enhance personalized search results and query suggestions. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            590
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgement. This work was supported in part by National Science Foundation Grant IIS1760523, IIS-1553568, IIS-1618948, and the NVIDIA Hardware Grant. ",
+        "bbox": [
+            174,
+            604,
+            821,
+            632
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            651,
+            285,
+            666
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ricardo A Baeza-Yates, Carlos A Hurtado, Marcelo Mendoza, et al. Query recommendation using query logs in search engines. In EDBT workshops, volume 3268, pp. 588–596. Springer, 2004. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            699
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            173,
+            705,
+            821,
+            733
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jing Bai, Ke Zhou, Guirong Xue, Hongyuan Zha, Gordon Sun, Belle Tseng, Zhaohui Zheng, and Yi Chang. Multi-task learning for learning to rank in web search. In Proceedings of the 18th ACM International on Conference on Information and Knowledge Management, pp. 1549–1552. ACM, 2009. ",
+        "bbox": [
+            174,
+            739,
+            823,
+            777
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Huanhuan Cao, Daxin Jiang, Jian Pei, Qi He, Zhen Liao, Enhong Chen, and Hang Li. Context-aware query suggestion by mining click-through and session data. In Proceedings of the 14th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 875–883. ACM, 2008. ",
+        "bbox": [
+            174,
+            785,
+            821,
+            824
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rich Caruana. Multitask learning. In Learning to learn, pp. 95–133. Springer, 1998. ",
+        "bbox": [
+            174,
+            830,
+            673,
+            844
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wanyu Chen, Fei Cai, Honghui Chen, and Maarten de Rijke. Personalized query suggestion diversification. Proceedings of the 37th ACM SIGIR conference on Research and development in information retrieval, 2017. ",
+        "bbox": [
+            176,
+            852,
+            821,
+            877
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ronan Collobert and Jason Weston. A unified architecture for natural language processing: Deep neural networks with multitask learning. In Proceedings of the 25th international conference on Machine learning, pp. 160–167. ACM, 2008. ",
+        "bbox": [
+            173,
+            886,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexis Conneau, Douwe Kiela, Holger Schwenk, Lo¨ıc Barrault, and Antoine Bordes. Supervised learning of universal sentence representations from natural language inference data. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 670–680. Association for Computational Linguistics, 2017. ",
+        "bbox": [
+            174,
+            104,
+            826,
+            155
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "W Bruce Croft, Donald Metzler, and Trevor Strohman. Search engines: Information retrieval in practice, volume 283. Addison-Wesley Reading, 2010. ",
+        "bbox": [
+            176,
+            162,
+            821,
+            189
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Li Deng, Geoffrey Hinton, and Brian Kingsbury. New types of deep neural network learning for speech recognition and related applications: An overview. In Acoustics, Speech and Signal Processing (ICASSP), 2013 IEEE International Conference on, pp. 8599–8603. IEEE, 2013. ",
+        "bbox": [
+            173,
+            196,
+            823,
+            234
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Henry Feild and James Allan. Task-aware query recommendation. In Proceedings of the 36th ACM SIGIR conference on Research and development in information retrieval, pp. 83–92. ACM, 2013. ",
+        "bbox": [
+            173,
+            242,
+            823,
+            270
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jianfeng Gao, Li Deng, Michael Gamon, Xiaodong He, and Patrick Pantel. Modeling interestingness with deep neural networks, June 13 2014. US Patent App. 14/304,863. ",
+        "bbox": [
+            173,
+            276,
+            823,
+            304
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dario Garigliotti and Krisztian Balog. Generating query suggestions to support task-based search. In Proceedings of the 40th ACM SIGIR conference on Research and development in information retrieval, pp. 1153–1156. ACM, 2017. ",
+        "bbox": [
+            173,
+            310,
+            823,
+            349
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ross Girshick. Fast r-cnn. In Proceedings of the IEEE international conference on computer vision, pp. 1440– 1448, 2015. ",
+        "bbox": [
+            173,
+            357,
+            823,
+            383
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiafeng Guo, Yixing Fan, Qingyao Ai, and W Bruce Croft. A deep relevance matching model for ad-hoc retrieval. In Proceedings of the 25th ACM International on Conference on Information and Knowledge Management, pp. 55–64. ACM, 2016a. ",
+        "bbox": [
+            174,
+            391,
+            821,
+            430
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiafeng Guo, Yixing Fan, Qingyao Ai, and W Bruce Croft. Semantic matching by non-linear word transportation for information retrieval. In Proceedings of the 25th ACM International on Conference on Information and Knowledge Management, pp. 701–710. ACM, 2016b. ",
+        "bbox": [
+            173,
+            438,
+            823,
+            477
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Qi He, Daxin Jiang, Zhen Liao, Steven CH Hoi, Kuiyu Chang, Ee-Peng Lim, and Hang Li. Web query recommendation via sequential query prediction. In Data Engineering, 2009. ICDE’09. IEEE 25th International Conference on, pp. 1443–1454. IEEE, 2009. ",
+        "bbox": [
+            176,
+            483,
+            823,
+            522
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8):1735–1780, 1997. ",
+        "bbox": [
+            173,
+            530,
+            821,
+            556
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Baotian Hu, Zhengdong Lu, Hang Li, and Qingcai Chen. Convolutional neural network architectures for matching natural language sentences. In Advances in neural information processing systems, pp. 2042– 2050, 2014. ",
+        "bbox": [
+            173,
+            564,
+            823,
+            602
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Po-Sen Huang, Xiaodong He, Jianfeng Gao, Li Deng, Alex Acero, and Larry Heck. Learning deep structured semantic models for web search using clickthrough data. Proceedings of the 22nd ACM International on Conference on Information and Knowledge Management, pp. 2333–2338, 2013. ",
+        "bbox": [
+            174,
+            609,
+            823,
+            648
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aaron Jaech, Hetunandan Kamisetty, Eric Ringger, and Charlie Clarke. Match-tensor: a deep relevance model for search. arXiv preprint arXiv:1701.07795, 2017. ",
+        "bbox": [
+            171,
+            656,
+            821,
+            683
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "J Jansen Bernard, Amanda Spink, Chris Blakely, and Sherry Koshman. Defining a session on web search engines: Research articles. Journal of the American Society for Information Science and Technology, 58(6): 862–871, 2007. ",
+        "bbox": [
+            173,
+            690,
+            823,
+            728
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jyun-Yu Jiang, Yen-Yu Ke, Pao-Yu Chien, and Pu-Jen Cheng. Learning user reformulation behavior for query auto-completion. In Proceedings of the 37th ACM SIGIR conference on Research and development in information retrieval, pp. 445–454. ACM, 2014. ",
+        "bbox": [
+            171,
+            737,
+            821,
+            776
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            171,
+            784,
+            823,
+            809
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Steve Lawrence, C Lee Giles, Ah Chung Tsoi, and Andrew D Back. Face recognition: A convolutional neuralnetwork approach. IEEE transactions on neural networks, 8(1):98–113, 1997. ",
+        "bbox": [
+            171,
+            818,
+            821,
+            843
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pengfei Liu, Xipeng Qiu, and Xuanjing Huang. Deep multi-task learning with shared memory for text classification. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pp. 118–127, 2016a. ",
+        "bbox": [
+            173,
+            852,
+            821,
+            890
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pengfei Liu, Xipeng Qiu, and Xuanjing Huang. Recurrent neural network for text classification with multi-task learning. Proceedings of the Twenty-Fifth International Joint Conference on Artificial Intelligence, 2016b. ",
+        "bbox": [
+            171,
+            898,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tie-Yan Liu et al. Learning to rank for information retrieval. Foundations and Trends $\\textsuperscript { \\textregistered }$ in Information Retrieval, 3(3):225–331, 2009. ",
+        "bbox": [
+            173,
+            104,
+            821,
+            131
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiaodong Liu, Jianfeng Gao, Xiaodong He, Li Deng, Kevin Duh, and Ye-Yi Wang. Representation learning using multi-task deep neural networks for semantic classification and information retrieval. In Proceedings of the 2015 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 912–921, 2015. ",
+        "bbox": [
+            176,
+            136,
+            820,
+            188
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Thang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches to attention-based neural machine translation. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pp. 1412–1421, 2015. ",
+        "bbox": [
+            174,
+            193,
+            820,
+            231
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bhaskar Mitra and Nick Craswell. Query auto-completion for rare prefixes. In Proceedings of the 24th ACM International on Conference on Information and Knowledge Management, pp. 1755–1758. ACM, 2015. ",
+        "bbox": [
+            174,
+            238,
+            820,
+            263
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bhaskar Mitra, Eric Nalisnick, Nick Craswell, and Rich Caruana. A dual embedding space model for document ranking. arXiv preprint arXiv:1602.01137, 2016. ",
+        "bbox": [
+            171,
+            270,
+            823,
+            296
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bhaskar Mitra, Fernando Diaz, and Nick Craswell. Learning to match using local and distributed representations of text for web search. pp. 1291–1299. International World Wide Web Conferences Steering Committee, 2017. ",
+        "bbox": [
+            174,
+            303,
+            821,
+            340
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Liang Pang, Yanyan Lan, Jiafeng Guo, Jun Xu, Shengxian Wan, and Xueqi Cheng. Text matching as image recognition. Association for the Advancement of Artificial Intelligence, pp. 2793–2799, 2016. ",
+        "bbox": [
+            173,
+            347,
+            821,
+            373
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. Bleu: a method for automatic evaluation of machine translation. In Proceedings of the 40th annual meeting on association for computational linguistics, pp. 311–318. Association for Computational Linguistics, 2002. ",
+        "bbox": [
+            178,
+            380,
+            820,
+            417
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Greg Pass, Abdur Chowdhury, and Cayley Torgeson. A picture of search. In InfoScale, volume 152, pp. 1, 2006. ",
+        "bbox": [
+            173,
+            424,
+            821,
+            450
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nanyun Peng and Mark Dredze. Multi-task domain adaptation for sequence tagging. In Proceedings of the 2nd Workshop on Representation Learning for NLP, pp. 91–100, 2017. ",
+        "bbox": [
+            171,
+            457,
+            823,
+            483
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nanyun Peng, Hoifung Poon, Chris Quirk, Kristina Toutanova, and Wen-tau Yih. Cross-sentence n-ary relation extraction with graph lstms. Transactions of the Association for Computational Linguistics, 5:101–115, 2017. ",
+        "bbox": [
+            174,
+            488,
+            823,
+            526
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Pennington, Richard Socher, and Christopher Manning. Glove: Global vectors for word representation. Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pp. 1532–1543, 2014. ",
+        "bbox": [
+            173,
+            534,
+            823,
+            571
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jay M Ponte and W Bruce Croft. A language modeling approach to information retrieval. In Proceedings of the 21st ACM SIGIR conference on Research and development in information retrieval, pp. 275–281. ACM, 1998. ",
+        "bbox": [
+            173,
+            578,
+            823,
+            616
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stephen Robertson, Hugo Zaragoza, et al. The probabilistic relevance framework: Bm25 and beyond. Foundations and Trends $\\textsuperscript { \\textregistered }$ in Information Retrieval, 3(4):333–389, 2009. ",
+        "bbox": [
+            173,
+            622,
+            820,
+            648
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rodrygo LT Santos, Craig Macdonald, and Iadh Ounis. Learning to rank query suggestions for adhoc and diversity search. Information Retrieval, 16(4):429–451, 2013. ",
+        "bbox": [
+            173,
+            655,
+            821,
+            681
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yelong Shen, Xiaodong He, Jianfeng Gao, Li Deng, and Gregoire Mesnil. A latent semantic model with´ convolutional-pooling structure for information retrieval. In Proceedings of the 23rd ACM International on Conference on Information and Knowledge Management, pp. 101–110. ACM, 2014. ",
+        "bbox": [
+            176,
+            686,
+            823,
+            726
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alessandro Sordoni, Yoshua Bengio, Hossein Vahabi, Christina Lioma, Jakob Grue Simonsen, and Jian-Yun Nie. A hierarchical recurrent encoder-decoder for generative context-aware query suggestion. Proceedings of the 24th ACM International on Conference on Information and Knowledge Management, pp. 553–562, 2015. ",
+        "bbox": [
+            178,
+            731,
+            823,
+            782
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of machine learning research, 15(1): 1929–1958, 2014. ",
+        "bbox": [
+            174,
+            787,
+            823,
+            827
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104–3112, 2014. ",
+        "bbox": [
+            171,
+            833,
+            821,
+            859
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Abhinav Thanda and Shankar M Venkatesan. Multi-task learning of deep neural networks for audio visual automatic speech recognition. arXiv preprint arXiv:1701.02477, 2017. ",
+        "bbox": [
+            174,
+            866,
+            821,
+            891
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ji-Rong Wen, Jian-Yun Nie, and Hong-Jiang Zhang. Clustering user queries of a search engine. In Proceedings of the 10th international conference on World Wide Web, pp. 162–168. acm, 2001. ",
+        "bbox": [
+            171,
+            898,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A MULTITASK NEURAL SESSION RELEVANCE FRAMEWORK ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            687,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/83c46148e4e6af4c9d203864f201eaf5920e678a89b0c13d367bcdc4a99f8beb.jpg",
+        "image_caption": [
+            "Figure 3: Architecture of the Multi-task Neural Session Relevance Framework (M-NSRF). M-NSRF uses bi-LSTM with max pooling to form query and document representations and use LSTM to gather session-level information. These recurrent states (current query representation and sessionlevel recurrent state, which summarizes all previous queries) are used by query decoder and document ranker for predicting next query and computing relevance scores. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            141,
+            821,
+            422
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B MULTITASK MATCH-TENSOR ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            534,
+            591,
+            551
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/fd777dc795cce8647616e23db141d0ddd6ab1bc7d9e4204093caf79b2101c00e.jpg",
+        "image_caption": [
+            "Figure 4: Architecture of the Multi-task Match-Tensor Model (M-Match-Tensor). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            573,
+            826,
+            768
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C DOCUMENT RANKING BASELINES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            824,
+            495,
+            840
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Deep semantic similarity model, DSSM (Huang et al., 2013) maps words to letter tri-grams using a word-hashing technique and uses a feed-forward neural network to build representations for both query and document. Similarity, convolutional latent semantic model, CLSM (Shen et al., 2014) uses word-hashing technique and uses convolutional neural networks (CNN) to build query and document representations. To compute relevance between query and document, both DSSM and ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "CLSM uses cosine similarity. ARC-I (Hu et al., 2014) uses CNN to form query and document representations and employs a multi-layer perceptron to compute relevance score. In our implementation, we used 128 convolution filters of size 1, 2 and 256 filters of size 3. ",
+        "bbox": [
+            174,
+            103,
+            821,
+            145
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "ARC-II (Hu et al., 2014) was proposed by focusing on learning hierarchical matching patterns from local interactions using a CNN. To keep the ARC-II model simple, we use two layers of 2d convolution and max-pooling each and two-layer feed forward neural network to compute relevance score. DRMM (Guo et al., 2016a) aims to perform term matching over histogram-based features ignoring the actual position of matches. In DRMM, histogram-based features are computed using exact term matching and pretrained word embeddings based cosine similarities. In principal, the histogram counts the number of word pairs at different similarity levels. The counts are combined by a feed forward network to produce final ranking scores. ",
+        "bbox": [
+            174,
+            151,
+            825,
+            260
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The DUET (Mitra et al., 2017) model composed of a local and distributed model where the distributed model projects the query and the document text into an embedding space before matching, while the local model operates over an interaction matrix comparing every query term to every document term. Similarly, Match-Tensor (Jaech et al., 2017) model incorporates both immediate and larger contexts in a given document when comparing document to a query. ",
+        "bbox": [
+            174,
+            266,
+            825,
+            334
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D QUERY SUGGESTION BASELINES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            353,
+            485,
+            371
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Seq2seq model proposed by Bahdanau et al. (2015) is a general neural network architecture that can be applied to the task where both input and output consist of a sequence of tokens. This method have been shown successful in machine translation and sequential tagging. Because different input tokens may contribute to each output token differently, attention mechanism which learns a weight between each input-output token pair can further improve the Seq2seq model. In this paper, we consider a Seq2seq with global attention method proposed by Luong et al. (2015), which is suitable for short text such as web queries. HRED-qs suggested by Sordoni et al. (2015) is very close to our work which proposed to use a hierarhical recurrent encoder-decoder approach by considering session information for context-aware query suggestion. ",
+        "bbox": [
+            173,
+            385,
+            825,
+            507
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E MORE EXAMPLES OF QUERY SUGGESTION BY M-NSRF ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            526,
+            678,
+            544
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/04a92dc6bd0f5525b0bc9006058db5b700b8651c9694a4b4176e24c00b85b098.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Previous session queriesNext user querySuggested next query</td><td rowspan=1 colspan=1>discount pet supplies, homes for rent smyrna georgiahomes for rent atlanta georgiapet friendly rentals in georgia</td></tr><tr><td rowspan=1 colspan=1>Previous session queriesNext user querySuggested next query</td><td rowspan=1 colspan=1>language aptitude test, foreign language aptitude testamerican idolamerican language association</td></tr><tr><td rowspan=1 colspan=1>Previous session queriesNext user query Suggested next query</td><td rowspan=1 colspan=1>saturday night fever, saturday night fever nj bandnew jersey cover bandsaturday night live</td></tr><tr><td rowspan=1 colspan=1>Previous session queriesNext user querySuggested next query</td><td rowspan=1 colspan=1>pregnancy, abortion, abortion clinicstampa abortionabortionclinics in florida</td></tr><tr><td rowspan=1 colspan=1>Previous session queriesNext user querySuggested next query</td><td rowspan=1 colspan=1> ncaa basketball, ncaa basketball trees, ncaa mens basketball bracket,sportscentermens ncaa basketball oddsespn</td></tr><tr><td rowspan=1 colspan=1>Previous session queriesNext user querySuggested next query</td><td rowspan=1 colspan=1>childhood autism rating scale, childhood autism rating scale free,autism screening questionnairepervasive developmental disorderhow to do questionnaire</td></tr></table>",
+        "bbox": [
+            176,
+            564,
+            820,
+            835
+        ],
+        "page_idx": 13
+    }
+]

parse/train/r1l1myStwr/r1l1myStwr.md

@@ -0,0 +1,528 @@
+# CONTINUOUS META-LEARNING WITHOUT TASKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Meta-learning is a promising strategy for learning to efficiently learn within new tasks, using data gathered from a distribution of tasks. However, the meta-learning literature thus far has focused on the task segmented setting, where at train-time, offline data is assumed to be split according to the underlying task, and at test-time, the algorithms are optimized to learn in a single task. In this work, we enable the application of generic meta-learning algorithms to settings where this task segmentation is unavailable, such as continual online learning with a time-varying task. We present meta-learning via online changepoint analysis (MOCA), an approach which augments a meta-learning algorithm with a differentiable Bayesian changepoint detection scheme. The framework allows both training and testing directly on time series data without segmenting it into discrete tasks. We demonstrate the utility of this approach on a nonlinear meta-regression benchmark as well as two meta-image-classification benchmarks.
+
+# 1 INTRODUCTION
+
+Meta-learning methods have recently shown promise as an effective strategy for enabling efficient few-shot learning in complex domains from image classification to nonlinear regression (Finn et al., 2017; Snell et al., 2017). These methods leverage an offline meta-training phase, in which they use data from a distribution of tasks to optimize learning performance on new tasks. These algorithms have focused on settings with task segmentation, where the learning agent knows when tasks change. At meta-train time, these algorithms assume access to a meta-dataset of datasets from individual tasks, and at meta-test time, the learner is evaluated on a single task. However, there are many applications where task segmentation is unavailable, which have thus far been under-addressed in the meta-learning literature. For example, consider a robot which must learn to adapt to a changing environment. The robot may switch from one environment to another during the course of deployment, and these task switches may not be directly observed. Furthermore, using an existing time series from interaction to craft a meta-dataset may require a difficult or expensive process of detecting switches in task.
+
+In this work, we aim to enable meta-learning in task-unsegmented settings, operating directly on time series in which the latent task undergoes discrete, unobserved switches, rather than requiring a pre-segmented meta-dataset. Equivalently, this problem can be viewed from the perspective of continual learning, in that we apply the meta-learning approach to the standard online learning problem statement wherein an agent must sequentially make predictions and learn with a potentially varying latent data generating process. To accomplish this, we integrate a Bayesian changepoint estimation scheme with existing meta-learning approaches, allowing the algorithm to reason about whether or not the task has changed in a time series. Thus, we enable a standard meta-learning algorithm, which is designed for the task segmented setting, to be both trained and tested directly on time series data without the need for task segmentation.
+
+Contributions. The primary contribution of this work is an algorithmic framework for task unsegmented meta-learning which we refer to as meta-learning via online changepoint analysis (MOCA). MOCA wraps arbitrary meta-learning algorithms in a differentiable changepoint estimation algorithm, enabling application of meta-learning algorithms directly to problems in the continuous learning setting. By backpropagating through the changepoint estimation framework, MOCA learns both a rapidly adaptive underlying predictive model (in the form of the meta-learning model), as well as an effective changepoint detection algorithm. MOCA is a generic framework which can be paired with many existing meta-learning algorithms. We demonstrate the performance of MOCA on both regression and classification settings with unobserved task switches.
+
+# 2 PROBLEM STATEMENT
+
+Our goal is to apply meta-learning tools to the problem of task-unsegmented continual learning, in which an agent is presented sequentially with input $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$ , asked to make a (probabilistic) prediction $p ( \hat { y } _ { t } \mid x _ { t } )$ , and is then given the true label ${ \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \Xi } _ { \mathbf { } } \mathbf { \Lambda } _ { \mathbf { } } \mathbf { \Lambda } _ { \mathbf { } } \textbf { } _ { \mathbf { } } \textbf { } \textbf { } _ { \mathrm { } }$ , and can thus ideally improve its predictions by learning from the labeled examples. Following the terminology of meta-learning, we assume that these data are drawn from a distribution according to some latent task $\mathcal { T } _ { t }$ , $p ( \pmb { x } _ { t } , \mathbf { \bar { y } } _ { t } \mid \mathcal { T } _ { t } ) = p ( \pmb { x } _ { t } \mid$ $\mathcal { T } _ { t } ) p ( \pmb { y } _ { t } \mid \pmb { x } _ { t } , \mathcal { T } _ { t } )$ . We will write $x , y \sim \ T _ { t }$ as shorthand for $\boldsymbol { x } , \boldsymbol { y } \sim p ( \boldsymbol { x } , \boldsymbol { y } \mid \mathcal { T } _ { t } )$ . We assume a distribution over tasks, which we write $p ( \mathcal { T } )$ , and that the initial task $\mathcal { T } _ { 1 } \sim p ( \mathcal { T } )$ . At each timestep, the task is re-sampled from $p ( \tau )$ with some probability $\lambda$ (which we refer to as the hazard rate), or remains the same.
+
+Our goal is to optimize a learning agent to perform well in this setting. Let $p _ { \pmb { \theta } } ( \hat { \pmb { y } } _ { t } \mid \pmb { x } _ { 1 : t } , \pmb { y } _ { 1 : t - 1 } )$ by the agent’s prediction for ${ \mathbf { } } _ { \pmb { y } _ { t } }$ given input $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$ and the past labeled examples. We will evaluate the learner’s performance through a negative log likelihood loss, and our objective is as follows:
+
+$$
+\begin{array} { r l } { \underset { \theta } { \mathrm { m i n } } } & { \mathbb { E } \left[ \displaystyle \sum _ { t = 1 } ^ { \infty } - \log p _ { \theta } ( y _ { t } \mid x _ { 1 : t } , y _ { 1 : t - 1 } ) \right] } \\ { \mathrm { s u b j e c t ~ t o } } & { x _ { t } , y _ { t } \sim \mathcal { T } _ { t } , \quad \mathcal { T } _ { t } = \left\{ \mathcal { T } _ { t , \mathrm { n e w } } \right. \mathrm { ~ w . p . ~ } 1 - \lambda } \\ & { \mathcal { T } _ { 1 } \sim p ( \mathcal { T } ) , \quad \mathcal { T } _ { t , \mathrm { n e w } } \sim p ( \mathcal { T } ) } \end{array}
+$$
+
+We assume that we have access to a representative time series generated in the same manner from the same distribution of tasks, and use this time series to optimize $\pmb \theta$ in an offline, meta-training phase. Critically, however, in stark contrast to standard meta-learning approaches, we do not assume access to task segmentation, i.e. that this offline data is pre-grouped by latent parameter $\tau$ . Moreover, we highlight that we consider the case of individual data points provided sequentially, in contrast to the common $^ { 6 6 } k$ -shot, $n$ -way” problem setting prevalent in few-shot learning (especially classification). Our setting may easily be extended to the setting in which multiple data points are observed simultaneously.
+
+# 3 PRELIMINARIES
+
+# 3.1 META-LEARNING
+
+We begin by presenting a unified perspective on meta-learning in the task-segmented setting, which allows straightforward presentation of the algorithms used in this work as well as generalization to the task-unsegmented case. The core idea of meta-learning is to directly optimize the few-shot learning performance of a machine learning model over a distribution of learning tasks, rather than just a single task, with the goal of this learning performance generalizing to other tasks from this distribution.
+
+A meta-learning method consists of two phases: meta-training and online adaptation. Let $\pmb { \theta }$ be the parameters of this model learned via meta-training. During online adaptation, the model uses context data $\mathcal { D } _ { t } = ( \boldsymbol { \mathbf { \mathit { x } } } _ { 1 : t } , \boldsymbol { \mathbf { \mathit { y } } } _ { 1 : t } )$ from within one task to compute statistics
+
+$$
+\eta _ { t } = f _ { \theta } ( \mathcal { D } _ { t } )
+$$
+
+where $f$ is a function parameterized by $\pmb { \theta }$ . For example, in MAML (Finn et al., 2017), the statistics are the neural network weights after gradient updates computed using $\mathcal { D } _ { t }$ . In neural processes (Garnelo et al., 2018), the statistics are the aggregated context parameters computed via encoding and aggregating the context data. For recurrent network-based meta-learning algorithms, these statistics correspond to the hidden state of the network. For a simple nearest-neighbors model, $\eta$ may simply be the context data. The model then performs predictions by using these statistics to define a conditional distribution on $\textbf {  { y } }$ given new inputs $_ { \textbf { \em x } }$ ,
+
+$$
+\textbf { \textit { y } } | \textbf { \textit { x } } , \mathcal { D } _ { t } \sim p _ { \boldsymbol { \theta } } ( \textbf { \textit { y } } | \textbf { \textit { x } } , \eta _ { t } ) .
+$$
+
+Adopting a Bayesian perspective, we refer to $p _ { \pmb { \theta } } ( \pmb { y } \mid \pmb { x } , \pmb { \eta } _ { t } )$ as the posterior predictive distribution.
+
+The performance of this model on this task can be evaluated by considering how well this posterior predictive distribution matches the true task data distribution,
+
+$$
+\mathcal { L } ( \mathcal { D } _ { t } , \pmb { \theta } ) = D ( p ( \pmb { y } \mid \pmb { x } , \mathcal { T } _ { i } ) | | p _ { \pmb { \theta } } ( \pmb { y } \mid \pmb { x } , f _ { \pmb { \theta } } ( \mathcal { D } _ { t } ) ) )
+$$
+
+where $D$ is a measure of the dissimilarity of the two distributions, e.g. the KL divergence, for which this objective becomes standard negative log likelihood minimization.
+
+Meta-learning optimizes the parameters $\pmb \theta$ such that the model performs well across a distribution of tasks,
+
+$$
+\operatorname* { m i n } _ { \pmb { \theta } } \ \mathbb { E } _ { \mathcal { T } _ { i } \sim p ( \mathcal { T } ) } \left[ \mathbb { E } _ { \mathcal { D } _ { t } \sim \mathcal { T } _ { i } } \left[ \mathcal { L } ( \mathcal { D } _ { t } , \pmb { \theta } ) \right] \right] .
+$$
+
+Across most meta-learning algorithms, including all of those referenced above, both the update rule and the prediction function are chosen to be differentiable operations, such that the parameters can be optimized via stochastic gradient descent. Given a dataset pre-segmented into groups of data from individual tasks, standard meta-learning algorithms operate via first sampling a group for which $\tau$ is fixed, treating part of that group as the context data $\mathcal { D } _ { t } ^ { \mathrm { ~ \scriptsize ~ 1 ~ } }$ and sampling from the remainder to obtain test points $( { \pmb x } , { \pmb y } ) $ from the same task. While this strategy can be very effective and produce expressive models that are capable of few-shot learning in complex domains, it relies on task segmentation which in many settings, especially continual learning, is not easily available.
+
+# 3.2 BAYESIAN ONLINE CHANGEPOINT DETECTION
+
+To enable meta-learning without task segmentation, we extend prior work in changepoint detection. Specifically, we build on Bayesian online changepoint detection (Adams & MacKay, 2007), an approach for detecting changepoints (i.e. task switches) originally presented in a streaming unconditional density estimation context, which we review here.
+
+BOCPD operates by maintaining a belief distribution over run lengths, i.e. how many of the past data points ${ \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \Xi } _ { \mathbf { } } \mathbf { \Lambda } _ { \mathbf { } } \mathbf { \Lambda } _ { \mathbf { } } \textbf { } _ { \mathbf { } } \textbf { } \textbf { } _ { \mathrm { } }$ correspond to the current task. At time $t$ , run length of $r _ { t } = \tau$ indicates that the task has switched $\tau$ timesteps ago, i.e. $\mathcal { D } _ { - \tau } = \pmb { y } _ { t - \tau : t }$ are all drawn from a shared task $\tau$ . A belief that $r _ { t } = 0$ implies that there has been a task switch, and that the current datapoint ${ \mathbf { } } _ { \mathbf { } } \mathbf { \psi } _ { \mathbf { } } \mathbf { _ { } } \mathbf { \psi } _ { \mathbf { } } \mathbf { _ { } } \mathbf { \psi } _ { \mathbf { } } \mathbf { _ { } } \mathbf { \psi } _ { \mathbf { } } \mathbf { _ { } } \mathbf { \psi } _ { \mathbf { } } \mathbf { _ { } } \mathbf { \psi } _ { \mathbf { } } \mathbf { _ { } } \mathbf { \psi } _ { \mathbf { } \psi } \mathbf { _ { } } \textbf { } \psi _ { } \psi _ { } \left. \textbf { } \psi _ { } \mathbf { } \psi _ { } \textbf { } \right.$ was drawn from a new task $\bar { \mathcal { T } } ^ { \prime } \sim p ( \mathcal { T } )$ . We denote this belief distribution at time $t$ as $b _ { t } ( r _ { t } ) \bar { ( r _ { t } ) } = p ( r _ { t } \mid \pmb { y } _ { 1 : t - 1 } )$ .
+
+Given $r _ { t }$ , we know the past $r _ { t }$ data points all correspond to the same task, and thus the density $p ( \pmb { y } _ { t } \ | \ \pmb { y } _ { 1 : t - 1 } , r _ { t } )$ corresponds to the posterior predictive density after conditioning on the past $r _ { t }$ data points. We can reason about the overall posterior predictive by marginalizing over the run length $r _ { t }$ according to $b _ { t } ( \boldsymbol { r } _ { t } )$ ,
+
+$$
+p ( { \pmb y } _ { t } \mid { \pmb y } _ { 1 : t - 1 } ) = \sum _ { r _ { t } = 0 } ^ { t - 1 } p ( { \pmb y } _ { t } \mid { \pmb y } _ { 1 : t - 1 } , r _ { t } ) b _ { t } ( r _ { t } ) ,
+$$
+
+where $p ( \mathbf { \mathscr { y } } _ { t } \mid \mathbf { \mathscr { y } } _ { 1 : t - 1 } , r _ { t } )$ is referred to as the underlying predictive model (UPM). BOCPD recursively computes posterior predictive densities for each value of $r _ { t } \in \{ 0 , \ldots , t - 1 \}$ , and then evaluates new datapoints $\mathbf { \pmb { y } } _ { t + 1 }$ under these posterior predictive densities to update the belief distribution $b ( r _ { t } )$ . In this work, we extend this approach of Adams & MacKay (2007) beyond Bayesian unconditional density estimation to apply to general meta-learning models operating in the conditional density estimation setting, and derive these update rules in more detail for our context.
+
+# 4 META-LEARNING VIA ONLINE CHANGEPOINT ANALYSIS
+
+MOCA uses Bayesian changepoint detection to enable the application of meta-learning algorithms to settings without task segmentation, both at train and test time. Specifically, we extend BOCPD to derive a recursive Bayesian filtering algorithm for run length in the conditional and joint density estimation setting, and leverage a base meta-learning algorithm with parameters $\pmb \theta$ to provide an underlying predictive model when conditioned on a run length. In the following subsections, we first derive MOCA’s Bayesian filtering updates, and then outline how the full framework can be used to both train and evaluate meta-learning models on time series without task segmentation.
+
+# 4.1 BAYESIAN RUN-LENGTH FILTERING
+
+As in BOCPD, MOCA maintains a belief over possible run lengths $r _ { t }$ . Throughout this paper, we use $b _ { t }$ to refer to the updated belief before observing data at that timestep, $( \pmb { x } _ { t } , \bar { \pmb { y } } _ { t } )$ . Note that $b _ { t }$ is a discrete distribution with support over $r _ { t } \in \{ 0 , . . . , \bar { t } - 1 \}$ .
+
+At time $t$ , the agent first observes the input $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$ , then makes a prediction $p ( { \pmb y } _ { t } \mid { \pmb x } _ { 1 : t } , { \pmb y } _ { 1 : t - 1 } )$ , and subsequently observes ${ \mathbf { } } _ { \pmb { y } _ { t } }$ . Generally, the latent task can influence both the marginal distribution of the input, $p \big ( { \pmb x } _ { t } \ | \ x _ { 1 : t - 1 } , { \pmb y } _ { 1 : t - 1 } \big )$ as well as the conditional distribution $p ( { \pmb y } _ { t } \mid { \bar { \pmb x } } _ { 1 : t } , { \pmb y } _ { 1 : t - 1 } )$ . Thus, the agent can update its belief over run lengths once after observing the input $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$ , and again after observing the label ${ \mathbf { } } _ { \pmb { y } _ { t } }$ . We will use $b _ { t } ( r _ { t } \mid \bar { \mathbf { x } _ { t } } ) = p ( r _ { t } \mid \mathbf { x } _ { 1 : t } , \pmb { y } _ { 1 : t - 1 } )$ to represent the updated belief over run length after observing only $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$ , and $b _ { t } ( r _ { t } \mid \pmb { x } _ { t } , \pmb { y } _ { t } ) = p ( r _ { t } \mid \pmb { x } _ { 1 : t } , \pmb { y } _ { 1 : t } )$ to represent the fully updated belief over $r _ { t }$ after observing $\mathbf { \mathscr { y } } _ { t }$ . Finally, we will propagate this forward in time according to our assumptions on task dynamics to compute $\bar { b } _ { t + 1 } ( r _ { t + 1 } )$ , which is used in the subsequent timestep.
+
+To derive the Bayesian update rules, we start by noting that the updated posterior is proportional to the joint density,
+
+$$
+\begin{array} { r l } & { b _ { t } ( r _ { t } \mid \pmb { x _ { t } } ) = p ( r _ { t } \mid \pmb { x _ { 1 : t } } , \pmb { y _ { 1 : t - 1 } } ) = Z ^ { - 1 } p ( r _ { t } , \pmb { x _ { t } } \mid \pmb { x _ { 1 : t - 1 } } , \pmb { y _ { 1 : t - 1 } } ) } \\ & { \qquad = Z ^ { - 1 } p ( \pmb { x _ { t } } \mid \pmb { x _ { 1 : t - 1 } } , \pmb { y _ { 1 : t - 1 } } , r _ { t } ) p ( r _ { t } \mid \pmb { x _ { 1 : t - 1 } } , \pmb { y _ { 1 : t - 1 } } ) } \\ & { \qquad = Z ^ { - 1 } p _ { \theta } ( \pmb { x _ { t } } \mid \pmb { \eta _ { t - 1 } } [ r _ { t } ] ) b _ { t } ( r _ { t } ) } \end{array}
+$$
+
+where the normalization constant $Z$ can be computed by summing over the finite support of $b _ { t - 1 } ( r _ { t } )$ . Importantly, this update requires $p _ { \pmb { \theta } } ( \mathbf { x } _ { t } \mid \mathbf { \eta } _ { \pmb { \eta } _ { t - 1 } } \mathbf { \bar { \phi } } _ { [ r _ { t } ] } )$ , the base meta-learning algorithm’s posterior predictive density over the inputs. Within classification, this density is available for generative models, and thus a generative approach is favorable to a discriminative approach within MOCA. In regression, it is uncommon to estimate the distribution of the independent variable. We take the same approach in this work and assume that $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$ is independent of the task for regression problems, in which case $b _ { t } ( r _ { t } \mid \mathbf { x } _ { t } ) = b _ { t } ( r _ { t } )$ .
+
+Next, upon observing ${ \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \Xi } _ { \mathbf { } } \mathbf { \Lambda } _ { \mathbf { } } \mathbf { \Lambda } _ { \mathbf { } } \textbf { } _ { \mathbf { } } \textbf { } \textbf { } _ { \mathrm { } }$ , we can similarly factor the belief over run lengths for the next timestep,
+
+$$
+b _ { t } ( r _ { t } \mid \mathbf { x } _ { t } , \pmb { y } _ { t } ) = Z ^ { - 1 } p _ { \theta } ( \pmb { y } _ { t } \mid \mathbf { x } _ { t } , \pmb { \eta } _ { t - 1 } [ r _ { t } ] ) b _ { t } ( r _ { t } \mid \pmb { x } _ { t } ) .
+$$
+
+Again, the normalization constant can be computed via a sum over the support of
+
+Finally, we must propagate this belief forward in time to obtain $b _ { t + 1 } ( r _ { t + 1 } )$ :
+
+$$
+\begin{array} { l } { { b _ { t + 1 } ( r _ { t + 1 } ) = p ( r _ { t + 1 } \mid x _ { 1 : t } , y _ { 1 : t } ) = \displaystyle \sum _ { r _ { t } } p ( r _ { t + 1 } , r _ { t } \mid x _ { 1 : t } , y _ { 1 : t } ) } } \\ { { \ = \displaystyle \sum _ { r _ { t } } p ( r _ { t + 1 } \mid r _ { t } , x _ { 1 : t } , y _ { 1 : t } ) p ( r _ { t } \mid x _ { 1 : t } , y _ { 1 : t } ) = \displaystyle \sum _ { r _ { t } } p ( r _ { t + 1 } \mid r _ { t } ) b _ { t } ( r _ { t } \mid x _ { t } , y _ { t } ) . } } \end{array}
+$$
+
+where we have exploited the assumption that the changes in task, and hence the evolution of run length $r _ { t }$ , happen independently of the data generation process. The conditional run-length distribution $p ( r _ { t + 1 } \mid r _ { t } )$ is defined by our model of task evolution.
+
+Recall that we assume that the task switches with fixed probability $\lambda$ , the hazard rate. Thus, for all $r _ { t } , p ( r _ { t + 1 } = 0 \mid r _ { t } ) = \lambda$ , implying
+
+$$
+b _ { t + 1 } ( r _ { t + 1 } = 0 ) = \sum _ { r _ { t } } \lambda b _ { t } ( r _ { t } \mid { x } _ { t } , y _ { t } ) = \lambda .
+$$
+
+Conditioned on the task remaining the same, $r _ { t + 1 } = k > 0$ and $r _ { t } = k - 1$ . Thus, $p ( r _ { t + 1 } = k \ |$ $r _ { t } ) = ( 1 - \lambda ) \mathbb { 1 } \{ r _ { t } = k - 1 \}$ implying
+
+$$
+b _ { t + 1 } ( r _ { t + 1 } = k ) = ( 1 - \lambda ) b _ { t } ( r _ { t } = k - 1 \mid x _ { t } , y _ { t } ) .
+$$
+
+Equations (5) and (6) together define $b _ { t + 1 }$ over its support $r _ { t + 1 } \in \{ 0 , \ldots , t \}$
+
+# 4.2 META LEARNING WITHOUT TASK SEGMENTATION
+
+By taking a Bayesian filtering approach to changepoint detection, we avoid hard assignments of changepoints and instead perform a soft selection over run lengths. In this way, MOCA is able to backpropagate through the changepoint detection and directly optimize the underlying predictive model, which may be any meta-learning model that admits a probabilistic interpretation.
+
+MOCA processes a time series sequentially. We initialize $b _ { 1 } ( r _ { 1 } = 0 ) = 1$ , and initialize the posterior statistics for $\eta _ { 0 } [ r _ { 1 } = 0 ]$ as specified by the parameters $\pmb \theta$ of the meta learning algorithm. Then, at timestep $t$ , we first observe inputs $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$ and update our belief over run length accordingly, computing $b _ { t } ( \boldsymbol { r } _ { t } \mid \mathbf { \hat { x } } _ { t } )$ according to (3). Next, we marginalize over this belief to make a probabilistic prediction for the label $\mathbf { \mathscr { y } } _ { t }$ ,
+
+$$
+p _ { \theta } \big ( \hat { y } _ { t } \mid x _ { 1 : t } , y _ { 1 : t - 1 } \big ) = \sum _ { r _ { t } = 0 } ^ { t - 1 } b _ { t } \big ( r _ { t } \mid x _ { t } \big ) p _ { \theta } \big ( \hat { y } _ { t } \mid x _ { t } , \eta _ { t - 1 } [ r _ { t } ] \big )
+$$
+
+We then observe the true label ${ \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \mathbf { } } _ { \mathbf { } } \mathbf { \Xi } _ { \mathbf { } } \mathbf { \Lambda } _ { \mathbf { } } \mathbf { \Lambda } _ { \mathbf { } } \textbf { } _ { \mathbf { } } \textbf { } \textbf { } _ { \mathrm { } }$ and incur the corresponding negative log likelihood loss. We can then use this observation to update both the belief over run length, computing $\boldsymbol { b } _ { t } \left( \boldsymbol { r } _ { t } ~ | ~ \boldsymbol { x } _ { t } , \boldsymbol { y } _ { t } \right)$
+
+# Algorithm 1 Meta-Learning via Online Changepoint Analysis: Training
+
+Require: Training data $\pmb { x } _ { 1 : n } , \pmb { y } _ { 1 : n }$ , number of training iterations $N$ , initial model parameters $\pmb { \theta }$   
+1: for $i = 1$ to $N$ do   
+2: Sample training batch $\pmb { x } _ { 1 : T } , \pmb { y } _ { 1 : T }$ from the full timeseries.   
+3: Initialize belief over run length $b _ { 1 } ( r _ { 1 } = 0 ) = 1$   
+4: Initialize posterior statistics $\eta _ { 0 } [ r = 0 ]$ according to $\pmb \theta$   
+5: for $t = 1$ to $T$ do   
+6: Observe $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$   
+7: Compute $b _ { t } ( \boldsymbol { r } _ { t } \mid \boldsymbol { x } _ { t } )$ according to (3)   
+8: Predict $p _ { \pmb { \theta } } \big ( \hat { \pmb { y } } _ { t } \mid \pmb { x } _ { 1 : t } , \pmb { y } _ { 1 : t - 1 } \big )$ according to (7)   
+9: Observe yt   
+10: Incur NLL loss $\ell _ { t } = - \log p _ { \pmb { \theta } } ( \pmb { y } _ { t } \mid \pmb { x } _ { 1 : t } , \pmb { y } _ { 1 : t - 1 } )$   
+11: Compute updated posteriors $\eta _ { t } [ r _ { t } ]$ for all $r _ { t }$ according to (8)   
+12: Compute $\hat { b _ { t } } ( r _ { t } \mid \boldsymbol { x } _ { t } ^ { \prime } , \boldsymbol { y } _ { t } )$ according to (4)   
+13: Compute updated belief over run length $b _ { t + 1 }$ according to (6) and (5)   
+14: 15: end forCompute $\begin{array} { r } { \nabla _ { \pmb { \theta } } \sum _ { t = k } ^ { k + T } \ell _ { t } } \end{array}$ and perform gradient descent update to $\pmb \theta$   
+16: end for
+
+according to (4), as well as update the posterior statistics for all the run lengths using the labeled example. A recursive update rule for $\eta$ allows these parameters to be computed efficiently using the past values of $\eta$
+
+$$
+\pmb { \eta } _ { t } [ r ] = h ( \pmb { x } _ { t } , \pmb { y } _ { t } , \pmb { \eta } _ { t - 1 } [ r - 1 ] ) \quad \forall \ r = 1 , \dots , t .
+$$
+
+While MOCA could be used with an algorithm which didn’t admit such a recursive update rule, this would require storing data online and running the non-recursive posterior computation (2) on $\mathcal { D } _ { - r _ { t } }$ for every $r _ { t }$ , which involves $t$ operations using datasets of sizes from 0 to $t$ , and thus can be an $O ( t ^ { 2 } )$ operation. In contrast, the recursive updates involve $t$ operations involving just the latest datapoint, yielding $O ( t )$ complexity. Finally, we propagate the belief over run length forward in time according to (5) and (6) to obtain $\bar { b _ { t } } ( r _ { t + 1 } )$ to be ready to process the next data point.
+
+Since all these operations are differentiable, given a training time series in which there are task switches $\pmb { x } _ { 1 : n } , \pmb { y } _ { 1 : n }$ , we can run this procedure, sum the NLL losses incurred at each step, and use backpropagation within a standard deep learning framework to optimize the parameters of the base learning algorithm $\pmb \theta$ . Algorithm 1 outlines this training procedure. In practice, we sample shorter time-series of length $T$ from the training data to ease computational requirements during training; we discuss implications of this in the appendix. If available, a user can input various levels of knowledge on task segmentation by manually updating $b ( r _ { t } )$ at any time; further details on this task semi-segmented use case are provided in the appendix.
+
+# 5 MAKING YOUR MOCA: MODEL INSTANTIATIONS
+
+Thus far, we have presented MOCA at an abstract level, highlighting the fact that it can be used with any meta-learning model that admits the probabilistic interpretation as an underlying predictive model. However, there are several practical considerations in the choice of meta-learning algorithm which can influence the computational efficiency and overall performance of MOCA. For the experiments in this paper, we leverage two meta-learning algorithms which offer a clean Bayesian learning interpretation, relatively low-dimensional posterior statistics, recursive updates for these statistics, and computationally efficient likelihood evaluation under the posterior predictive. For regression experiments, we use ALPaCA (Harrison et al., 2018); for classification experiments, we use a novel algorithm based on similar Bayesian updates which we refer to as PCOC, for probabilistic clustering for online classification. For completeness, we offer a high level overview of these algorithms and show how they fit into the MOCA framework in the following subsections.
+
+# 5.1 ALPACA: BAYESIAN META-LEARNING FOR REGRESSION
+
+ALPaCA (Harrison et al., 2018) is a meta-learning approach for which the base learning model is Bayesian linear regression in a learned feature space $\pmb { y } \mid \pmb { x } \sim \mathcal { N } ( K ^ { T } \phi ( \pmb { x } , \pmb { w } ) , \Sigma _ { \epsilon } )$ where $\phi ( { \pmb x } , { \pmb w } )$ is a feed-forward neural network with weights $\pmb { w }$ mapping inputs $_ { \textbf { \em x } }$ to a $n _ { \phi }$ -dimensional feature space. ALPaCA maintains a matrix-normal distribution over $K$ , and thus, assuming Gaussian likelihood, results in a matrix-normal posterior distribution over $K$ . This posterior inference may be performed exactly, and computed recursively. The matrix-normal distribution on the last layer results in a Gaussian posterior predictive density.
+
+We fix the prior $K \sim \mathcal { M N } ( \bar { K } _ { 0 } , \Sigma _ { \epsilon } , \Lambda _ { 0 } ^ { - 1 } )$ . In this matrix-normal prior, $\bar { K } _ { 0 } \in \mathbb { R } ^ { n _ { \phi } \times n _ { y } }$ is the prior mean and $\Lambda _ { 0 }$ is a $n _ { \phi } \times n _ { \phi }$ precision matrix (inverse of the covariance). Given this prior and data model, the posterior may be recursively computed as follows. First, we define $Q _ { t } = \Lambda _ { t } ^ { - 1 } \bar { K } _ { t }$ . Then, the one step posterior update is
+
+$$
+\Lambda _ { t + 1 } ^ { - 1 } = \Lambda _ { t } ^ { - 1 } - \frac { \overset { \cdot } { ( } \Lambda _ { t } ^ { - 1 } \phi ( { \pmb x } _ { t + 1 } ) ) ( \Lambda _ { t } ^ { - 1 } \phi ( { \pmb x } _ { t + 1 } ) ) ^ { T } } { 1 + \phi ^ { T } ( { \pmb x } _ { t + 1 } ) \Lambda _ { t } ^ { - 1 } \phi ( { \pmb x } _ { t + 1 } ) } \qquad Q _ { t + 1 } = y _ { t + 1 } \phi ^ { T } ( { \pmb x } _ { t + 1 } ) + Q _ { t }
+$$
+
+and the posterior predictive distribution is
+
+$$
+p _ { \theta } ^ { \ i } ( \hat { y } _ { t + 1 } \mid x _ { 1 : t + 1 } ^ { \ i } , y _ { 1 : t } ) = \mathcal N ( ( \Lambda _ { t } ^ { - 1 } Q _ { t } ) ^ { T } \phi ( x _ { t + 1 } ) , ( 1 + \phi ^ { T } ( x _ { t + 1 } ) \Lambda _ { t } ^ { - 1 } \phi ( x _ { t + 1 } ) ) \Sigma _ { \epsilon } ) .
+$$
+
+In summary, ALPaCA is a meta learning model for which the posterior statistics are $\begin{array} { r l } { \eta _ { t } } & { { } = } \end{array}$ $\{ Q _ { t } , \Lambda _ { t } ^ { - 1 } \}$ , and the recursive update rule $h ( x , y , \eta )$ is given by (9). The parameters that are meta-learned are the prior statistics, the feature network weights, and the noise covariance: $\theta =$ $\{ \bar { K } _ { 0 } , \Lambda _ { 0 } , { w } , \Sigma _ { \epsilon } \}$ . Note that, as is typical in regression, $\mathrm { { A L P a C A } }$ only models the conditional density $p ( \pmb { y } \mid \pmb { x } )$ , implicitly assuming that $p ( { \pmb x } )$ is independent of the underlying task.
+
+# 5.2 PCOC: BAYESIAN META-LEARNING FOR CLASSIFICATION
+
+In the classification setting, one can obtain a similar Bayesian meta-learning algorithm by performing Gaussian discriminant analysis in a learned feature space. This is a novel approach to metalearning for classification which we term probabilistic clustering for online classification (PCOC, pronounced “peacock”). We present a concise description of this algorithm here but defer to the appendix for a more detailed discussion.
+
+In PCOC we process labeled input/class pairs $\left( { { \pmb x } _ { t } , y _ { t } } \right)$ by encoding the input through an embedding network $\pmb { z } _ { t } = \dot { \phi } ( \pmb { x } _ { t } ; \pmb { w } )$ , and performing Bayesian density estimation for every class. Specifically, we assume a Categorical-Gaussian generative model in this embedding space, and impose the conjugate Dirichlet prior over the class probabilities and a Gaussian prior over the mean for each class,
+
+$$
+y _ { t } \sim \mathrm { C a t } ( p _ { 1 } , . . . . , \mathbf { \hat { { p } } } _ { n _ { y } } )
+$$
+
+$$
+p _ { 1 } , . . . , p _ { n _ { y } } \sim \mathrm { D i r } ( \pmb { \alpha } _ { 0 } ) .
+$$
+
+$$
+z _ { t } \mid y _ { t } \sim \mathcal { N } ( \bar { z } _ { y _ { t } } , \Sigma _ { \epsilon , y _ { t } } ) ,
+$$
+
+$$
+\tau _ { y _ { t } } \sim \mathcal { N } ( \mu _ { y _ { t } , 0 } , \Lambda _ { y _ { t } , 0 } ^ { - 1 } ) .
+$$
+
+Given labeled context data $( x _ { t } , y _ { t } )$ , the algorithm updates its belief over the Gaussian mean for the corresponding class, as well as its belief over the probability of each class. As with ALPaCA, these posterior computations can be performed through closed form recursive updates. Defining $\begin{array} { r } { \pmb q _ { i , t } = \Lambda _ { i , t } \pmb { \mu } _ { i , t } } \end{array}$ , we have
+
+$$
+\begin{array} { r } { { } _ { - 1 } + \mathbf { 1 } _ { y _ { t } } \qquad q _ { y _ { t } , t } = q _ { y _ { t } , t - 1 } + \Sigma _ { \epsilon , y _ { t } } \phi ( { \pmb x } _ { t } ) \qquad \Lambda _ { y _ { t } , t } = \Lambda _ { y _ { t } , t - 1 } + \Sigma _ { \epsilon , y _ { t } } \phi ( { \pmb x } _ { t } ) \qquad } \end{array}
+$$
+
+where ${ \bf 1 } _ { i }$ denotes a one-hot vector with a one at index $i$ . Terms not related to class $y _ { t }$ are left unchanged in this recursive update. Given this set of posterior parameters $\pmb { \eta } _ { t } = \{ \pmb { \alpha } _ { t } , \pmb { q } _ { 1 : J , t } , \pmb { \Lambda } _ { 1 : J , t } \}$ , the posterior predictive density in the embedding space can be computed as
+
+$$
+\dot { p ( y ) } = { \alpha _ { y , t } } / ( \sum _ { i = 1 } ^ { J } { { \alpha _ { i , t } } } ) \qquad \qquad \mathrm p ( z , y ) = p ( y ) \mathcal N ( z ; \Lambda _ { y , t } ^ { - 1 } q _ { y , t } , \Lambda _ { y , t } ^ { - 1 } + \Sigma _ { \epsilon , y } )
+$$
+
+where $\mathcal { N } ( z ; \mu , \Sigma )$ denotes the Gaussian pdf with mean $\mu$ and covariance $\Sigma$ evaluated at $_ z$ . Applying Bayes rule, the posterior predictive on $y _ { t + 1 }$ given ${ \pmb x } _ { t + 1 }$ is
+
+$$
+p ( y _ { t + 1 } = j \mid x _ { 1 : t + 1 } , y _ { 1 : t } ) = \frac { p ( z = \phi ( x _ { t } ) , y = j ) } { \sum _ { i = 1 } ^ { J } p ( z = \phi ( x _ { t } ) , y = i ) } .
+$$
+
+This generative modeling approach also allows computing $p ( z _ { t + 1 } \mid \eta _ { t } )$ by simply marginalizing out $y$ from the joint density of $\bar { p ( } z , y )$ ,
+
+$$
+p ( \boldsymbol { z } _ { t + 1 } \mid \boldsymbol { \eta } _ { t } ) = \sum _ { y = 1 } ^ { J } p ( y ) \mathcal { N } ( \boldsymbol { z } _ { t + 1 } ; \boldsymbol { \mu } _ { t } , \boldsymbol { \Lambda } _ { y , t } ^ { - 1 } + \boldsymbol { \Sigma } _ { \epsilon , y } )
+$$
+
+As this only depends on the input $_ { \textbf { \em x } }$ , we can use this likelihood within MOCA to update the run length belief upon seeing $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$ and before predicting $\hat { y } _ { t }$ .
+
+In summary, PCOC performs Bayesian Gaussian discriminant analysis for online classification, and meta-learns the parameters $\pmb { \theta } = \{ \pmb { \alpha } _ { 0 } , \pmb { q } _ { 1 : J , 0 } , \pmb { \Lambda } _ { 1 : J , 0 } , \pmb { w } , \Sigma _ { \epsilon , 1 : J } \}$ for efficient few-shot online classification. In practice, we assume that all the covariances are diagonal to limit memory footprint of the posterior parameters. PCOC can be thought of a Bayesian analogue of prototypical networks (Snell et al., 2017). Further details regarding PCOC can be found in the appendix.
+
+# 6 RELATED WORK
+
+Online Learning, Continuous Learning, and Concept Drift Adaptation. A substantial literature exists on online, continual and lifelong learning (Hazan, 2016; Chen & Liu, 2016). While these terms are often used interchangeably and inconsistently, they all roughly correspond to the problem of learning within a streaming series of tasks, wherein it is desirable to re-use information from previous tasks while avoiding negative transfer French (1999); Thrun & Pratt (2012). Typically, continual learning assumes access to task segmentation information, whereas online learning does not (Aljundi et al., 2019). Regularization approaches (Kirkpatrick et al., 2017; Hazan, 2016; Li & Hoiem, 2017) have been shown to be an effective method for avoiding forgetting in continual learning. By augmenting the loss function for a new task with a penalty for deviation from the parameters learned for previous tasks, the regularizing effects of a prior are mimicked; in contrast we explicitly learn a prior over task weights that is meta-trained to be rapidly adaptive. Thus, MOCA is capable of avoiding substantial negative transfer by detecting task change, and rapidly adapting to new tasks. Aljundi et al. (2019) loosen the assumption of task segmentation in continual learning and operate in a similar setting to that addressed herein, but their work still focuses on learning a single set of parameters that perform well on all tasks; in contrast, we operate in the meta-learning setting, aiming to learn parameters that accelerate online adaptation within a task.
+
+Meta-Learning for Continuous and Online Learning. While continual learning techniques have mitigated forgetting in changing problem settings, large learning models have been slow to adapt to new tasks, due in part to the propensity of neural network models to overfit to small amounts of data. In response to this, there has been substantial interest in applying ideas from meta-learning to continual learning to enable rapid adaptation to new tasks. Indeed, some modern meta-learning models such as MAML (Finn et al., 2017) may be interpreted as regularization methods (Grant et al., 2018), wherein the regularization term is explicitly learned for fast adaptation. In the streaming data setting, several works (Nagabandi et al., 2019a; He et al., 2019) use a sliding window approach, wherein a small amount of recent data is used for conditioning. By not explicitly detecting task change and choosing the window length in response, these models risk suffering from negative transfer. Indeed, MOCA may be interpreted as an adaptive sliding window model, that actively infers the optimal window length. Nagabandi et al. (2019b) and Jerfel et al. (2019) aim to detect task changes via combining mean estimation of the dependent variable with MAML models. However, these models are both less expressive than MOCA (which maintains a full Bayesian posterior) and are not capable of task-unsegmented training. Instead, these models require pre-training with a meta-dataset that is segmented by task, limiting their applicability relative to MOCA.
+
+Empirical Bayes for Changepoint Models. The Bayesian online changepoint framework of Adams & MacKay (2007) (which we leverage in this paper) and the similar, simultaneous work of Fearnhead & Liu (2007) have generated a substantial body of follow-on work since their publication. Due to the simplicity of these algorithms—in particular, the ability to compute closed-form posteriors as opposed to being forced to turn to approximate methods such as MCMC—many practical modifications and extensions have been developed. Of particular relevance are two works that investigate empirical Bayes for the underlying predictive model, which is a similar problem to that addressed herein. In particular, Paquet (2007) develop a forward-backward algorithm that allows closed-form max likelihood estimation of the prior for simple distributions via EM. Turner et al. (2009) derive general-purpose gradients for hyperparameter optimization within the BOCPD model. This approach is similar to our work, although we use neural network meta-learning models and rely on automatic differentiation for gradient computation.
+
+# 7 EXPERIMENTAL RESULTS
+
+We investigate the performance of MOCA in three problem settings: one in regression and two in classification. Our primary goal is to characterize the impact on performance of using MOCA to move from the standard task-segmented meta-learning setting to the task-unsegmented case. To this end, we investigate the performance of MOCA versus an “oracle” model that uses the same base meta-learning algorithm, but has access to exact task segmentation at train and test time. We additionally compare against baseline sliding window models of various window lengths, which again use the same meta-learning algorithm, but always condition on the last $n$ data points. These baselines are a competitive approach to learning in time-varying data streams (Gama et al., 2014) and have been used effectively for meta-learning in time-varying settings (see e.g. Nagabandi et al. (2019a)). Finally, we compare to a “train on everything” model, which only learns a prior and does not adapt online, corresponding to a standard supervised learning approach. Many problems that are currently addressed with standard supervised learning in fact have underlying temporal structure that is ignored, and thus this baseline model is a valuable point of comparison.
+
+![](images/cbdcafd29dedb12ebdc784ef282b741636583c254046810a514bcf193edabcfb.jpg)  
+Figure 1: The performance of MOCA on the sinusoid regression problem. Right: The belief over run length versus time. The intensity of each point in the plot corresponds to the belief in run length at the associated time. The red lines show the true changepoints. Left: Visualizations of the posterior predictive density corresponding to the blue dotted lines in the figure on the right. The red line denotes the current function (task), and red points denote samples from that function. Green points denote data from previous tasks, where more faint points are older. a) A visualization of the posterior at an arbitrary time. b) The visualization of the posterior for a case in which MOCA did not successfully detect the changepoint. In this case, it is because the pre- and postchange function (corresponding to figure a and b) are highly similar. c) An instance of a multimodal posterior. d) The changepoint is initially missed due to the data generated from the post-change function being highly likely under the previous posterior. e) After an unlikely data point, the model increases its uncertainty as the changepoint is detected.
+
+In addition, we investigate in isolation the effects of task-segmentation information when provided at train-time and at test-time. To characterize the impact of test time segmentation, we train an oracle model and at test time, remove task segmentation and replace it with MOCA’s run length estimation. We then compare this to the oracle model tested with segmentation, so the only difference is availability of test-time segmentation. Similarly, to characterize the impact of train time segmentation, we provide a model trained using MOCA with task segmentation at test time and compare this to a the same MOCA model when tested without segmentation. Finally, we investigate the performance of MOCA under partial task segmentation. Due to space constraints, we defer this to the appendix. For sinusoid experiments, confidence intervals at $9 5 \%$ for three different models (trained with different random seeds). For Rainbow MNIST and miniImageNet, confidence intervals are $9 5 \%$ for five different models.
+
+# 7.1 SINUSOID REGRESSION
+
+To characterize MOCA in the regression setting, we investigate the performance on a switching sinusoid problem adapted from (Finn et al., 2017), in which a task change corresponds to a resampled sinusoid phase and amplitude. Qualitative results are visualized for the sinusoid in Fig. 1, as well as a visualization of the belief over run length at each time. Qualitatively, MOCA is capable of accurate and calibrated posterior inference with only a handful of data points, and is capable of identifying task change extremely rapidly. Typically, it identifies task change in one timestep, if the generated data does not happen to have high likelihood under the previous task as in Fig. 1d. Performance of MOCA versus baselines is presented in Fig. 2 for all problem domains. For sinusoid (left), MOCA achieves performance close to the oracle model and substantially outperforms the sliding window approaches for all hazard rates.
+
+![](images/a936a53d2e2578ab9e7206767e8c79bc465c2c78781cf95516130a74ef315f61.jpg)  
+Figure 2: Performance of MOCA versus baselines in sinusoid regression (left; lower is better), Rainbow MNIST (center; higher is better), and miniImageNet (right; higher is better), versus hazard rate. Note that for both problems, MOCA always outperforms the baselines and the performance degrades only slightly from the performance of the oracle. In contrast, sliding window methods result in severely degraded performance.
+
+Fig. 3 shows the performance of MOCA when augmented with task segmentation at test time (violet), compared to unsegmented (blue), as well as the oracle model without test segmentation (teal) compared to with test segmentation (grey). We find that as the hazard rate increases, both the value of segmentation in training and value of segmentation at test time increases steadily. Because our regression version of MOCA is not performing density estimation for the independent variable, it is not able to detect a changepoint before incurring the loss associated with an incorrect prediction. Thus, for high changepoints, considerable loss is incurred, increasing the value of task segmentation. Interestingly and counter-intuitively, the model trained with MOCA outperforms the model trained with oracle supervision, when both are given oracle supervision at test time. The MOCA training results in a small “curriculum” effect due to the non-zero weight on placed on the prior for every training iteration; in comparison, for the oracle model, a missed prediction with a highly concentrated yet incorrect posterior occasionally results in a very large loss than may destabilize training. When the oracle model is trained with a small belief weight on the prior (even down to e.g. $1 0 ^ { - 1 6 ^ { \circ } }$ ), the performance matches the MOCA model. This suggests that MOCA may be beneficial in training by acting as a form of curriculum.
+
+# 7.2 RAINBOW MNIST
+
+In the classification setting, we apply MOCA to the Rainbow MNIST dataset of Finn et al. (2019). In this dataset, MNIST digits have been perturbed via a color transformation, rotation, and scaling, and each task corresponds to a unique combination of these transformations. MOCA approaches oracle performance for most hazard rates, likely due in part to the fact that task change can usually be detected via a change in digit color. Seven colors were used, and thus with probability $6 / \dot { 7 }$ , MOCA has a very strong indicator of task change.
+
+In Fig. 3, the relative effect of the MOCA train and test is visible. For high hazard rates, as expected, MOCA at test time performs slightly worse than the oracle model. The majority of performance degradation is thus due to MOCA training. Performance degradation due to MOCA training is largest for this experiment, compared to the sinusoid and miniImageNet. Because the changing digit color results in a relatively clear indicator of changepoints, and MOCA performs a belief update based on both the image and the label, MOCA performs comparably to the oracle model at test time.
+
+# 7.3 MINIIMAGENET
+
+Finally, we investigate the performance of MOCA on the miniImageNet benchmark task (Vinyals et al., 2016). This dataset consists of 100 ImageNet categories (Deng et al., 2009), each with 600 RGB images of resolution $8 4 \times 8 4$ . In our continual learning setting, we associate each class with a semantic label that is consistent between tasks. Specifically, we split the miniImageNet dataset in to five approximately balanced high level classes, which we refer to as super-classes, as five-way classification is standard for miniImageNet (Vinyals et al., 2016; Snell et al., 2017). For example, one super-class is dog breeds, while another is food, kitchen and clothing items; details are provided in the appendix. Then, a new task corresponds to sampling a new class within each super-class, and the problem is to classify an image as belonging to a specific super-class. This enables knowledge re-use between classes, and corresponds to a continual learning scenario in which each super-class experiences distributional shift. Note that this is somewhat different from the typical task in few-shot learning, where classes have no a priori semantic meaning.
+
+![](images/41c889573642666c4a4b69c8b63f158a775748a3a46c1ee0d0be44ecb1625130.jpg)  
+Figure 3: Performance change from augmenting a model trained with MOCA with task supervision at test time (violet) and from using changepoint estimation at test time for a model trained with task-supervision (teal), for sinusoid (left), Rainbow MNIST (center), and miniImageNet (right).
+
+Fig. 2 shows that MOCA outperforms baselines for all hazard rates. Fig. 3 shows that, in contrast to the Rainbow MNIST experiment, there is a large and constant (with respect to hazard rate) performance decrease moving from oracle to MOCA at test time. Interestingly, one would expect the performance decrease with respect to hazard rate to be attributable primarily to lack of task segmentation at test time—in fact, it appears that the trend is primarily a consequence of MOCA training. This also holds for the Rainbow MNIST experiments. This is likely a consequence of the limited amount of data, as the trend is not apparent for the sinusoid experiment.
+
+# 8 DISCUSSION AND CONCLUSIONS
+
+Future Work. While MOCA addresses a continual learning problem setting, we have not formulated MOCA as an online learning algorithm. Specifically, MOCA meta-trains on an offline timeseries, and keeps the parameters $\pmb \theta$ fixed online, whereas an online learning algorithm would not have this train/test distinction, and would consider updating $\pmb { \theta }$ continuously (Hazan, 2016). However, in order to do this with MOCA, we would need to keep a running buffer of all data observed so far and to use as training data to update $\pmb \theta$ , which may be expensive in real-world domains where large volumes of data (e.g. high definition video from a large collection of cameras on an autonomous vehicle). Extending MOCA toward either strictly online training or a scheme to maintain an efficient replay buffer (Mnih et al., 2013; Vitter, 1985), is a promising direction of future work. Indeed, it may be possible to use MOCA’s changepoint analysis to inform which data to save.
+
+Beyond the continual learning extension, data efficiency may be improved by re-using information from previous tasks or modeling task evolution dynamics. Previous work (Nagabandi et al., 2019b; Jerfel et al., 2019; Knoblauch & Damoulas, 2018) has addressed the case in which tasks reoccur in both meta-learning and the BOCPD framework, and thus knowledge (in the form of a posterior estimate) may be re-used. In this work, we address the case in which tasks are sampled i.i.d. from a (typically continuous) distribution, and thus knowledge re-use is often impractical or adds marginal value. Broadly, moving beyond the assumption of i.i.d. tasks to task having associated dynamics (Al-Shedivat et al., 2018) represents a promising future direction.
+
+Conclusions. MOCA enables the application of existing meta-learning algorithms to problems without task segmentation, such as the problem setting of continual learning. We find that by leveraging a Bayesian perspective on meta-learning algorithms and augmenting these algorithms with a Bayesian changepoint detection scheme to automatically detect task switches within time-series, we can achieve similar predictive performance when compared to the standard task-segmented metalearning setting, without the often prohibitive requirement of supervised task segmentation.
+
+# REFERENCES
+
+Ryan Prescott Adams and David JC MacKay. Bayesian online changepoint detection. arXiv:0710.3742, 2007.
+
+Maruan Al-Shedivat, Trapit Bansal, Yuri Burda, Ilya Sutskever, Igor Mordatch, and Pieter Abbeel. Continuous adaptation via meta-learning in nonstationary and competitive environments. International Conference on Learning Representations (ICLR), 2018.
+
+Rahaf Aljundi, Klaas Kelchtermans, and Tinne Tuytelaars. Task-free continual learning. IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
+
+Kelsey R Allen, Evan Shelhamer, Hanul Shin, and Joshua B Tenenbaum. Infinite mixture prototypes for few-shot learning. International Conference on Machine Learning (ICML), 2019.
+
+Wei-Yu Chen, Yen-Cheng Liu, Zsolt Kira, Yu-Chiang Frank Wang, and Jia-Bin Huang. A closer look at few-shot classification. International Conference on Learning Representations (ICLR), 2019.
+
+Zhiyuan Chen and Bing Liu. Lifelong machine learning. Synthesis Lectures on Artificial Intelligence and Machine Learning, 2016.
+
+J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2009.
+
+Bradley Efron and Carl Morris. Stein’s estimation rule and its competitorsan empirical Bayes approach. Journal of the American Statistical Association, 1973.
+
+Paul Fearnhead and Zhen Liu. On-line inference for multiple changepoint problems. Journal of the Royal Statistical Society: Series B (Statistical Methodology), 2007.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. International Conference on Machine Learning (ICML), 2017.
+
+Chelsea Finn, Aravind Rajeswaran, Sham Kakade, and Sergey Levine. Online meta-learning. International Conference on Machine Learning (ICML), 2019.
+
+Robert M French. Catastrophic forgetting in connectionist networks. Trends in cognitive sciences, 1999.
+
+Joao Gama, Indr ˜ e˙ Zliobait ˇ e, Albert Bifet, Mykola Pechenizkiy, and Abdelhamid Bouchachia. A ˙ survey on concept drift adaptation. ACM computing surveys (CSUR), 2014.
+
+Marta Garnelo, Jonathan Schwarz, Dan Rosenbaum, Fabio Viola, Danilo J. Rezende, S.M. Ali Eslami, and Yee Whye Teh. Neural processes. International Conference on Machine Learning (ICML), 2018.
+
+Erin Grant, Chelsea Finn, Sergey Levine, Trevor Darrell, and Thomas Griffiths. Recasting gradientbased meta-learning as hierarchical Bayes. International Conference on Learning Representations (ICLR), 2018.
+
+James Harrison, Apoorva Sharma, and Marco Pavone. Meta-learning priors for efficient online Bayesian regression. Workshop on the Algorithmic Foundations of Robotics (WAFR), 2018.
+
+Elad Hazan. Introduction to online convex optimization. Foundations and Trends $\textsuperscript { \textregistered }$ in Optimization, 2016.
+
+Xu He, Jakub Sygnowski, Alexandre Galashov, Andrei A Rusu, Yee Whye Teh, and Razvan Pascanu. Task agnostic continual learning via meta learning. arXiv preprint arXiv:1906.05201, 2019.
+
+Khurram Javed and Martha White. Meta-learning representations for continual learning. Neural Information Processing Systems (NeurIPS), 2019.
+
+Ghassen Jerfel, Erin Grant, Thomas L Griffiths, and Katherine Heller. Online gradient-based mixtures for transfer modulation in meta-learning. Neural Information Processing Systems (NeurIPS), 2019.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. International Conference on Learning Representations (ICLR), 2015.
+
+James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, 2017.
+
+Jeremias Knoblauch and Theodoros Damoulas. Spatio-temporal bayesian on-line changepoint detection with model selection. International Conference on Machine Learning (ICML), 2018.
+
+Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE Transactions on Pattern Analysis & Machine Intelligence, 2017.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. Neural Information Processing Systems (NeurIPS), 2013.
+
+Kevin P Murphy. Machine Learning: A Probabilistic Perspective. MIT Press, 2012.
+
+Anusha Nagabandi, Ignasi Clavera, Simin Liu, Ronald S Fearing, Pieter Abbeel, Sergey Levine, and Chelsea Finn. Learning to adapt in dynamic, real-world environments through metareinforcement learning. International Conference on Learning Representations (ICLR), 2019a.
+
+Anusha Nagabandi, Chelsea Finn, and Sergey Levine. Deep online learning via meta-learning: Continual adaptation for model-based RL. arXiv:1812.07671, 2019b.
+
+Ulrich Paquet. Empirical Bayesian change point detection. Graphical Models, 2007.
+
+Mengye Ren, Eleni Triantafillou, Sachin Ravi, Jake Snell, Kevin Swersky, Joshua B Tenenbaum, Hugo Larochelle, and Richard S Zemel. Meta-learning for semi-supervised few-shot classification. International Conference on Learning Representations (ICLR), 2018.
+
+Y Saatci, R Turner, and CE Rasmussen. Gaussian process change point models. International Conference on Machine Learning (ICML), 2010.
+
+Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. Neural Information Processing Systems (NeurIPS), 2017.
+
+Charles Stein. Inadmissibility of the usual estimator for the mean of a multivariate normal distribution. Third Berkeley symposium on Mathematical statistics and Probability, 1956.
+
+Sebastian Thrun and Lorien Pratt. Learning to learn. Springer, 2012.
+
+Ryan Turner, Yunus Saatci, and Carl Edward Rasmussen. Adaptive sequential Bayesian change point detection. NeurIPS Workshop on Nonparametric Bayes, 2009.
+
+Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. Neural Information Processing Systems (NeurIPS), 2016.
+
+Jeffrey S Vitter. Random sampling with a reservoir. ACM Transactions on Mathematical Software (TOMS), 1985.
+
+Robert C Wilson, Matthew R Nassar, and Joshua I Gold. Bayesian online learning of the hazard rate in change-point problems. Neural Computation, 2010.
+
+![](images/276ccca49fb4031d4a4f325cebcfd12b2c1736c9879b8592f38b2b07731916cf.jpg)  
+Figure 4: Performance versus the training horizon $( T )$ for the sinusoid with hazard 0.01. The lowest hazard was used to increase the effects of the short training horizon. A minor decrease in performance is visible for very small training horizons (around 20), but flattens off around 100 and above. It is expected that these diminishing marginal returns will occur for all systems and hazard rates.
+
+# A BATCH TRAINING MOCA
+
+In practice, we sample batches of length $T$ from the full training time series, and train on these components. While this artificially increases the observed hazard rate (as a result of the initial belief over run length being 0 with probability 1), it substantially reduces the computational burden of training. Because MOCA maintains a posterior for each possible run length, computational requirements grow linearly with $T$ . Iterating over the whole training time series without any hypothesis pruning can be prohibitively expensive. While a variety of different pruning methods within BOCPD have been proposed (Wilson et al., 2010; Saatci et al., 2010), we require a pruning method which does not break model differentiability. Note that at test-time, we no longer require differentiability and so previously developed pruning methods may be applied.
+
+Empirically, we observe diminishing marginal returns when training on longer sequences. Fig. 4 shows the performance of MOCA for varying training sequence lengths $( T )$ . In all experiments presented in the body of the paper, we use $\dot { T } = 1 0 0$ . As discussed, small $T$ values artificially inflate the observed hazard rate, so we expect to see performance improve with larger $T$ values. Fig. 4 shows that this effect results in diminishing marginal returns, with little performance improvement beyond $T = 1 0 0$ . Longer training sequences lead to increased computation per iteration (as MOCA is linear in the runlength), as well as an increased memory burden (especially during training, when the computation graph must be retained by automatic differentiation frameworks). Thus, we believe it is best to train on the shortest possible sequences, and propose $T = 1 / \lambda$ (where $\lambda$ is the hazard rate) as a rough rule of thumb.
+
+# B PROBABILISTIC CLUSTERING FOR ONLINE CLASSIFICATION
+
+In this section we present in more detail probabilistic clustering for online classification (PCOC, pronounced “peacock”), a framework for Bayesian meta-learning for classification. PCOC extends embedding-based meta-learning algorithms (e.g. Snell et al. (2017); Vinyals et al. (2016); Allen et al. (2019); Ren et al. (2018)) to enable expressive posterior distributions (which are useful for use within the MOCA framework). However, PCOC is a valuable meta-learning algorithm outside of the MOCA framework, with many features of note for downstream applications.
+
+PCOC maps each data point, $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$ , through an embedding function1 $\phi : \mathbb { R } ^ { n _ { x } }  \mathbb { R } ^ { n _ { \phi } }$ . We choose a neural network with weights $\pmb { w }$ for the embedding function. We assume a generative model within the embedding space. We will assume that each class is sampled from a task dependant categorical distribution with class probabilities $p _ { 1 } , . . . , p _ { n _ { y } }$ . We will assume that for each class $j$ , $z = \phi ( { \bar { x } } )$ (for $\scriptstyle { \mathbf { { \mathit { x } } } } _ { k }$ with $y _ { k } = j $ ) follows a Gaussian distribution with mean $\bar { z } _ { j }$ and variance $\Sigma _ { j }$ . This assumption is a standard generative modelling assumption corresponding to a Gaussian mixture model (Murphy, 2012). As such, our classification strategy will be based on Gaussian discriminant analysis (GDA, also referred to as quadratic discriminant analysis).
+
+Given this Categorical-Gaussian generative model, we will fix a conjugate Dirichlet prior on class probabilities and a Gaussian prior on the class conditional mean:
+
+$$
+p _ { 1 } , \dots , p _ { n _ { y } } \sim \mathrm { D i r } ( \alpha _ { 0 } ) \qquad \quad \bar { z } _ { j } \sim \mathcal { N } ( \mu _ { j , 0 } , \Lambda _ { j , 0 } ^ { - 1 } ) \ \forall j
+$$
+
+Algorithm 2 Probabilistic Clustering for Online Classification   
+
+<table><tr><td colspan="2">Require:Meta-dataset D 1: Randomly initialize weights of 𝜙,Dirichlet priors, prior mean and variance of each class</td></tr><tr><td colspan="2">2: while not converged do for all D ∈D do</td></tr><tr><td>3:</td><td></td></tr><tr><td>4:</td><td>Split D into conditioning data {x1:k, y1:k} and evaluation data {xk+1:T, yk+1:T}</td></tr><tr><td>5:</td><td>Compute μj,k,△j,k and posterior Dirichlet concentration parameters for each class j</td></tr><tr><td>6:</td><td>Evaluate probability of evaluation data under posterior densities (Eq. 16)</td></tr><tr><td>7: 8:</td><td>end for</td></tr><tr><td>9: end while</td><td>Update network weights and prior terms based on maximum likelihood of evaluation data</td></tr></table>
+
+This choice of conjugate prior and generative model means that the posterior distributions on $q$ and $\bar { z } _ { j }$ remain Dirichlet and Gaussian respectively, and that the parameters of this posterior can be computed analytically.
+
+The posterior parameters at time $t$ after observing $k _ { j }$ samples of class $j$ are
+
+$$
+\begin{array} { l } { { \Lambda _ { j , t } = \Lambda _ { j , 0 } + k _ { j } \Sigma _ { \epsilon , j } ^ { - 1 } , } } \\ { { \displaystyle \mu _ { j , t } = \Lambda _ { j , t } ^ { - 1 } \big ( k _ { j } \Sigma _ { \epsilon , j } ^ { - 1 } \bar { \phi } _ { j , t } + \Lambda _ { j , 0 } \mu _ { j , 0 } \big ) , } } \\ { { \displaystyle \alpha _ { t } = \sum _ { j = 1 } ^ { J } k _ { j } \mathbf { 1 } _ { j } . } } \end{array}
+$$
+
+where $\bar { \phi } _ { j , t }$ is the sample mean of the embedded points corresponding to class $j$ . These can also be computed recursively, as outlined in the main paper in equation (11).
+
+Given these posteriors, the posterior predictive distribution for class $j$ is Gaussian:
+
+$$
+p ( \boldsymbol { z } _ { t + 1 } \mid \boldsymbol { y } _ { t + 1 } = j , \boldsymbol { x } _ { 1 : t } , \boldsymbol { y } _ { 1 : t } ) = \mathcal { N } ( \boldsymbol { z } _ { t + 1 } ; \boldsymbol { \mu } _ { j , t } , \Lambda _ { j , t } ^ { - 1 } + \Sigma _ { \epsilon , j } )
+$$
+
+Given this within-class posterior predictive, we can now consider the posterior predictive over classes. Note that, by Bayes rule,
+
+$$
+p ( y _ { t + 1 } = j \mid x _ { t + 1 } , x _ { 1 : t } , y _ { 1 : t } ) = { \frac { p ( x _ { t + 1 } \mid y _ { t + 1 } = j , x _ { 1 : t } , y _ { 1 : t } ) p ( y _ { t + 1 } = j \mid x _ { 1 : t } , y _ { 1 : t } ) } { \sum _ { i } p ( x _ { t + 1 } \mid y _ { t + 1 } = i , x _ { 1 : t } , y _ { 1 : t } ) p ( y _ { t + 1 } = i \mid x _ { 1 : t } , y _ { 1 : t } ) } } .
+$$
+
+Because we have a finite number of classes, computing the partition function in the denominator is tractable. The posterior Dirichlet probabilities take the form
+
+$$
+p ( \pmb { y } _ { t + 1 } = j \mid \pmb { x } _ { 1 : t } , \pmb { y } _ { 1 : t } ) = p ( \pmb { y } _ { t + 1 } = j \mid \pmb { y } _ { 1 : t } ) = \frac { \alpha _ { j , t } } { \sum _ { i } \alpha _ { i , t } } ,
+$$
+
+and we choose to meta-learn the Dirichlet prior $\pmb { \alpha } _ { 0 }$ . In the general meta-classification setting, each label has a task-dependent probability (the classes are not necessarily balanced, as is typically assumed in e.g. 1 shot and 5 shot benchmarks). As such, online estimation of the posterior allows us to infer the class probabilities within one task, and the Dirichlet priors allow us to meta-learn a belief over label probabilities between tasks. In addition to learning priors on imbalanced classes, this approach allows our model to encode confidence in the class probabilities. For example, for small $\alpha _ { j , 0 }$ ’s, the model will be highly sensitive to the empirical class counts within one task, whereas for large $\alpha _ { j , 0 }$ ’s, the empirical counts within one task will have a relatively small effect.
+
+# B.1 PCOC FOR EPISODIC META-CLASSIFICATION
+
+The standard episodic meta-classification benchmarks are typically of the form of $k$ -shot (corresponding to the number of context data points observed for each class), and $n$ -way (corresponding to the number of classes) (Snell et al., 2017; Finn et al., 2017; Vinyals et al., 2016). This setting is based on association between the context data and the test data; the labels do not have a priori semantic value. For example, a meta-classification problem is identical if two class labels are exchanged. This property results in simplifications for the PCOC model. Maintaining a prior over each class individually is no longer logical, as two classes with different priors could have their labels switched with no change in the problem. Therefore, in this setting, we maintain a shared prior for the mean of all classes.
+
+This generic prior over data is useful for modified problem statements. Consider a setting in which we do not a priori know the number of classes. In this case, in which data is being provided sequentially, we wish to report if the data provided at time $t$ corresponds to a previously unobserved class. Replacing the Dirichlet prior with a Chinese restaurant process (as in e.g. Nagabandi et al. (2019b); Allen et al. (2019)) would enable a few-shot meta-classification model with a potentially expandable number of classes. Moreover, a better calibrated confidence in outputs is available, which is useful for downstream tasks.
+
+# B.2 PCOC FOR STREAMING META-CLASSIFICATION
+
+We will now discuss modifications to the PCOC framework for the streaming setting. We will discuss two cases:
+
+1. The set of labels is known a priori (and labels have semantic value—i.e. reporting class $j$ has specific meaning beyond indicating that a data point belongs to the same class as other data points of class $j$ ).   
+2. The set of labels is not known in advance, and thus our streaming meta-classification algorithm must be able to predict when a class is previously unseen.
+
+In this paper we consider the first case. In this setting, we may directly apply PCOC as described above. Importantly, this setting allows “zero-shot” classification, which is critical in the MOCA framework, as we have distinct, semantically meaningful priors for each class mean. In the second case, the set of labels would necessarily need to be expanded over time, for which a non-parametric model may be used as described above. There are several versions of this problem statement, which is more similar to a “lifelong learning” setting, and we defer them to future work.
+
+# B.3 DISCUSSION
+
+PCOC extends a line of work on meta-classification based on prototypical networks (Snell et al., 2017). This framework maps the context data to an embedding space, after which it computes the centroid for each class. For a new data point, it models the probability of belonging to each class as the softmax of the distances between the embedded point and the class centroids, for some distance metric. For Euclidean distances (which the authors focus on), this corresponds to performing frequentist estimation of class means, under the assumption that the variance matrix for each class is the identity matrix2. Indeed, this corresponds to the cheapest-to-evaluate simplification of PCOC. Ren et al. (2018) propose adding a class-dependent length scale (which is a scalar), which corresponds to meta-learning a frequentist estimate of the variance for each class. Moreover, it corresponds to assuming a variance that takes the form of a scaled identity matrix. Indeed, assuming diagonality of the covariance matrix results in substantial performance improvement as the matrix inverse may be performed element-wise. This reduces the numerical complexity of this operation in the (frequently high-dimensional) embedding space from cubic to linear. However, in our implementation of MOCA, we assume diagonal covariances throughtout, resulting in comparable computational complexity to the different flavors of prototypical networks. If one were to use dense covariances, the computational performance decreases substantially (due to the necessity of matrix inversions), especially in high dimensional embedding spaces.
+
+In contrast to this previous work, PCOC has several desirable features. First, both Snell et al. (2017) and Ren et al. (2018) make the implicit assumption that the classes are balanced, whereas we perform online estimation of class probabilities via Dirichlet posterior inference. Beyond this, our approach is explicitly Bayesian, and we maintain priors over the parameters that we estimate online. This is critical for utilization in the MOCA framework. Existence of these priors allows “zero-shot” learning—it enables a model to classify incoming data to a certain class, even if no data belonging to that class has been observed within the current task. Finally, because the posteriors concentrate (the predictive variance decreases as more data is observed), we may better estimate when a change in the task has occurred. We also note that maximum likelihood estimation of Gaussian means is dominated by the James-Stein estimator (Stein, 1956), which shrinks the least squares estimator toward some prior. Moreover, the James-Stein estimator paired with empirical Bayesian estimation of the prior—which is the basis for Bayesian meta-learning approaches such as ALPaCA and PCOC—has been shown to be a very effective estimator in this problem setting (Efron & Morris, 1973).
+
+![](images/453bca4c24121084e82d962ffd2e96d186e1d9b10719cfaaab02d38607d804f6.jpg)  
+Figure 5: Test negative log likelihood of MOCA on the sinusoid problem with partial task segmentation. The partial segmentation during training results in negligible performance increase, while partial supervision at test time uniformly improves performance. Note that each column corresponds to one trained model, and thus the randomly varying performance across train supervision rates may be explained by simply results of minor differences in individual models.
+
+# C MOCA WITH PARTIAL TASK SEGMENTATION
+
+Since MOCA explicitly reasons about a belief over run-lengths, it can operate anywhere in the spectrum of the task-unsegmented case as presented so far, to the fully task-segmented setting of standard meta-learning. At every time step $t$ , the user can override the belief $\bar { b } _ { t } ( \boldsymbol { r } _ { t } )$ to provide a degree of supervision. At known changepoints, for example, the user can override $b _ { t } ( \boldsymbol { r } _ { t } )$ to have all its mass on $r _ { t } = 0$ . If the task is known not to change at the given time, the user can set the hazard probability to 0 when updating the belief for the next timestep. If a user applies both of these overrides, it amounts to effectively sidestepping the Bayesian reasoning over changepoints and revealing this information to the meta-learning algorithm. If the user only applies the former, the user effectively indicates to the algorithm when known changepoints occur, but the algorithm is free to propagate this belief forward in time according to the update rules, and detect further changepoints that were not known to the user. Finally, the Bayesian framework allows a supervisor to provide their belief over a changepoint, which may not have probability mass entirely at $r _ { t } = 0$ . Thus, MOCA flexibly incorporates any type of task supervision available to a system designer.
+
+Fig. 5 shows the performance of partial task segmentation at both train and test for the sinusoid problem, for the hazard rate 0.2. This problem was chosen as the results were highly repeatable and thus the trend is more readily observed. Here, we label a changepoint with some probability, which we refer to as the supervision rate. We do not provide supervision for any non-changepoint timesteps, and thus a supervision rate of 1 corresponds to labeling every changepoint but is not equivalent to the oracle. Specifically, the model may still have false positive changepoints, but is incapable of false negatives. This figure shows that the performance monotonically improves with increasing train supervision rate, but is largely invariant under varying train supervision. This performance improvement agrees with Fig. 3, which shows that for the sinusoid problem, performance is improved by full online segmentation. Indeed, these results show that training with MOCA results in models with comparable test performance to those with supervised changepoints, and thus there is little marginal value to task segmentation during training.
+
+# D COMPUTATIONAL PERFORMANCE
+
+Fig. 6 shows the computational performance at test time on the sinusoid problem. Note that the right hand side of the curve shows a linear trend that is expected from the growing run length belief vector. However, even for 25000 iterations, the execution time is approximately 7ms for one iteration. These experiments were performed on an Nvidia Titan Xp GPU. Interestingly, on the left hand side of the curve, the time per iteration is effectively constant until the number of iterations approaches approximately 4500. Based on our code profiling, we hypothesize that this is an artifact of overhead in matrix multiplication computations done on the GPU.
+
+![](images/a756b359b6de1248ab77ccc57a5f59c9e235605ba807a6eed39f36b981d2179e.jpg)  
+Figure 6: Time per iteration versus iteration number at test time. Note that the right hand side of the curve shows the expected linear complexity expected of MOCA. Note that for these experiments, no hypothesis pruning was performed, and thus at test time performance could be constant time as opposed to linear. This figure shows $9 5 \%$ confidence intervals for 10 trials, but the repeatability of the computation time is consistent enough that they are not visible.
+
+# E EXPERIMENTAL DETAILS
+
+# E.1 SINUSOID
+
+To test the performance of the MOCA framework combined with ALPaCA for the regression setting, we investigate a switching sinusoid regression problem. The standard sinusoid regression problem, in which randomly sampled phase and amplitude constitute a task, is a standard benchmark in metalearning (Finn et al., 2017). Moreover, a switching sinusoid problem is a popular benchmark in continuous learning (He et al., 2019; Javed & White, 2019). Each task consists of a randomly sampled phase in the range $[ 0 , \pi ]$ and amplitude in [0.1, 5]. This task was investigated for varying hazard rates. For the experiments in this paper, samples from the sinusoid had additive zero-mean Gaussian noise of variance 0.05.
+
+# E.2 RAINBOW MNIST
+
+The Rainbow MNIST dataset (introduced in Finn et al. (2019)) contains 56 different color/scale/rotation transformations of the MNIST dataset, where one transformation constitutes a task. We split this dataset into a train set of 49 transformations and a test set of 7. For hyperparameter optimization, we split the train set into a training set of 42 transformations and a validation of 7. However, because the dataset represents a fairly small amount of tasks (relative to the sinusoid problem, which has infinite), after hyperparameters were set we trained on all 49 tasks. We found this notably improved performance. Note that the same approach was used in Snell et al. (2017).
+
+# E.3 MINIIMAGENET
+
+We use the miniImageNet dataset of Vinyals et al. (2016), a standard benchmark in few-shot learning. However, the standard few-shot learning problem does not require data points to be assigned to a certain class label. Instead, given context data, the goal is to associated the test data with the correct context data. We argue that this problem setting is implausible for the continual learning setting: while observing a data stream, you are also inferring the set of possible labels. Moreover, after a task change, there is no context data to associate a new point with. Therefore we instead assume a known set of classes. We group the 100 classes of miniImageNet in to five super-classes, and perform five-way classification given these. These super-classes vary in intra-class diversity of sub-classes: for example, one of the super-class is entirely composed of sub-classes that are breeds of dogs, while another corresponds to buildings, furniture, and household objects. Thus, the strength of the prior information for each super-class varies. Moreover, the intra-class similarities are quite weak, and thus generalization from the train set to the test set is difficult and few-shot learning is still necessary and beneficial. The super-classes are detailed in table ??.
+
+The super-classes are roughly balanced in terms of number of classes contained. Each task correspond to sampling a class from within each super-class, which was fixed for the duration of that task. Each super-class was sampled with equal probability.
+
+# E.4 BASELINES
+
+Three baselines were used, described below:
+
+Table 1: Our super-class groupings for miniImageNet experiments.   
+
+<table><tr><td>Class</td><td>Description</td><td>Train/Val/Test</td><td>Synsets</td></tr><tr><td rowspan="5">1</td><td rowspan="5">Non-dog animals</td><td>Train</td><td>n01532829,n01558993,n01704323,n01749939,</td></tr><tr><td></td><td>n01770081,n01843383,n01910747, n02074367, n02165456,n02457408,n02606052, n04275548</td></tr><tr><td>Validation</td><td>n01855672,n02138441,n02174001</td></tr><tr><td>Test</td><td>n01930112, n01981276, n02129165, n02219486,</td></tr><tr><td></td><td>n02443484</td></tr><tr><td rowspan="5">2</td><td rowspan="5">Dogs, foxes, wolves</td><td>Train</td><td>n02089867,n02091831, n02101006, n02105505,</td></tr><tr><td></td><td>n02108089,n02108551, n02108915,n02111277,</td></tr><tr><td></td><td>n02113712,n02120079</td></tr><tr><td>Validation Test</td><td>n02091244,n02114548 n02099601,n02110063,n02110341,n02116738</td></tr><tr><td></td><td></td></tr><tr><td rowspan="5">3</td><td rowspan="5">Vehicles, musical instruments, nature/outdoors</td><td>Train</td><td>n02687172,n02966193,n03017168,n03838899,</td></tr><tr><td></td><td>n03854065,n04251144, n04389033, n04509417, n04515003,n04612504,n09246464,n13054560</td></tr><tr><td>Validation</td><td>n02950826,n02981792, n03417042, n03584254,</td></tr><tr><td></td><td>n03773504,n09256479</td></tr><tr><td>Test</td><td>n03272010,n04146614</td></tr><tr><td rowspan="5">4</td><td rowspan="5">Food, kitchen equipment, clothing</td><td>Train</td><td>n02747177,n02795169, n02823428, n03047690,</td></tr><tr><td></td><td>n03062245,n03207743,n03337140,n03400231,</td></tr><tr><td></td><td>n03476684,n03527444,n03676483,n04596742,</td></tr><tr><td></td><td>n07584110,n07697537,n07747607,n13133613</td></tr><tr><td>Validation</td><td>n03770439,n03980874</td></tr><tr><td rowspan="7"></td><td rowspan="7">Building, furniture, household</td><td>Test</td><td>n03146219,n03775546,n04522168,n07613480</td></tr><tr><td>Train</td><td></td></tr><tr><td></td><td>n03220513, n03347037, n03888605,n03908618,</td></tr><tr><td></td><td>n03924679,n03998194,n04067472,n04243546,</td></tr><tr><td></td><td>n04258138,n04296562,n04435653,n04443257, n04604644, n06794110</td></tr><tr><td>Validation</td><td>n02971356,n03075370,n03535780</td></tr><tr><td>Test</td><td>n02871525,n03127925,n03544143, n04149813,</td></tr></table>
+
+• Train on Everything: This baseline consists of ignoring task variation and treating the training timeseries as one dataset. Note that many datasets contain latent temporal information that is ignored, and so this approach is effectively common practice.
+
+Oracle: In this baseline, the same ALPaCA and PCOC models were used as in MOCA, but with exact knowledge of the task switch times. Note that within a regret setting, one typically compares to the best achievable performance. The oracle actually outperforms the best achieveable performance in this problem setting, as it takes at least one data point (and the associated prediction, on which loss is incurred) to become aware of the task variation.
+
+• Sliding Window: The sliding window approach is commonly used within problems that exhibit time variation, both within meta-learning (Nagabandi et al., 2019a) and continual learning (He et al., 2019; Gama et al., 2014). In this approach, the last $n$ data points are used for conditioning, under the expectation that the most recent data is the most predictive of the observations in the near future. Typically, some form of validation is used to choose the window length, $n$ . As MOCA is performing a form of adaptive windowing, it should ideally outperform any fixed window length. We compare to three window lengths $( n = 5 , 1 0 , 5 0 )$ , each of which are well-suited to part of the range of hazard rates that we consider.
+
+# E.5 TRAINING DETAILS
+
+Sinusoid. A standard feedforward network consisting of two hidden layers of 128 units was used with ReLU nonlinearities. These layers were followed by a 32 units layer and another tanh nonlinearity. Finally, the output layer (for which we learn a prior) was of size ${ \dot { 3 } } 2 \times 1$ . The same architecture was used for all baselines. This is the same architecture for sinusoid regression as was used in Harrison et al. (2018) (with the exception of using ReLU nonlinearities instead of all tanh nonlinearities). The following parameters were used for training:
+
+• Optimizer: Adam (Kingma & Ba, 2015)
+
+• Learning rate: 0.02   
+• Batch size: 50   
+• Batch length: 100   
+• Train iterations: 7500
+
+Batch length here corresponds to the number of timesteps in each training batch. Note that longer batch lengths are necessary to achieve good performance on low hazard rates, as short batch lengths artificially increase the hazard rate as a result of the assumption that each batch begins with a new task. The learning rate was decayed every 1000 training iterations.
+
+We allowed the noise variance to be learned by the model. This, counter-intuitively, resulted in a substantial performance improvement over a fixed (accurate) noise variance. This is due to a curriculum effect, where the model early one increases the noise variance and learns roughly accurate features, followed by slowly decreasing the noise variance to the correct value.
+
+Rainbow MNIST. In our experiments, we used the same architecture as was used as in Snell et al. (2017); Vinyals et al. (2016). It is often unclear in recent work on few-shot learning whether performance improvements are due to improvements in the meta-learning scheme or the network architecture used (although these things are not easily disentangled). As such, the architecture we use in this experiment provides fair comparison to previous few-shot learning work. This architecture consists of four blocks of $6 4 3 \times 3$ convolution filters, followed by a batchnorm, ReLU nonlinearity and $2 \times 2$ max pool. On the last conv black, we removed the batchnorm and the nonlinearity. For the $2 8 \times 2 8$ Rainbow MNIST dataset, this encoder leads to a 64 dimensional embedding space. For the “train on everything” baseline, we used the same architecture followed by a fully connected layer and a softmax. This architecture is standard for image classification and has a comparable number of parameters to our model.
+
+We used a diagonal covariance factorization within PCOC, substantially reducing the number of terms in the covariance matrix for each class and improving the performance of the model (due to the necessary inversion of the posterior predictive covariance). We learned a prior mean and variance for each class, as well as a noise covariance for each class (again, diagonal). We also fixed the Dirichlet priors to be large, effectively imbuing the model with the knowledge that the classes were balanced. The following parameters were used for training:
+
+• Optimizer: Adam   
+• Learning rate: 0.02   
+• Batch size: 10   
+• Batch length: 100   
+• Train iterations: 5000
+
+The learning rate was decayed every 1500 training iterations.
+
+miniImageNet. Finally, for miniImageNet, we used six convolution blocks, each as previous described. This resulted in a 64 dimensional embedding space. We initially attempted to use the same four-conv backbone as for Rainbow MNIST, but the resulting 1600 dimensional embedding space had unreasonable memory requirements for batches lengths of 100. Again, for the “train on everything” baseline, we used the same architectures with one fully connected layer followed by a softmax. The following parameters were used for training:
+
+• Optimizer: Adam   
+• Learning rate: 0.002   
+• Batch size: 10   
+• Batch length: 100   
+• Train iterations: 3000
+
+The learning rate was decayed every 1000 training iterations. We used the validation set to monitor performance, and as in Chen et al. (2019), we used the highest validation accuracy iteration for test. We also performed data augmentation as in Chen et al. (2019) by adding random reflections and color jitter to the training data.
+
+# E.6 TEST DETAILS.
+
+For all problems, a test horizon of 400 was used. Again, the longest possible test horizon was used to avoid artificial distortion of the test hazard rate. Both both problems, a batch of 200 evaluations was performed, and all confidence intervals correspond to $9 5 \%$ .

parse/train/rkcQFMZRb/rkcQFMZRb.md

@@ -0,0 +1,445 @@
+# VARIATIONAL IMAGE COMPRESSION WITH A SCALE HYPERPRIOR
+
+Johannes Ballé∗ jballe@google.com
+
+David Minnen∗ dminnen@google.com
+
+Saurabh Singh∗ saurabhsingh@google.com
+
+Sung Jin Hwang∗ sjhwang@google.com
+
+Nick Johnston∗nickj@google.com
+
+∗Google Mountain View, CA 94043, USA
+
+# ABSTRACT
+
+We describe an end-to-end trainable model for image compression based on variational autoencoders. The model incorporates a hyperprior to effectively capture spatial dependencies in the latent representation. This hyperprior relates to side information, a concept universal to virtually all modern image codecs, but largely unexplored in image compression using artificial neural networks (ANNs). Unlike existing autoencoder compression methods, our model trains a complex prior jointly with the underlying autoencoder. We demonstrate that this model leads to state-of-the-art image compression when measuring visual quality using the popular MS-SSIM index, and yields rate–distortion performance surpassing published ANN-based methods when evaluated using a more traditional metric based on squared error (PSNR). Furthermore, we provide a qualitative comparison of models trained for different distortion metrics.
+
+# 1 INTRODUCTION
+
+Recent machine learning methods for lossy image compression have generated significant interest in both the machine learning and image processing communities (e.g., Ballé et al., 2017; Theis et al., 2017; Toderici et al., 2017; Rippel and Bourdev, 2017). Like all lossy compression methods, they operate on a simple principle: an image, typically modeled as a vector of pixel intensities $_ { \textbf { \em x } }$ , is quantized, reducing the amount of information required to store or transmit it, but introducing error at the same time. Typically, it is not the pixel intensitites that are quantized directly. Rather, an alternative (latent) representation of the image is found, a vector in some other space $\textbf {  { y } }$ , and quantization takes place in this representation, yielding a discrete-valued vector $\hat { y }$ . Because it is discrete, it can be losslessly compressed using entropy coding methods, such as arithmetic coding (Rissanen and Langdon, 1981), to create a bitstream which is sent over the channel. Entropy coding relies on a prior probability model of the quantized representation, which is known to both encoder and decoder (the entropy model).
+
+In the class of ANN-based methods for image compression mentioned above, the entropy model used to compress the latent representation is typically represented as a joint, or even fully factorized, distribution $p _ { \hat { \pmb { y } } } ( \hat { \pmb { y } } )$ . Note that we need to distinguish between the actual marginal distribution of the latent representation $m ( \hat { \pmb y } )$ , and the entropy model $p _ { \hat { \pmb { y } } } ( \hat { \pmb { y } } )$ . While the entropy model is typically assumed to have some parametric form, with parameters fitted to the data, the marginal is an unknown distribution arising from both the distribution of images that are encoded, and the method which is used to infer the alternative representation $\textbf {  { y } }$ . The smallest average code length an encoder–decoder pair can achieve, using $p _ { \hat { \mathbf { \it y } } }$ as their shared entropy model, is given by the Shannon cross entropy between the two distributions:
+
+$$
+R = \mathbb { E } _ { \hat { \pmb { y } } \sim m } [ - \log _ { 2 } p _ { \hat { \pmb { y } } } ( \hat { \pmb { y } } ) ] .
+$$
+
+Note that this entropy is minimized if the model distribution is identical to the marginal. This implies that, for instance, using a fully factorized entropy model, when statistical dependencies exist in the actual distribution of the latent representation, will lead to suboptimal compression performance.
+
+One way conventional compression methods increase their compression performance is by transmitting side information: additional bits of information sent from the encoder to the decoder, which signal modifications to the entropy model intended to reduce the mismatch. This is feasible because the marginal for a particular image typically varies significantly from the marginal for the ensemble of images the compression model was designed for. In this scheme, the hope is that the amount of side information sent is smaller, on average, than the reduction of code length achieved in eq. (1) by matching $p _ { \hat { \mathbf { \it y } } }$ more closely to the marginal for a particular image. For instance, JPEG (1992) models images as independent fixed-size blocks of $8 \times 8$ pixels. However, some image structure, such as large homogeneous regions, can be more efficiently represented by considering larger blocks at a time. For this reason, more recent methods such as HEVC (2013) partition an image into variablesize blocks, convey the partition structure to the decoder as side information, and then compress the block representations using that partitioning. That is, the entropy model for JPEG is always factorized into groups of 64 elements, whereas the factorization is variable for HEVC. The HEVC decoder needs to decode the side information first, so that it can use the correct entropy model to decode the block representations. Since the encoder is free to select a partitioning that optimizes the entropy model for each image, this scheme can be used to achieve more efficient compression.
+
+![](images/62379532d85e57e76a7f106e13482a843d2413edc5754907416a7826696126f7.jpg)  
+Figure 1: Left: representation of a transform coding model as a generative Bayesian model, and a corresponding variational inference model. Nodes represent random variables or parameters, and arrows indicate conditional dependence between them. Right: diagram showing the operational structure of the compression model. Arrows indicate the flow of data, and boxes represent transformations of the data. Boxes labeled $\textit { u } | \textit { Q }$ represent either addition of uniform noise applied during training (producing vectors labeled with a tilde), or quantization and arithmetic coding/decoding during testing (producing vectors labeled with a hat).
+
+In conventional compression methods, the structure of this side information is hand-designed. In contrast, the model we present in this paper essentially learns a latent representation of the entropy model, in the same way that the underlying compression model learns a representation of the image. Because our model is optimized end-to-end, it minimizes the total expected code length by learning to balance the amount of side information with the expected improvement of the entropy model. This is done by expressing the problem formally in terms of variational autoencoders (VAEs), probabilistic generative models augmented with approximate inference models (Kingma and Welling, 2014). Ballé et al. (2017) and Theis et al. (2017) previously noted that some autoencoder-based compression methods are formally equivalent to VAEs, where the entropy model, as described above, corresponds to the prior on the latent representation. Here, we use this formalism to show that side information can be viewed as a prior on the parameters of the entropy model, making them hyperpriors of the latent representation.
+
+Specifically, we extend the model presented in Ballé et al. (2017), which has a fully factorized prior, with a hyperprior that captures the fact that spatially neighboring elements of the latent representation tend to vary together in their scales. We demonstrate that the extended model leads to state-ofthe-art image compression performance when measured using the MS-SSIM quality index (Wang, Simoncelli, et al., 2003). Furthermore, it provides significantly better rate–distortion performance compared to other ANN-based methods when measured using peak signal-to-noise ratio (PSNR), a metric based on mean squared error. Finally, we present a qualitative comparison of the effects of training the same model class using different distortion losses.
+
+# 2 COMPRESSION WITH VARIATIONAL MODELS
+
+In the transform coding approach to image compression (Goyal, 2001), the encoder transforms the image vector $_ { \textbf { \em x } }$ using a parametric analysis transform $g _ { a } ( { \pmb x } ; \phi _ { g } )$ into a latent representation $\textbf {  { y } }$ , which is then quantized to form $\hat { y }$ . Because $\hat { y }$ is discrete-valued, it can be losslessly compressed using entropy coding techniques such as arithmetic coding (Rissanen and Langdon, 1981) and transmitted as a sequence of bits. On the other side, the decoder recovers $\hat { y }$ from the compressed signal, and subjects it to a parametric synthesis transform $g _ { s } ( \hat { y } ; \pmb { \theta } _ { g } )$ to recover the reconstructed image $\hat { \pmb x }$ . In the context of this paper, we think of the transforms $g _ { a }$ and $g _ { s }$ as generic parameterized functions, such as artificial neural networks (ANNs), rather than linear transforms as in traditional compression methods. The parameters $\theta _ { g }$ and $\phi _ { g }$ then encapsulate the weights of the neurons, etc. (refer to section 4 for details).
+
+![](images/5a42160c527f00e0710d3a9ed49d63128467312382b9e89b4ef63ed65a246462.jpg)  
+Figure 2: Left: an image from the Kodak dataset. Middle left: visualization of a subset of the latent representation $\textbf {  { y } }$ of that image, learned by our factorized-prior model. Note that there is clearly visible structure around edges and textured regions, indicating that a dependency structure exists in the marginal which is not represented in the factorized prior. Middle right: standard deviations $\hat { \pmb { \sigma } }$ of the latents as predicted by the model augmented with a hyperprior. Right: latents $\textbf {  { y } }$ divided elementwise by their standard deviation. Note how this reduces the apparent structure, indicating that the structure is captured by the new prior.
+
+The quantization introduces error, which is tolerated in the context of lossy compression, giving rise to a rate–distortion optimization problem. Rate is the expected code length (bit rate) of the compressed representation: assuming the entropy coding technique is operating efficiently, this can again be written as a cross entropy:
+
+$$
+R = \mathbb { E } _ { { \pmb x } \sim p _ { \pmb x } } \left[ - \log _ { 2 } p _ { \hat { \pmb y } } \big ( Q ( g _ { a } ( { \pmb x } ; \phi _ { g } ) ) \big ) \right] ,
+$$
+
+where $Q$ represents the quantization function, and $p _ { \hat { \pmb { y } } }$ is the entropy model, as described in the introduction. In this context, the marginal distribution of the latent representation arises from the (unknown) image distribution $p _ { \pmb { x } }$ and the properties of the analysis transform. Distortion is the expected difference between the reconstruction $\hat { \pmb x }$ and the original image $_ { \textbf { \em x } }$ , as measured by a norm or perceptual metric. The coarseness of the quantization, or alternatively, the warping of the representation implied by the analysis and synthesis transforms, affects both rate and distortion, leading to a trade-off, where a higher rate allows for a lower distortion, and vice versa. Various compression methods can be viewed as minimizing a weighted sum of these two quantities. Formally, we can parameterize the problem by $\lambda$ , a weight on the distortion term. Different applications require different trade-offs, and hence different values of $\lambda$ .
+
+In order to be able to use gradient descent methods to optimize the performance of the model over the parameters of the transforms $\wp _ { g }$ and $\phi _ { g , \ l }$ ), the problem needs to be relaxed, because due to the quantization, gradients with respect to $\phi _ { g }$ are zero almost everywhere. Approximations that have been investigated include substituting the gradient of the quantizer (Theis et al., 2017), and substituting additive uniform noise for the quantizer itself during training (Ballé et al., 2016b). Here, we follow the latter method, which switches back to actual quantization when applying the model as a compression method. We denote the quantities derived from this approximation with a tilde, as opposed to a hat; for instance, $\tilde { y }$ represents the “noisy” representation, and $\hat { y }$ the quantized representation.
+
+The optimization problem can be formally represented as a variational autoencoder (Kingma and Welling, 2014); that is, a probabilistic generative model of the image combined with an approximate inference model (figure 1). The synthesis transform is linked to the generative model (“generating” a reconstructed image from the latent representation), and the analysis transform to the inference model (“inferring” the latent representation from the source image). In variational inference, the goal is to approximate the true posterior $p _ { \tilde { \pmb { y } } | \pmb { x } } ( \tilde { \pmb { y } } \mid \pmb { x } )$ , which is assumed intractable, with a parametric variational density $q ( \tilde { \textbf { \mathscr { y } } } \mid x )$ by minimizing the expectation of their Kullback–Leibler (KL) divergence over the data distribution $p _ { \pmb { x } }$ :
+
+$$
+\mathbb { E } _ { \alpha \sim p _ { \alpha } } D _ { \mathrm { K L } } [ q \mathbin { \lVert } p _ { \tilde { y } \rVert x } ] = \mathbb { E } _ { \alpha \sim p _ { \alpha } } \mathbb { E } _ { \tilde { y } \sim q } \left[ \log q ( \tilde { y } + \overbrace { x } ) ^ { * } \underbrace { \log p _ { \alpha | \tilde { y } } ( x \mathbin { \lvert } \tilde { y } ) } _ { \mathrm { V o } \mathbin { \lvert } \tilde { y } \rvert } \underbrace { - \log p _ { \tilde { y } } ( \tilde { y } ) } _ { \mathrm { V o } \mathbin { \lvert } \tilde { y } \rvert } \right] + \mathrm { c o n s t . }
+$$
+
+By matching the parametric density functions to the transform coding framework, we can appreciate that the minimization of the $\mathrm { K L }$ divergence is equivalent to optimizing the compression model for rate–distortion performance. We have indicated here that the first term will evaluate to zero, and the second and third term correspond to the weighted distortion and the bit rate, respectively. Let’s take a closer look at each of the terms.
+
+First, the mechanism of “inference” is computing the the analysis transform of the image and adding uniform noise (as a stand-in for quantization), thus:
+
+$$
+\begin{array} { l l l } { q ( \pmb { \tilde { y } } \mid \pmb { x } , \phi _ { g } ) } & { = } & { \displaystyle \prod _ { i } { \mathcal U } \big ( \tilde { y } _ { i } \mid y _ { i } - \frac { 1 } { 2 } , y _ { i } + \frac { 1 } { 2 } \big ) } \end{array}
+$$
+
+where $\mathcal { U }$ denotes a uniform distribution centered on $y _ { i }$ . Since the width of the uniform distribution is constant (equal to one), the first term in the KL divergence technically evaluates to zero, and can be dropped from the loss function.
+
+For the sake of argument, assume for a moment that the likelihood is given by:
+
+$$
+\begin{array} { r l r } { p _ { x | \tilde { y } } ( x \mid \tilde { y } , \pmb { \theta } _ { g } ) } & { = } & { \mathcal { N } \big ( x \mid \tilde { x } , ( 2 \lambda ) ^ { - 1 } \mathbf { 1 } \big ) } \\ & { } & { \mathrm { w i t h } \tilde { x } = g _ { s } ( \tilde { y } ; \pmb { \theta } _ { g } ) . } \end{array}
+$$
+
+The log likelihood then works out to be the squared difference between $_ { \textbf { \em x } }$ and $\tilde { \pmb x }$ , the output of the synthesis transform, weighted by $\lambda$ . Minimizing the second term in the KL divergence is thus equivalent to minimizing the expected distortion of the reconstructed image. A squared error loss is equivalent to choosing a Gaussian distribution; other distortion metrics may have an equivalent distribution, but this is not guaranteed, as not all metrics necessarily correspond to a normalized density function.
+
+The third term in the KL divergence is easily seen to be identical to the cross entropy between the marginal $m ( \tilde { \pmb { y } } ) = \mathbb { E } _ { { \pmb { x } } \sim p _ { \pmb { x } } } q ( \tilde { \pmb { y } } \mid { \pmb x } )$ and the prior $p _ { \tilde { \pmb { y } } } ( \tilde { \pmb { y } } )$ . It reflects the cost of encoding $\tilde { y }$ , as produced by the inference model, assuming $p _ { \tilde { \mathbf { \mathcal { Y } } } }$ as the entropy model. Note that this term represents a differential cross entropy, as opposed to a Shannon (discrete) entropy as in eq. (2), due to the uniform noise approximation. Under the given assumptions, however, they are close approximations of each other (for an empirical evaluation of this approximation, see Ballé et al., 2017). Similarly to Ballé et al. (2017), we model the prior using a non-parametric, fully factorized density model (refer to appendix 6.1 for details):
+
+$$
+p _ { \tilde { \pmb { y } } | \psi } ( \tilde { \pmb { y } } \mid \psi ) = \prod _ { i } \left( p _ { y _ { i } | \psi ^ { ( i ) } } \left( \psi ^ { ( i ) } \right) * \mathcal { U } \left( - \textstyle \frac { 1 } { 2 } , \textstyle \frac { 1 } { 2 } \right) \right) ( \tilde { y } _ { i } )
+$$
+
+where the vectors $\psi ^ { ( i ) }$ encapsulate the parameters of each univariate distribution $p _ { y _ { i } | \psi ^ { ( i ) } }$ (we denote all these parameters collectively as $\psi$ ). Note that we convolve each non-parametric density with a standard uniform density. This is to enable a better match of the prior to the marginal – for more details, see appendix 6.2. As a shorthand, we refer to this case as the factorized-prior model.
+
+The center panel in figure 2 visualizes a subset of the quantized responses $( \hat { y } )$ of a compression model trained in this way. Visually, it is clear that the choice of a factorized distribution is a stark simplification: non-zero responses are highly clustered in areas of high contrast; i.e., around edges, or within textured regions. This implies a probabilistic coupling between the responses, which is not represented in models with a fully factorized prior. We would expect a better model fit and, consequently, a better compression performance, if the model captured these dependencies. Introducing a hyperprior is an elegant way of achieving this.
+
+![](images/57f01f04f349fbee0c0c36fc2c01503e2d9f08b8341b433f11ce2de67276d55e.jpg)  
+Figure 3: As in figure 1, but extended with a hyperprior.
+
+# 3 INTRODUCTION OF A SCALE HYPERPRIOR
+
+As evident from the center panel of figure 2, there are significant spatial dependencies among the elements of $\hat { y }$ . Notably, their scales appear coupled spatially. A standard way to model dependencies between a set of target variables is to introduce latent variables conditioned on which the target variables are assumed to be independent (Bishop, 1999). We introduce an additional set of random variables $\tilde { z }$ to capture the spatial dependencies and propose to extend the model as follows (figure 3).
+
+Each element $\tilde { y } _ { i }$ is now modeled as a zero-mean Gaussian with its own standard deviation $\sigma _ { i }$ , where the standard deviations are predicted by applying a parametric transform $h _ { s }$ to $\tilde { z }$ (as above, we convolve each Gaussian density with a standard uniform; see appendix 6.2):
+
+$$
+p _ { \tilde { \pmb { y } } | \tilde { \pmb { z } } } ( \tilde { \pmb { y } } \mid \tilde { \pmb { z } } , \pmb { \theta } _ { h } ) = \prod _ { i } \Bigl ( \mathcal { N } \bigl ( 0 , \tilde { \sigma } _ { i } ^ { 2 } \bigr ) \ast \mathcal { U } \bigl ( - \textstyle { \frac { 1 } { 2 } } , \frac { 1 } { 2 } \bigr ) \Bigr ) ( \tilde { y } _ { i } )
+$$
+
+We extend the inference model simply by stacking another parametric transform $h _ { a }$ on top of $\textbf {  { y } }$ , effectively creating a single joint factorized variational posterior, as follows:
+
+$$
+\begin{array} { l c l } { { q ( \tilde { y } , \tilde { z } \mid x , \phi _ { g } , \phi _ { h } ) } } & { { = } } & { { \displaystyle { \prod _ { i } \mathcal U \big ( \tilde { y } _ { i } \mid y _ { i } - \frac { 1 } { 2 } , y _ { i } + \frac { 1 } { 2 } \big ) \cdot \prod _ { j } \mathcal U \big ( \tilde { z } _ { j } \mid z _ { j } - \frac { 1 } { 2 } , z _ { j } + \frac { 1 } { 2 } \big ) } } } \\ { { } } & { { } } & { { \mathrm { w i t h } ~ y = g _ { a } ( { \bf x } ; \phi _ { g } ) , z = h _ { a } ( y ; \phi _ { h } ) . } } \end{array}
+$$
+
+This follows the intuition that the responses $\textbf {  { y } }$ should be sufficient to estimate the spatial distribution of the standard deviations. As we have no prior beliefs about the hyperprior, we now model $\tilde { z }$ using the non-parametric, fully factorized density model previously used for $\tilde { y }$ (appendix 6.1):
+
+$$
+\begin{array} { r c l } { p _ { \tilde { z } | \psi } ( \tilde { z } \mid \psi ) } & { = } & { \displaystyle \prod _ { i } \left( p _ { z _ { i } | \psi ^ { ( i ) } } \left( \psi ^ { ( i ) } \right) * \mathcal { U } \left( - \frac { 1 } { 2 } , \frac { 1 } { 2 } \right) \right) ( \tilde { z } _ { i } ) , } \end{array}
+$$
+
+where the vectors $\psi ^ { ( i ) }$ encapsulate the parameters of each univariate distribution $p _ { z _ { i } | \psi ^ { ( i ) } }$ (collectively denoted as $\psi$ ). The loss function of this model works out to be:
+
+$$
+\begin{array} { r l } & { \mathbb { E } _ { \alpha \sim p _ { \alpha } } D _ { \mathrm { K L } } \big [ q \bigm \lVert p _ { \tilde { y } , \tilde { z } | x } \big ] = \mathbb { E } _ { \alpha \sim p _ { \alpha } } \mathbb { E } _ { \tilde { y } , \tilde { z } \sim q } \Big [ \log q ( \tilde { y } , \tilde { z } \mid x ) - \log p _ { \alpha | \tilde { y } } ( x \mid \tilde { y } ) } \\ & { \qquad \quad - \log p _ { \tilde { y } | \tilde { z } } ( \tilde { y } \mid \tilde { z } ) - \log p _ { \tilde { z } } ( \tilde { z } ) \Big ] + \mathrm { c o n s t . } } \end{array}
+$$
+
+Again, the first term is zero, since $q$ is a product of uniform densities of unit width. The second term (the likelihood) encapsulates the distortion, as before. The third and fourth term represent the cross entropies encoding $\tilde { y }$ and $\tilde { z }$ , respectively. In analogy to traditional transform coding, the fourth term can be seen as representing side information.
+
+The right-hand panel in figure 3 illustrates how the model is used as a compression method. The encoder subjects the input image $_ { \textbf { \em x } }$ to $g _ { a }$ , yielding the responses $\textbf {  { y } }$ with spatially varying standard deviations. The responses are fed into $h _ { a }$ , summarizing the distribution of standard deviations in $z , \ z$ is then quantized, compressed, and transmitted as side information. The encoder then uses the quantized vector $\hat { z }$ to estimate $\hat { \pmb { \sigma } }$ , the spatial distribution of standard deviations, and uses it to compress and transmit the quantized image representation $\hat { y }$ . The decoder first recovers $\hat { z }$ from the compressed signal. It then uses $h _ { s }$ to obtain $\hat { \pmb { \sigma } }$ , which provides it with the correct probability estimates to successfully recover $\hat { y }$ as well. It then feeds $\hat { y }$ into $g _ { s }$ to obtain the reconstructed image.
+
+![](images/bc8f3d3ee2b18a7d430f906edf28c59b3aa32b8dce5c09930528dd55ce2b696e.jpg)  
+Figure 4: Network architecture of the hyperprior model. The left side shows an image autoencoder architecture, the right side corresponds to the autoencoder implementing the hyperprior. The factorized-prior model uses the identical architecture for the analysis and synthesis transforms $g _ { a }$ and $g _ { s }$ . Q represents quantization, and AE, AD represent arithmetic encoder and arithmetic decoder, respectively. Convolution parameters are denoted as: number of filters $\times$ kernel support height $\times$ kernel support width / down- or upsampling stride, where $\uparrow$ indicates upsampling and $\downarrow$ downsampling. $N$ and $M$ were chosen dependent on $\lambda$ , with $N = 1 2 8$ and $M = 1 9 2$ for the 5 lower values, and $N = 1 9 2$ and $M = 3 2 0$ for the 3 higher values.
+
+# 4 EXPERIMENTS
+
+To compare the compression performance of our proposed models, we conducted a number of experiments using the Tensorflow framework.
+
+# 4.1 EXPERIMENTAL SETUP
+
+We set up the transforms $g _ { a } , g _ { s } , h _ { a }$ , and $h _ { s }$ as alternating compositions of linear and nonlinear functions, as is common in artificial neural networks (figure 4). Specifically, $g _ { a }$ and $g _ { s }$ are composed of convolutions and GDN/IGDN nonlinearities, which implement local divisive normalization, a type of transformation that has been shown to be particularly suitable for density modeling and compression of images (Ballé et al., 2016a; Ballé et al., 2017).1 $h _ { a }$ and $h _ { s }$ are composed of convolutions and rectifiers (rectified linear units). To make the hyperprior model and the factorized-prior model comparable, we chose identical architectures for $g _ { a }$ and $g _ { s }$ , as shown in figure 4.
+
+To maintain translation invariance across the model, all elements of $_ z$ with the same channel index are assumed to follow the same univariate distribution. This allows the model to be used with arbitrary image sizes. Arithmetic coding is implemented using a simple non-adaptive binary arithmetic coder. Each element of $\hat { y }$ and $\hat { z }$ is independently converted to its representation as a binary integer and arithmetically encoded from the most significant to the least significant bit. Since the spatial distribution of standard deviations $( \hat { \sigma } )$ is known to the decoder by the time decoding of $\hat { y }$ is attempted, the arithmetic coder does not need to handle conditional dependencies. It also does not need to be separately trained, since the binary probabilities needed for encoding are a direct function of the probability mass functions of $\hat { y }$ and $\hat { z }$ , and the probability mass functions in turn are direct functions of their “noisy” counterparts $\tilde { y } , \tilde { z }$ by design (Ballé et al., 2017). This is particulary important for $\hat { y }$ . Since the prior is conditioned on $\hat { \pmb { \sigma } }$ , the probability mass functions $p _ { \hat { y } _ { i } }$ need to be constructed “on the fly” during decoding of an image:
+
+$$
+p _ { \hat { y } _ { i } } ( \hat { y } _ { i } \mid \hat { \sigma } _ { i } ) = p _ { \tilde { y } _ { i } } ( \hat { y } _ { i } \mid \hat { \sigma } _ { i } ) = \left( \mathcal { N } ( 0 , \hat { \sigma } _ { i } ) \ast \mathcal { U } \big ( - \textstyle \frac { 1 } { 2 } , \textstyle \frac { 1 } { 2 } \big ) \right) ( \hat { y } _ { i } ) = \int _ { \hat { y } _ { i } - 1 / 2 } ^ { \hat { y } _ { i } + 1 / 2 } \mathcal { N } ( y \mid 0 , \hat { \sigma } _ { i } ) \mathrm { d } y ,
+$$
+
+which can be evaluated in closed form.
+
+The models were trained on a body of color JPEG images with heights/widths between 3000 and 5000 pixels, comprising approximately 1 million images scraped from the world wide web. Images with excessive saturation were screened out to reduce the number of non-photographic images. To reduce existing compression artifacts, the images were further downsampled by a randomized factor, such that the minimum of their height and width equaled between 640 and 1200 pixels. Then, randomly placed $2 5 6 \times 2 5 6$ pixel crops of these downsampled images were extracted. Minibatches of 8 of these crops at a time were used to perform stochastic gradient descent using the Adam algorithm (Kingma and Ba, 2015) with a learning rate of $1 0 ^ { - 4 }$ . Common machine learning techniques such as batch normalization or learning rate decay were found to have no beneficial effect (this may be due to the local normalization properties of GDN, which contain global normalization as a special case).
+
+With this setup, we trained a total of 32 separate models: half of the models with a hyperprior and half without; half of the models with mean squared error as the distortion metric (as described in the previous section), and half on the MS-SSIM distortion index (Wang, Simoncelli, et al., 2003); finally, each of these combinations with 8 different values of $\lambda$ in order to cover a range of rate– distortion tradeoffs.
+
+# 4.2 EXPERIMENTAL RESULTS
+
+We evaluate the compression performance of all models on the publicly available Kodak dataset (Eastman Kodak, 1993). Summarized rate–distortion curves are shown in figure 5. Results for individual images, as well as summarized comparisons to a wider range of existing methods are provided in appendices 6.5 and 6.7. We quantify image distortion using peak signal-to-noise ratio (PSNR) and MS-SSIM. Each curve represents the rate–distortion tradeoffs for a given set of models, across different values of $\lambda$ . Since MS-SSIM yields values between 0 (worst) and 1 (best), and most of the compared methods achieve values well above 0.9, we converted the quantity to decibels in order to improve legibility.
+
+Interestingly, but maybe not surprisingly, results differ substantially depending on which distortion metric is used in the loss function during training. When measuring distortion in PSNR (figure 5, top), both our models perform poorly if they have been optimized for MS-SSIM. However, when optimized for squared error, the model with the factorized prior outperforms existing conventional codecs such as JPEG, as well as other ANN-based methods which have been trained for squared error (Theis et al., 2017; Ballé et al., 2017). Note that other published ANN-based methods not shown here underperform compared to the ones that are shown, or have not made their data available to us. Our factorized prior model does not outperform BPG (Bellard, 2014), an encapsulation of HEVC (2013) targeted at still image compression. When training our hyperprior model for squared error, we get close to BPG performance, with better results at higher bit rates than lower ones, but still substantially outperforming all published ANN-based methods.
+
+When measuring distortion using MS-SSIM (figure 5, bottom), conventional codecs such as JPEG and BPG end up at the lower end of the performance ranking. This is not surprising, since these methods have been optimized for squared error (with hand-selected constraints intended to ensure that squared error optimization doesn’t go against visual quality). To the best of our knowledge, the state of the art for compression performance in terms of MS-SSIM is Rippel and Bourdev (2017). Surprisingly, it is matched (with better performance at high bit rates, and slightly worse performance at low bit rates) by our factorized prior model, even though their model is conceptually much more complex (due to its multiscale architecture, GAN loss, and context-adaptive entropy model). The hyperprior model adds further gains across all rate–distortion tradeoffs, consistently surpassing the state of the art.
+
+With the results differing so heavily depending on which training loss is used, one has to wonder if there are any qualitative differences in the image reconstructions. When comparing images compressed to similar bit rates by models optimized with an MS-SSIM distortion loss compared to a squared loss, we find that the overall fidelity in terms of how much detail is preserved appears similar. However, the spatial distribution of detail changes substantially. MS-SSIM, like its predecessor SSIM (Wang, Bovik, et al., 2004), is a metric designed to model human visual contrast perception. Compared to squared loss, it has the effect of attenuating the error in image regions with high contrast, and boosting the error in regions with low contrast, because the human visibility threshold varies with local contrast. This behavior yields good results for images containing textures with different local contrast (refer to examples provided in appendix 6.7). However, more frequently than expected, it can also produce results inconsistent with human expectations: for the image we show in figure 6, the compression model trained for MS-SSIM assigns more detail to the grass (low contrast), and removes detail from the text on the side of the airplane (high contrast). Because semantic relevance is often assigned to high-contrast areas (such as text, or salient objects), the squared-error optimized models produce subjectively better reconstructions in these cases. It is important to note that neither distortion metric is sophisticated enough to capture image semantics, which makes the choice of distortion loss a difficult one.
+
+![](images/9bba06d8d3bf6f4189fef638bdf634fa1defbfd77c80d22d9e7145b7919fc4fe.jpg)  
+Figure 5: Rate–distortion curves aggregated over the Kodak dataset. The top plot shows peak signalto-noise ratios as a function of bit rate $( 1 0 \log _ { 1 0 } { \frac { 2 5 5 ^ { 2 } } { d } }$ , with $d$ representing mean squared error), the bottom plot shows MS-SSIM values converted to decibels $( - 1 0 \log _ { 1 0 } ( 1 - d )$ , where $d$ is the MSSSIM value in the range between zero and one). We observe that matching the training loss to the metric used for evaluation is crucial to optimize performance. Our hyperprior model trained on squared error outperforms all other ANN-based methods in terms of PSNR, and approximates HEVC performance. In terms of MS-SSIM, the hyperprior model consistently outperforms conventional codecs as well as Rippel and Bourdev (2017), the current state-of-the-art model for that metric. Note that the PSNR plot aggregates curves over equal values of $\lambda$ , and the MS-SSIM plot aggregates over equal rates (with interpolation), in order to provide a fair comparison to both stateof-the-art methods. Refer to figures 11 and 12 in the appendix for full-page RD curves that include a wider range of compression methods.
+
+![](images/b943f199a5549dbccce4bbf79fe8e3e181aad0a6adde121033afea362bfdaa2b.jpg)  
+Figure 6: The visual artifacts generated at low bit rates depend on the training loss. The top figure (0.1864 bpp, $\mathrm { P S N R } { = } 2 7 . 9 9$ , MS-SSIM=0.9803) was generated by the hyperprior model using an MS-SSIM loss, while the bottom figure (0.1932 bpp, PSNR $= 3 2 . 2 6$ , MS-SSIM=0.9713) was trained using squared loss.
+
+![](images/2539de1bb4279ef0a0ea6c58e7aaafa41ad061f234f8407c0f8c9cffb9625ef3.jpg)  
+Figure 7: Amount of side information (encoding $\hat { z }$ ) as a function of total bit rate (encoding $\hat { y }$ and $\hat { z }$ ), for the hyperprior model optimized for squared error, averaged over the Kodak set, and normalized per pixel. Only a small fraction of the total bit rate is used for encoding $\hat { z }$ .
+
+Prior work on ANN-based image compression has shown that extending the transform coding concept from linear to nonlinear transforms fundamentally improves the qualitative nature of compression artifacts (Ballé et al., 2017). It appears that nonlinear transforms with higher computational capacity adapt better to the statistics of natural images, imitating properties of the data distribution better than linear transforms. When comparing image reconstructions visually between models with or without the hyperprior, we find no changes to the qualitative nature of the artifacts. Rather, the hyperprior model simply tends to produce image reconstructions with improved detail and a lower bit rate than the corresponding model with a factorized prior.
+
+Figure 7 shows how much of the total bit rate the hyperprior model uses as side information. The amount of side information grows with the total bit rate, but stays far below 0.1 bpp, even for the highest total bit rates. Still, the resulting improvement of the prior enables the performance gains over the factorized-prior model shown in figure 5. Note that the architecture of the models does not explicitly constrain the bit rates in any way. The illustrated trade-off in allocating bits for encoding $\hat { z }$ vs. $\hat { y }$ is simply the result of optimizing the loss function given in eq. (10).
+
+# 5 DISCUSSION
+
+We implement a variational image compression model, conceptually identical to the model presented by Ballé et al. (2017), and augment it with a more powerful entropy model by introducing a hyperprior on the local scale parameters of the latent representation. The hyperprior is trained end-to-end with the rest of the model.
+
+Like all recent image compression methods based on ANNs, our method can be directly optimized for distortion losses that are more complex than pixel-wise losses such as mean squared error. As one of the first studies in this emerging field, we examine the effect of optimizing for one of the most popular perceptual metrics, MS-SSIM, and compare it to optimizing for squared loss. Note that Ballé et al. (2016b) compare models trained for different metrics, but their results are limited by the choice of transforms. Figure 6 demonstrates that the results can show significant variation in terms of visual quality, depending on image content, which implies that unless human rating experiments are conducted to provide more reliable data, it is wise to compare methods based on more than a single type of metric.
+
+Santurkar et al. (2017) formulate their compression method in a hybrid VAE-GAN framework, adopting a stepwise training scheme where a decoder is first trained using an adversarial loss. It is then fixed, and an encoder is trained to minimize the reconstruction error. Rippel and Bourdev (2017) also employ an adversarial approach, but use a weighted combination of an MS-SSIM and an adversarial loss. Baig and Torresani (2017) propose a compression scheme based on colorization, where color channels are predicted from the the luminance channel by making use of some model specific side information. The luminance channel is compressed using a traditional method. The proposed method exhibits significant color distortions at low bit rates, and is limited by the compression method used for the luminance channel.
+
+An early exploration of hierarchical generative models for compression of small images is found in Gregor et al. (2016). However, the aspect of quantization is not thoroughly considered, and hence, no actual compression method is designed. Theis et al. (2017) approach the problem of generating gradient descent directions for quantization functions by replacing their (unhelpful) gradient with the identity function, and derive a differentiable upper bound for the discrete rate term. Ballé et al. (2016b) instead replace the quantizer with additive uniform noise during training, and the discrete rate term with a differential entropy. While this method doesn’t offer a bound for the approximation, it establishes a direct relationship between the discrete and continuous prior distributions $p _ { \hat { \mathbf { \it y } } }$ and $p _ { \tilde { \mathbf { \mathcal { Y } } } }$ , which enables direct evaluation of the discrete prior as a function of the latents $\hat { z }$ as in eq. (11), and hence makes use of a hyperprior feasible in practice. The quality of the approximation is verified empirically by Ballé et al. (2017).
+
+Wainwright and Simoncelli (2000) observe that linear filter responses (i.e., wavelet coefficients obtained by filtering an image) follow heavy-tailed marginal distributions, but can be represented as conditionally Gaussian when groups of neighboring coefficients are linked by a common scale multiplier. That is, the distributions of the filter responses can be modeled as Gaussian scale mixtures. Lyu and Simoncelli (2009) extend this model from spatially localized groups of wavelet coefficients to a global image model. Our model can be seen as a further extension of this, where the filter responses are replaced with responses of a nonlinear transform, and an approximate inference model is added. Theis et al. (2017) directly use Gaussian scale mixtures, but in the form of a fully factorized prior. In the presented form, our variational model is perhaps most closely related to ladder VAEs (Sønderby et al., 2016). However, we choose different parametric forms to accommodate the approximation of the quantization and entropy coding process.
+
+In classical transform coding methods, compression researchers have exploited statistical dependency in the latent variables (e.g., DCT or wavelet coefficients) by carefully hand-engineering entropy codes modeling the dependencies in the quantized regime (Taubman and Marcellin, 2002). This presents a much more difficult engineering problem than relying on a fully factorized entropy model; transitioning to nonlinear transforms whose parameters are determined through training (and thus may be different for each re-training) only complicates the problem. Toderici et al. (2017) model images directly with a binarized latent representation, which technically removes the need for a separate entropy coding step. However, this corresponds to a very inflexible entropy model (a uniform prior on a binary representation, with no trainable parameters). The model apparently compensates for this by using higher capacity transforms (e.g., based on recurrent networks). Johnston et al. (2017) improve the method by designing an adaptive entropy model. However, this entropy model is not included in the rate term while training the transforms, and hence no feedback (in terms of gradients) is returned from the entropy model back to the transforms during training. This breaks the paradigm of end-to-end optimization, and may stand in the way of better compression performance. Similarly, Rippel and Bourdev (2017) use a hand-designed energy function without trainable parameters as the prior for training the autoencoder, and design an adaptive entropy model post hoc. The fact that our factorized prior model matches the performance of their method, when optimized on the same metric, may point towards this disconnect. Ágústsson et al. (2017) extend the fully-factorized prior model by proposing to do vector quantization over small subtensors of the latent representation, which effectively relaxes the factorization. They train their method end-to-end.
+
+All of the models presented here make use of GDN, a type of nonlinearity implementing local normalization. As part of a Gaussianizing transformation, GDN has been shown to be more efficient, in terms of number of parameters, at removing statistical dependencies in image data, than pointwise nonlinearities (Ballé et al., 2016a). Furthermore, there has been a long history of generative models, starting with independent component analysis (Cardoso, 2003), which can successfully recover factorized representations just by maximizing likelihood assuming a fully factorized prior. Despite these facts, we observe that significant dependencies between neighboring elements remain in the latent representation of our compression models (figure 2), even though we took care not to impose constraints on the transforms which might reduce their capacity to factorize the representation (refer to appendix 6.3 for details). We attribute this to the fact that the rate–distortion loss, unlike a maximum likelihood loss, trades off the rate term against expected distortion. It is easy to see that for increasing values of $\lambda$ , the rate term containing the factorized prior becomes less and less important. Hence, it is questionable whether rate–distortion optimality implies full independence of the representation, at least for arbitrary values of $\lambda$ .
+
+Regardless of this, the fact that the hyperprior models consistently outperform models with a factorized prior illustrate that it is important for any compression method to reduce mismatch between the prior and the marginal, as in eq. (2). Our model, when trained on the appropriate loss, has the capacity to surpass the state of the art on MS-SSIM, but does not quite reach the performance of a heavily optimized traditional method such as BPG on PSNR (while outperforming all other methods based on ANNs). This discrepancy may indicate that methods based on ANNs have not yet reached the expressive power of traditional methods. As such, the introduction of a hyperprior – or, in traditional terms, side information – is an elegant way of introducing more flexible priors, and a big step in the right direction.
+
+# REFERENCES
+
+Ágústsson, Eiríkur Þór et al. (2017). “Soft-to-Hard Vector Quantization for End-to-End Learning Compressible Representations”. In: Advances in Neural Information Processing Systems 30, pp. 1141–1151.   
+Asuni, N. and A. Giachetti (2014). “TESTIMAGES: A large-scale archive for testing visual devices and basic image processing algorithms”. In: Proc. of STAG: Smart Tools and Apps for Graphics.   
+Baig, Mohammad Haris and Lorenzo Torresani (2017). “Multiple hypothesis colorization and its application to image compression”. In: Computer Vision and Image Understanding 164. DOI: 10.1016/j.cviu.2017.01.010.   
+Ballé, Johannes, Valero Laparra, and Eero P. Simoncelli (2016a). “Density Modeling of Images Using a Generalized Normalization Transformation”. In: arXiv e-prints. Presented at the 4th Int. Conf. on Learning Representations. arXiv: 1511.06281. (2016b). “End-to-end optimization of nonlinear transform codes for perceptual quality”. In: Picture Coding Symposium (PCS), 2016. DOI: 10.1109/PCS.2016.7906310. arXiv: 1607. 05006. (2017). “End-to-end Optimized Image Compression”. In: arXiv e-prints. Presented at the 5th Int. Conf. on Learning Representations. arXiv: 1611.01704.   
+Bellard, Fabrice (2014). BPG Image Format. Accessed: 2017-01-30. URL: http://bellard. org/bpg/.   
+Bishop, Christopher M. (1999). “Latent variable models”. In: Learning in Graphical Models. MIT Press, pp. 371–403.   
+Cardoso, Jean-François (2003). “Dependence, Correlation and Gaussianity in Independent Component Analysis”. In: Journal of Machine Learning Research 4, pp. 1177–1203.   
+Eastman Kodak (1993). Kodak Lossless True Color Image Suite (PhotoCD PCD0992). URL: http: //r0k.us/graphics/kodak/.   
+Goyal, Vivek K. (2001). “Theoretical Foundations of Transform Coding”. In: IEEE Signal Processing Magazine 18.5. DOI: 10.1109/79.952802.   
+Gregor, Karol et al. (2016). “Towards Conceptual Compression”. In: Advances in Neural Information Processing Systems 29, pp. 3549–3557.   
+HEVC (2013). ITU-R Rec. H.265 & ISO/IEC 23008-2: High Efficiency Video Coding.   
+JPEG (1992). ITU-R Rec. T.81 & ISO/IEC 10918-1: Digital compression and coding of continuoustone still images.   
+Johnston, Nick et al. (2017). “Improved Lossy Image Compression with Priming and Spatially Adaptive Bit Rates for Recurrent Networks”. In: arXiv e-prints. arXiv: 1703.10114.   
+Kingma, Diederik P. and Jimmy Ba (2015). “Adam: A Method for Stochastic Optimization”. In: arXiv e-prints. Presented at the 3rd Int. Conf. on Learning Representations. arXiv: 1412.6980.   
+Kingma, Diederik P. and Max Welling (2014). “Auto-Encoding Variational Bayes”. In: arXiv eprints. Presented at the 2nd Int. Conf. on Learning Representations. arXiv: 1312.6114.   
+Lyu, Siwei and Eero P. Simoncelli (2009). “Modeling Multiscale Subbands of Photographic Images with Fields of Gaussian Scale Mixtures”. In: IEEE Transactions on Pattern Analysis and Machine Intelligence 31.4. DOI: 10.1109/TPAMI.2008.107.   
+Rippel, Oren and Lubomir Bourdev (2017). “Real-Time Adaptive Image Compression”. In: Proc. of Machine Learning Research. Vol. 70, pp. 2922–2930.   
+Rissanen, Jorma and Glen G. Langdon Jr. (1981). “Universal modeling and coding”. In: IEEE Transactions on Information Theory 27.1. DOI: 10.1109/TIT.1981.1056282.   
+Santurkar, Shibani, David Budden, and Nir Shavit (2017). “Generative Compression”. In: arXiv e-prints. arXiv: 1703.01467.   
+Sønderby, Casper Kaae et al. (2016). “Ladder variational autoencoders”. In: Advances in Neural Information Processing Systems 29, pp. 3738–3746.   
+Taubman, David S. and Michael W. Marcellin (2002). JPEG 2000 – Image Compression Fundamentals, Standards and Practice. Kluwer.   
+Theis, Lucas et al. (2017). “Lossy Image Compression with Compressive Autoencoders”. In: arXiv e-prints. Presented at the 5th Int. Conf. on Learning Representations. arXiv: 1703.00395.   
+Toderici, George et al. (2017). “Full Resolution Image Compression with Recurrent Neural Networks”. In: 2017 IEEE Conf. on Computer Vision and Pattern Recognition (CVPR). DOI: 10. 1109/CVPR.2017.577. arXiv: 1608.05148.   
+Wainwright, Martin J. and Eero P. Simoncelli (2000). “Scale Mixtures of Gaussians and the Statistics of Natural Images”. In: Advances in Neural Information Processing Systems 12, pp. 855–861.   
+Wang, Zhou, Alan Conrad Bovik, et al. (2004). “Image Quality Assessment: From Error Visibility to Structural Similarity”. In: IEEE Transactions on Image Processing 13.4. DOI: 10.1109/TIP. 2003.819861.   
+Wang, Zhou, Eero P. Simoncelli, and Alan Conrad Bovik (2003). “Multi-Scale Structural Similarity for Image Quality Assessment”. In: Conf. Rec. of the 37th Asilomar Conf. on Signals, Systems and Computers. DOI: 10.1109/ACSSC.2003.1292216.
+
+![](images/ef184845470904371ac9821e99ee774ae6b93ce12ab8dbc360fc4306ff515671.jpg)  
+Figure 8: A fit of the non-parametric model $p$ (with $K = 3$ ) to a Gaussian mixture distribution. Gray plots illustrate convergence of the model. The non-parametric model is able to produce a good fit to the ground truth density.
+
+# 6 APPENDIX
+
+# 6.1 UNIVARIATE NON-PARAMETRIC DENSITY MODEL
+
+Ballé et al. (2017) use a non-parametric piecewise linear density model to represent each factor of the fully factorized prior. By increasing the number of samples per unit interval, it can in principle be used to model any univariate density with arbitrary precision. However, it has two practical problems: The range of values with non-zero probability must be finite and known ahead of time, and its implementation is non-trivial with existing automatic differentiation frameworks, both due to numerical issues with normalizing the density and the fact that it typically relies on discrete operations such as array indexing. For the compression models presented in this paper, we instead use the following model based on the cumulative.
+
+We define a density $p : \mathbb { R } \to \mathbb { R } ^ { + }$ using its cumulative $c : \mathbb { R }  [ 0 , 1 ]$ by satisfying the following constraints:
+
+$$
+c ( - \infty ) = 0 ; \quad c ( \infty ) = 1 ; \quad p ( x ) = \frac { \partial c ( x ) } { \partial x } \geq 0
+$$
+
+Note that the monotonicity constraint of the cumulative is established by requiring the density function $p$ to be non-negative. Suppose the cumulative is a composition of functions. Then the density can be written using the chain rule of calculus:
+
+$$
+\begin{array} { l } { { c = f _ { K } \circ f _ { K - 1 } \cdot \cdot \cdot f _ { 1 } } } \\ { { p = f _ { K } ^ { \prime } \cdot f _ { K - 1 } ^ { \prime } \cdot \cdot \cdot f _ { 1 } ^ { \prime } } } \end{array}
+$$
+
+where we write the derivative of $f _ { k }$ as $f _ { k } ^ { \prime }$ . We’ll allow the $f _ { k }$ to be vector functions:
+
+$$
+f _ { k } : \mathbb { R } ^ { d _ { k } }  \mathbb { R } ^ { r _ { k } }
+$$
+
+In general, the $f _ { k } ^ { \prime }$ are Jacobian matrices, and the dots are matrix multiplications. To ensure $p ( x )$ is univariate, the domain of $f _ { 1 }$ and the range of $f _ { K }$ need to be one dimensional $d _ { 1 } = r _ { K } = 1$ ).
+
+To guarantee that $p ( x )$ is a density, we just need $f _ { K }$ to map to the range between 0 and 1, and ensure that $p ( x ) \geq 0$ . To do that, we require all the Jacobian elements to be non-negative. Then the matrix product computing $p ( x )$ is non-negative as well, and we have defined a valid density.
+
+An effective choice of $f _ { k }$ is the following (as a shorthand, we define tanh, sigmoid, and softplus as elementwise functions, when applied to vectors or matrices):
+
+$$
+\begin{array} { r l } & { f _ { k } ( { \pmb x } ) = g _ { k } \big ( { \pmb H } ^ { ( k ) } { \pmb x } + { \pmb b } ^ { ( k ) } \big ) \qquad { \qquad } { 1 \leq k < K } } \\ & { f _ { K } ( { \pmb x } ) = \mathrm { s i g m o i d } \big ( { \pmb H } ^ { ( K ) } { \pmb x } + { \pmb b } ^ { ( K ) } \big ) } \end{array}
+$$
+
+where $H ^ { ( k ) }$ are matrices, $\smash { \boldsymbol { b } ^ { ( k ) } }$ are vectors, and $g _ { k }$ are nonlinearities defined as
+
+$$
+g _ { k } ( { \pmb x } ) = { \pmb x } + { \pmb a } ^ { ( k ) } \odot \operatorname { t a n h } ( { \pmb x } )
+$$
+
+where $\mathbf { \pmb { a } } ^ { ( k ) }$ is a vector and $\odot$ denotes elementwise multiplication. The rationale behind this particular nonlinearity is that it allows to expand or contract the space near $x = 0$ . $\mathbf { \pmb { a } } ^ { ( k ) }$ controls the rate of expansion (when positive) or contraction (when negative). If $\mathbf { \pmb { a } } ^ { ( k ) }$ were fixed to a positive value, “peaks” in the density would become easier to model than “troughs”.
+
+The derivatives work out as follows:
+
+$$
+\begin{array} { r l r } & { f _ { k } ^ { \prime } ( \pmb { x } ) = \mathrm { d i a g } g _ { k } ^ { \prime } \big ( \pmb { H } ^ { ( k ) } \pmb { x } + \pmb { b } ^ { ( k ) } \big ) \cdot \pmb { H } ^ { ( k ) } \qquad } & { 1 \leq k < K , \mathrm { w i t h } } \\ & { g _ { k } ^ { \prime } ( \pmb { x } ) = 1 + \pmb { a } ^ { ( k ) } \odot \mathrm { t a n h } ^ { \prime } ( \pmb { x } ) } & { \mathrm { a n d } } \\ & { f _ { K } ^ { \prime } ( \pmb { x } ) = \mathrm { s i g m o i d } ^ { \prime } \big ( \pmb { H } ^ { ( K ) } \pmb { x } + \pmb { b } ^ { ( K ) } \big ) \cdot \pmb { H } ^ { ( K ) } } & \end{array}
+$$
+
+For the derivatives to be non-negative, we need to constrain $H ^ { ( k ) }$ to have all non-negative elements, and the elements of $\mathbf { \pmb { a } } ^ { ( k ) }$ to be lower bounded by $- 1$ . This is easily done by reparameterization:
+
+$$
+\begin{array} { r l } & { H ^ { ( k ) } = \mathrm { s o f t p l u s } \big ( \hat { H } ^ { ( k ) } \big ) } \\ & { a ^ { ( k ) } = \mathrm { t a n h } \big ( \hat { \mathbf { a } } ^ { ( k ) } \big ) } \end{array}
+$$
+
+where the quantities with the hat are the actual parameters. A plot of a fit of this model to a “toy” mixture density is provided in figure 8. As a special case, setting $K = 1$ yields a logistic distribution:
+
+$$
+\begin{array} { l c l } { { c ( x ) = \displaystyle \mathrm { s i g m o i d } \big ( h x + b \big ) } }  \\ { { p ( x ) = \displaystyle \frac { h } { 2 } \cdot \displaystyle \frac { 1 } { 1 + \cosh ( h x + b ) } } } \end{array}
+$$
+
+It may seem odd to define a density function as an explicit derivative; however, in an automatic differentiation framework, this operation is very easy to implement, and the resulting density function is normalized by construction. We have found the model to fit well to arbitrary densities, and perform just as well as the piecewise linear model in the context of compression models. For all experiments in this paper, we used $K = 4$ , with the dimensionalities $r _ { 1 } = r _ { 2 } = r _ { 3 } = 3$ . Each univariate density model is associated with its own set of parameters $\mathbf { \pmb { a } } ^ { ( k ) }$ , $\smash { \pmb { b } ^ { ( k ) } }$ , $H ^ { ( k ) }$ (which, together, form $\psi ^ { ( i ) } .$ ).
+
+# 6.2 MODELING PRIORS WITH ADDED UNIFORM NOISE
+
+We model both the prior $p _ { \tilde { y } | \tilde { z } }$ and the hyperprior $p _ { \tilde { z } }$ using densities that are convolved with a standard uniform density function. This is to ensure that the priors have enough flexibility to match the variational posterior $q$ . To see this, consider that in some cases, it is beneficial in terms of rate– distortion performance for the model to “disable” part of the latent representation, leading to a lower effective dimensionality than the model architecture has been set up for. For simplicity of notation, let’s assume that the variational posterior and the prior have just one dimension which has collapsed. In this case, $g _ { a }$ converges to always producing a constant value for the corresponding dimensions:
+
+$$
+y = g _ { a } ( \pmb { x } ) = c , { \mathrm { ~ i n d e p e n d e n t ~ o f ~ } } \pmb { x } .
+$$
+
+When this happens, the marginal distribution of that element during training is a uniform density centered on $c$ , due to the added uniform noise, and the variational posterior matches it exactly:
+
+$$
+\begin{array} { r } { m ( \tilde { y } ) = q ( \tilde { y } \mid \pmb { x } ) = \mathcal { U } \big ( \tilde { y } \mid c - \frac { 1 } { 2 } , c + \frac { 1 } { 2 } \big ) . } \end{array}
+$$
+
+The cross entropy of this element is given by:
+
+$$
+\mathbb { E } _ { \tilde { y } \sim m } [ - \log _ { 2 } p _ { \tilde { y } } ] .
+$$
+
+This entropy should evaluate to zero bits, as the quantized representation is deterministic (and hence, no information needs to be transmitted). For the cross entropy to evaluate to zero, however, the prior needs to be flexible enough to assume the shape of the posterior – a unit-width uniform density.
+
+![](images/2c8bde32ca90ab541312aa54bc84525b8f5ea205f4c6e7e36daf9a7118b12720.jpg)  
+Figure 9: Fitting the density model described in the previous section to a uniform distribution, with and without convolving the model with a uniform density. Gray plots illustrate convergence of the model. While $p$ itself assumes smoothness and thus fails to find an adequate fit to the uniform with its steep edges, the augmented model fits almost perfectly.
+
+Due to its infinitely steep edges, the uniform distribution is a corner case for not only the Gaussian density model, but also the non-parametric model described in appendix 6.1. To fix this, we incorporate the added noise directly into the prior/hyperprior by convolving the underlying density model $p$ with a standard uniform:
+
+$$
+\begin{array} { l } { { \displaystyle p _ { \tilde { y } } ( \tilde { y } ) = \left( p * \mathcal { U } \big ( - \frac 1 2 , \frac 1 2 \big ) \right) ( \tilde { y } ) } } \\ { { \displaystyle \qquad = \int _ { - \infty } ^ { \infty } p ( y ) \mathcal { U } \big ( \tilde { y } - y \mid - \frac 1 2 , \frac 1 2 \big ) \mathrm { d } y } } \\ { { \displaystyle \qquad = \int _ { \tilde { y } - \frac 1 2 } ^ { \tilde { y } + \frac 1 2 } p ( y ) \mathrm { d } y } } \\ { { \displaystyle \qquad = c \big ( \tilde { y } + \frac 1 2 \big ) - c \big ( \tilde { y } - \frac 1 2 \big ) , } } \end{array}
+$$
+
+where $c$ is the cumulative of the underlying density model. Now, whatever the underlying density $p$ is, letting its scale go towards zero makes $p _ { \tilde { y } }$ approach a unit-width uniform density. Since the non-parametric model is defined via its cumulative, and the cumulative of a Gaussian is available in most computational frameworks, this solution is easy to implement in practice.
+
+# 6.3 MODEL CAPACITY
+
+Our results seem to indicate that a certain degree of statistical dependency in the latent image representation $\textbf {  { y } }$ is preferred by the rate–distortion objective, and that the hyperprior model performs better by embracing this. However, it is possible that dependencies remain simply because the analysis
+
+![](images/c64d6cbefcdb3d0e8cb85432862fe7e7859fb8767d271d28084f8a5b9b5e6fa2.jpg)  
+Figure 10: Rate–distortion curves for factorized-prior models only differing in their transform capacity (number of filters at each transform layer $N$ ). Note that performance gains with increased number of filters stagnates as a $\lambda$ -dependent saturation point is reached. For example, moving from 64 to 128 filters makes a significant difference at $0 . 5 \mathrm { b p p }$ , while moving from 128 to 192 only yields a negligible gain, and there is no benefit in going up to 256.
+
+<table><tr><td rowspan="2">CPU N</td><td colspan="2">Kodak</td><td colspan="2">Tecnick</td><td rowspan="2">GPU N</td><td colspan="2">Kodak</td><td colspan="2">Tecnick</td></tr><tr><td>encode</td><td>decode</td><td>encode</td><td>decode</td><td>encode</td><td>decode</td><td>encode</td><td>decode</td></tr><tr><td>128</td><td>331.54</td><td>334.21</td><td>1003.73</td><td>1085.56</td><td>128</td><td>242.12</td><td>338.09</td><td>491.88</td><td>799.16</td></tr><tr><td>192</td><td>551.22</td><td>576.34</td><td>1852.10</td><td>1971.85</td><td>192</td><td>310.01</td><td>385.64</td><td>630.02</td><td>1018.35</td></tr></table>
+
+Table 1: Average encoding and decoding runtimes for the proposed model in milliseconds.
+
+and synthesis transforms $g _ { a }$ and $g _ { s }$ do not have enough capacity to factorize the image representation, or because the training algorithm did not succeed in finding the global optimum. Although it is impossible to fully control for this, we attempted to minimize the chances that capacity limitations in the transforms lead to the wrong conclusions, by carefully selecting the number of filters across layers of the transforms (as given by $N$ and $M$ in figure 4).
+
+We established in previous experiments that, for a given $\lambda$ , there exist a certain number of filters per layer at which performance saturates, and no gains can be achieved by further increasing it (figure 10; note that for these experiments, we set $N = M$ ). The optimal number of filters increases with $\lambda$ , indicating that models with higher bit rates require higher transform capacities. Based on these previous experiments, we attempted to choose values close to the point of saturation, or a little higher, in order to control for capacity limitations while minimizing training time. Additionally, we found that allowing a somewhat wider bottleneck $M > N$ helps to achieve comparable performance with overall lower $N$ , and we used this when choosing the model architectures.
+
+# 6.4 COMPUTATIONAL COMPLEXITY
+
+Table 1 lists encoding and decoding times of our method for a Python and TensorFlow implementation, for CPU as well as GPU and different number of filters per layer $( N )$ , averaged over the Kodak and Tecnick datasets. Note that no performance optimization was attempted. In particular, we did not optimize the metaparameter choices (number of filters, layers, etc.) for computational complexity. Rather, we chose the number of filters high enough to rule out bottlenecks in the transforms, as described in the previous section. Only the arithmetic coding was implemented as a customized operator in $\mathrm { C } { + } { + }$ . Thus, these measurements represent proof that the method is feasible, but their utility for meaningful comparisons with other methods is limited. The average increase in runtime for the hyperprior model compared to the factorized-prior model was between $20 \%$ and $50 \%$ .
+
+# 6.5 PERFORMANCE COMPARISONS FOR THE KODAK IMAGE SET
+
+The plots in figures 11 and 12 show the same results as figure 5, but provide comparisons to a wider array of compression methods. Note that the method to aggregate rate–distortion points across images differs between the PSNR and MS-SSIM plots: in the latter, we interpolate the RD curves for each image (as shown in appendix 6.7) using cubic splines at a predefined set of bit rates, and then average across equal bit rates. In the former, no interpolation was used, averaging rate and distortion measurements across equal values of $\lambda$ . As noted by Ballé et al. (2017), directly comparing RD curves with different methods of aggregation can give misleading results. Because of this, we match our aggregation method to the data available for the current state of the art ( $\lambda$ -aggregation for HEVC and PSNR, and rate aggregation for Rippel and Bourdev (2017) and MS-SSIM). Ultimately, a comparison based on individual images, as provided in section 6.7, should be considered more reliable; however, data on individual images for Rippel and Bourdev (2017) has not been available.
+
+# 6.6 PERFORMANCE COMPARISONS FOR THE TECNICK IMAGE SET
+
+For the sake of completeness, the plots in figures 13 and 14 show results over the Tecnick dataset (Asuni and Giachetti, 2014). Rate and distortion measurements were averaged across equal values of $\lambda$ for both PSNR and MS-SSIM plots.
+
+![](images/addd1687d84ad59b013b7f3ef4e3ed06197f4e0d6d5cdfd602f3e6087c4b9109.jpg)  
+Figure 11: Rate–distortion curves for PSNR covering a wide range of conventional and ANN-based compression methods. We see that our hyperprior model (blue squares) outperforms most conventional codecs (JPEG, JPEG 2000, and WebP) as well as all ANN-based methods by a wide margin.
+
+![](images/7ceda6b5ea97a5e8ccb6105783242918557d087f6c30bf2780b1584a782c149e.jpg)  
+RD curves averaged over Kodak (MS-SSIM)   
+Figure 12: Rate–distortion curves for MS-SSIM covering a wide range of conventional and ANNbased compression methods. When trained on MS-SSIM, our hyperprior model outperforms Rippel and Bourdev (2017), the current state of the art, consistently across all bit rates. Note that even when trained using squared loss, our hyperprior model (blue squares) yields higher MS-SSIM scores than all of the conventional methods.
+
+![](images/259db6d79b3dc85c0e03c63f6ab720569e143ab77cb06559b66ee9f73973a366.jpg)  
+Figure 13: Rate–distortion curves for PSNR covering a wide range of conventional and ANN-based compression methods. Results are qualitatively similar to the results on Kodak.
+
+![](images/85c91e46fe60f6047327d98c79ac7dbd2c2815dc9bf40a69048fc3ff42465adb.jpg)  
+Figure 14: Rate–distortion curves for MS-SSIM covering a wide range of conventional and ANNbased compression methods. Results are qualitatively similar to the results on Kodak.
+
+![](images/2125d3052bce5d53f58c23b2dd171c00453715f6e4a769299e6faada7d91ab5e.jpg)  
+Figure 15: Results for Kodak image 01: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/f6fcedb41fc98a4a528e0f6b64070da91c22639772bd88815a2703caf8c4adec.jpg)  
+Kodak image 2
+
+![](images/9e0b10a6f72043ac6262bdc1a5f6a1ba1af97820ff541a169a6cd735c1b0b249.jpg)  
+Figure 16: Results for Kodak image 02: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/934473a0c9a6fab061e4bb6fbb231d383aefa38ff3837101c791cd0333ad3bec.jpg)  
+Figure 17: Results for Kodak image 03: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/5e99f81706f6c67fd84ef7b7c861df0c86ae2d31e9b3cf7e709950f7780ef5fb.jpg)  
+Figure 18: Results for Kodak image 04: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/655bc93bbba9fd7aa5447ef20827ffaddbe5eaf195c292bbae6b29305828097a.jpg)  
+Figure 19: Results for Kodak image 05: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/5ccd2c2dce17086b58c265506b77d28131db643980af0331422c4b3eec232ea6.jpg)
+
+![](images/a90e5c729474911f3b94cd3a360df857b626ba34240010f3936ffaf3ec4e074c.jpg)  
+  
+Figure 20: Results for Kodak image 06: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/908dd44854899aad26d7bc7cf68287e5a5bd28bd11e45d7c6b8bfa17057f273a.jpg)  
+Figure 21: Results for Kodak image 07: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/21c355e093d019b8b386ebf535e8cf34423d5cc8cade6b94e102ce4c8800a674.jpg)  
+Figure 22: Results for Kodak image 08: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/0ea360199e671d860dacf371e27670183e34eb26ee508d6cd2e77ad0c1e91514.jpg)  
+Figure 23: Results for Kodak image 09: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/7f569d58bcd92de1429b406e3be5654b15dc41436f3f36674139584a60d930ad.jpg)  
+Figure 24: Results for Kodak image 10: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/13f362a00878dd53c87eef57b2433814bbc9a4d8d54524ba87aa8216cf9b9303.jpg)
+
+![](images/ce39c7fad4f1033c9e1aed2877e67ac98a3b381e75195f41050353d03e4a55b4.jpg)  
+Kodak image 11   
+Figure 25: Results for Kodak image 11: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/aba4fb15169e58a0402c71691cda47fa0e0b6f79b54d3b29dd1f1b5b281ec0f9.jpg)  
+Figure 26: Results for Kodak image 12: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/29494d651f08b98be128027047f6132db917057a0a1b1bfd10d439f7d90c98b5.jpg)
+
+![](images/05090187fcc36b5c6a94f9186c46b190291e8a84d63aa220a808d7189320c218.jpg)  
+  
+Figure 27: Results for Kodak image 13: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/ba1e76a0d560ffd510faff8d2cf2fe56c614529f5cc4b321a7ce9f3f1719b24c.jpg)  
+Figure 28: Results for Kodak image 14: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/55f1352f77bd14ff1aa4d31509a8ab91bcbf6b2446e2f52764b129bad21f9d98.jpg)  
+Figure 29: Results for Kodak image 15: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/e2b7e53fc5c2625cccd8577194c64f99b374e2e97e53c489f12678a9d16d4fa3.jpg)  
+Figure 30: Results for Kodak image 16: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/980e7a12be1960b526edc4bae4553fe7b2129b97fc2dcbf8c10bc139f59ca82e.jpg)  
+Figure 31: Results for Kodak image 17: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/7bc6a2685ba2a0bf2e674779116a50088d3bd61efd598c4cc1c6b1533bdd2342.jpg)
+
+Figure 32: Results for Kodak image 18: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/e70efe640c0ce96529662f05603337c153dfd73be1ca4a4b0614386959127d52.jpg)  
+Figure 33: Results for Kodak image 19: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/8fba7ab7bbcb783fc90121e2987aba5d98266766591f39746de485d0f9c72146.jpg)  
+Figure 34: Results for Kodak image 20: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/e4bbe5c6ab3fcd2a054038ed8d0d9e06f1328e0dccde0eb53da7e604f2d80767.jpg)
+
+![](images/8f749c550d92b46a7c76bd7130313a46112faa12e6ffd2cbca3eda0bb563b95c.jpg)  
+Figure 35: Results for Kodak image 21: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/5cc8925495c68a5de8ced70b834ea0c005c64a01ca4e593b36094273ce079da2.jpg)
+
+![](images/be949666dcf2c8f0c7d31add7a2ae88b1f299d91effea55fcf9df14ab97ec9d7.jpg)  
+Kodak image 22   
+Figure 36: Results for Kodak image 22: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/fb8f1f2e51cb1b62950b8baaa4e4341626ac2a14c3b652da38b32218a5110b54.jpg)  
+Figure 37: Results for Kodak image 23: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.
+
+![](images/838de1f6f4a675ba31e0b1020aa45dee8bc1e28a0006086d8c0c3aa1730eb017.jpg)  
+Figure 38: Results for Kodak image 24: PSNR and MS-SSIM rate-distortion curves (top), and example reconstructions for the hyperprior model optimized for squared error (bottom left) and MS-SSIM (bottom right). Images correspond to third rate–distortion point from the left of the blue curves (square and disc markers, respectively). Best viewed on a computer screen.

parse/train/rkl6As0cF7/rkl6As0cF7.md

@@ -0,0 +1,576 @@
+# PROBABILISTIC RECURSIVE REASONING FOR MULTI-AGENT REINFORCEMENT LEARNING
+
+Ying $\mathbf { W e n } ^ { \ S * }$ , Yaodong Yang§∗, Rui Luo§, Jun Wang§, Wei Pan\
+
+§University College London, \Delft University of Technology {ying.wen,yaodong.yang,rui.luo,jun.wang}@cs.ucl.ac.uk {wei.pan}@tudelft.nl
+
+# ABSTRACT
+
+Humans are capable of attributing latent mental contents such as beliefs, or intentions to others. The social skill is critical in everyday life to reason about the potential consequences of their behaviors so as to plan ahead. It is known that humans use this reasoning ability recursively, i.e. considering what others believe about their own beliefs. In this paper, we start from level-1 recursion and introduce a probabilistic recursive reasoning (PR2) framework for multi-agent reinforcement learning. Our hypothesis is that it is beneficial for each agent to account for how the opponents would react to its future behaviors. Under the PR2 framework, we adopt variational Bayes methods to approximate the opponents’ conditional policy, to which each agent finds the best response and then improve their own policy. We develop decentralized-training-decentralized-execution algorithms, PR2-Q and PR2-Actor-Critic, that are proved to converge in the self-play scenario when there is one Nash equilibrium. Our methods are tested on both the matrix game and the differential game, which have a non-trivial equilibrium where common gradient-based methods fail to converge. Our experiments show that it is critical to reason about how the opponents believe about what the agent believes. We expect our work to contribute a new idea of modeling the opponents to the multi-agent reinforcement learning community.
+
+# 1 INTRODUCTION
+
+In the long journey of creating artificial intelligent (AI) that mimics human intelligence, a hallmark of an AI agent is its capabilities of understanding and interacting with other agents (Lake et al., 2017). At the cognitive level, the real-world intelligent entities (e.g. rats, humans) are born to be able to reason about various properties of interests of others (Tolman, 1948; Pfeiffer & Foster, 2013). Those interests usually indicates unobservable mental state including desires, beliefs, and intentions (Premack & Woodruff, 1978; Gopnik & Wellman, 1992). In everyday life, people use this inborn ability to reason about others’ behaviors (Gordon, 1986), plan effective interactions (Gallese & Goldman, 1998), or match with the folk psychology (Dennett, 1991). It is known that people can use this reasoning ability recursively; that is, they engage in considering what others believe about their own beliefs. A number of human social behaviors have been profiled by the recursion reasoning ability (Pynadath & Marsella, 2005). Behavioral game theorist and experimental psychologist believe that reasoning recursively is a tool of human cognition that is equipped with evolutionary advantage (Camerer et al., 2004; 2015; Goodie et al., 2012; Robalino & Robson, 2012).
+
+Traditional approach of constructing the models of other agents, also known as opponent modeling, has a rich history in the multi-agent learning (Shoham et al., 2007; Albrecht & Stone, 2018). Even though equipped with modern machine learning methods that could enrich the representation of the opponent’s behaviors (He et al., 2016), those algorithms tend to only work either under limited types of scenarios (e.g. mean-field games (Yang et al., 2018)), pre-defined opponent strategies (e.g. Tit-fot-Tat in iterated Prisoner’s Dilemma (Foerster et al., 2018)), or in cases where opponents are assumed to constantly return to the same strategy (Da Silva et al., 2006). Recently, a promising methodology from game theory – recursive reasoning – has become popular in opponent modeling (Gmytrasiewicz & Durfee, 2000; Camerer et al., 2004; Gmytrasiewicz & Doshi, 2005; De Weerd et al., 2013b). Similar to the way of thinking from humans, recursive reasoning refers to the belief reasoning process where each agent considers the reasoning process of other agents, based on which it expects to make better decisions. Importantly, it allows an opponent to reason about the modeling agent rather than being a fixed type; the process can therefore be nested in a form as "I believe that you believe that I believe ...". Despite some initial trails (Gmytrasiewicz & Doshi, 2005; Von Der Osten et al., 2017), there has been little work that tries to adopt this idea into the multi-agent deep reinforcement learning (DRL) setting. One main reason is that computing the optimal policy is prohibitively expensive (Doshi & Gmytrasiewicz, 2006; Seuken & Zilberstein, 2008).
+
+In this paper, we introduce a probabilistic recursive reasoning (PR2) framework for multi-agent DRL tasks. Unlike previous work on opponent modeling, each agent here is to consider how the opponents would react to its potential behaviors, before it tries to find the best response for its own decision making. By employing variational Bayes methods to model the uncertainty of opponents’ conditional policies, we develop decentralized-training-decentralized-execution algorithms, PR2-Q and PR2-Actor-Critic, and prove the convergence in the self-play scenario when there is only one Nash equilibrium. Our methods are tested on the matrix game and the differential game. The games come with a non-trivial equilibrium where conventional gradient-based methods find challenging. We compare against multiple strong baselines. The results justify the unique value provided by agent’s recursive reasoning capability throughout the learning. We expect our work to offer a new angel on incorporating conditional opponent modeling into the multi-agent DRL context.
+
+# 2 RELATED WORK
+
+Game theorists take initiatives in modeling the recursive reasoning procedures (Harsanyi, 1962; 1967). Since then, alternative approaches, including logics-based models (Bolander & Andersen, 2011; Muise et al., 2015) or graphical models (Doshi et al., 2009; Gal & Pfeffer, 2003; 2008), have been adopted. Recently, the idea of Theory of Mind (ToM) (Goldman et al., 2012) from cognitive science becomes popular. An example of ToM is the "Recursive Modeling Method" (RMM) (Gmytrasiewicz et al., 1991; Gmytrasiewicz & Durfee, 1995; 2000), which incorporates the agent’s uncertainty about opponent’s exact model, payoff, and recursion depth. However, these methods follow the decisiontheoretic approaches, and are studied in the limited context of one-shot games. The environment is relatively simple and the opponents are not RL agents.
+
+The Interactive POMDP (I-POMDP) (Gmytrasiewicz & Doshi, 2005) implements the idea of ToM to tackle the multi-agent RL problems. It extends the partially observed MDP (Sondik, 1971) by introducing an extra space of models of other agents into the MDP; as such, an agent can build belief models about how it believes other agents know and believe. Despite the added flexibility, I-POMDP has limitations in its solvability (Seuken & Zilberstein, 2008). Solving I-POMDP with $N$ models in each recursive level with $K$ maximum level equals to solving $\Theta \big ( N ^ { \bar { K } } \big )$ PODMPs. Such inherent complexity requires high precision on the approximation solution methods, including particle filtering (Doshi & Gmytrasiewicz, 2009), value iteration (Doshi & Perez, 2008), or policy iteration (Sonu & Doshi, 2015). Out work is different from I-POMDP in that we do not adjust the MDP; instead, we provide a probabilistic framework to implement the recursive reason in the MDP. We approximate the opponent’s conditional policy through variational Bayes methods. The induced PR2-Q and PR2-AC algorithms are model-free and can practically be used as the replacement to other multi-agent RL algorithms such as MADDPG (Lowe et al., 2017).
+
+Our work can also be tied into the study of opponent modeling (OM) Albrecht & Stone (2018). OM is all about shaping the anticipated movements of the other agents. Traditional OM can be regarded as level-0 recursive reasoning in that OM methods model how the opponent behaves based on the history, but not how the opponent would behave based on what I would behave. In general, OM methods have two major limitations. One is that OM tends to work with a pre-defined target of opponents; for example, fictitious play (Brown, 1951) and joint-action learners (Claus & Boutilier, 1998) require opponents play stationary strategies, Nash-Q (Hu & Wellman, 2003) require all agents play towards the Nash equilibrium, so do Correlated $Q$ -learning (Greenwald et al., 2003), Minimax-Q (Littman, 1994), and Friend-or-foe Q (Littman, 2001). These algorithms become invalid if the opponents change their types of policy. The other major limitation is that OM algorithms require to know the exact (Nash) equilibrium policy of the opponent during training. Typical examples include the series of WoLF models (Bowling, 2005; Bowling & Veloso, 2001a; 2002) or the Nash-Q learning $\mathrm { \Delta H u }$ & Wellman, 2003), both of which require the Nash Equilibrium at each stage game to update the Q-function. By contrast, our proposed methods, PR2-Q & PR2-AC, do not need to pre-define the type of the opponents. Neither do our methods require to know the equilibrium beforehand.
+
+![](images/17e63043b3bdf70e5410597f4bb5df1c91379beda7cf43bdf580df6b2ba2973b.jpg)  
+Figure 1: Probabilistic recursive reasoning framework. PR2 decouples the connections between agents by Eq. 3. $\textcircled{1}$ : agent $i$ takes the best response after considering all the potential consequences of opponents’ actions given its own action $a ^ { i }$ . $\textcircled{2}$ : how agent $i$ behaves in the environment serves as the prior for the opponents to learn how their actions would affect $a ^ { i }$ . $\textcircled{3}$ : similar to $\textcircled{1}$ , opponents take the best response to agent $i$ . $\textcircled{4}$ : similar to $\textcircled{2}$ , opponents’ actions are the prior knowledge to agent $i$ on estimating how $a ^ { i }$ will affect the opponents. Looping from step 1 to 4 forms recursive reasoning.
+
+Despite the recent success of applying deep RL algorithms on the single-agent discrete (Mnih et al., 2015) and continuous (Lillicrap et al., 2015) control problems, it is still challenging to transfer these methods into the multi-agent RL context. The reason is because learning independently while ignoring the others in the environment will simply break the theoretical guarantee of convergence (Tuyls & Weiss, 2012). A modern framework is to maintain a centralized critic (i.e. $Q$ -network) during training, e.g. MADDPG (Lowe et al., 2017), BiCNet (Peng et al., 2017), and multi-agent soft $Q$ -learning (Wei et al., 2018); however, they require strong assumptions that the parameters of agent policies are fully observable, letting alone the centralized $Q$ -network potentially prohibits the algorithms from scaling up. By contrast, our approach employs decentralized training with no need to maintain a central critic; neither does it require to know the exact opponents’ policies.
+
+# 3 PRELIMINARIES
+
+For an $n$ -agent stochastic game (Shapley, 1953), we define a tuple $( \mathcal { S } , \mathcal { A } ^ { 1 } , . . . , \mathcal { A } ^ { n } , r ^ { 1 } , . . . , r ^ { n } , p , \gamma )$ , where S denotes the state space, $p$ ,is the distribution of the initial state, $\gamma$ , . . . , , , . . . , , , γis the discount factor for future rewards, $\mathcal { A } ^ { i }$ and $r ^ { i } \stackrel { - } { = } r ^ { i } ( \stackrel { - } { s } , a ^ { i } , a ^ { - i } )$ γ are the action space and the reward function for agent $i \in \{ 1 , . . . , n \}$ , respectively. Agent $i$ , chooses its action $a ^ { i } \in \mathcal { A } ^ { i }$ according to the policy $\pi _ { \theta ^ { i } } ^ { i } ( { \stackrel { \smile } { a } } ^ { i } | s )$ , . . . ,parameterized by $\theta ^ { i }$ conditioning on some given state $s \in \mathcal S$ πθ. Let us define the joint policy as the θcollection of all agents’ policies $\pi _ { \theta }$ with $\theta$ representing the joint parameter. It is convenient to πθ θinterpret the joint policy from the perspective of agent $i$ such that ${ \bf \dot { \pi } } _ { \theta } = ( \pi _ { \theta ^ { i } } ^ { i } ( a ^ { i } | s ) , \pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s ) )$ , where $a ^ { - i } = ( a ^ { j } ) _ { j \neq i }$ , $\theta ^ { - i } = ( \theta ^ { j } ) _ { j \neq i }$ , and $\pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s )$ πθ πθ , πθis a compact representation of the joint policy θ θof all complementary agents of $i$ πθ. At each stage of the game, actions are taken simultaneously. Each agent is presumed to pursue the maximal cumulative reward (Sutton et al., 1998), expressed as
+
+$$
+\operatorname* { m a x } \ \eta ^ { i } ( \pi _ { \theta } ) = \mathbb { E } \left[ \sum _ { t = 1 } ^ { \infty } \gamma ^ { t } r ^ { i } ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) \right] ,
+$$
+
+with $\left( a _ { t } ^ { i } , a _ { t } ^ { - i } \right)$ sample from $( \pi _ { \theta ^ { i } } ^ { i } , \pi _ { \theta ^ { - i } } ^ { - i } )$ . Correspondingly, for the game with (infinite) time horizon, , πwe can define the state-action $Q$ , πθ-function by $\begin{array} { r } { Q _ { \pi _ { \theta } } ^ { i } ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) = \mathbb { E } \left[ \sum _ { l = 0 } ^ { \infty } \gamma ^ { l } r ^ { i } ( s _ { t + l } , a _ { t + l } ^ { i } , a _ { t + l } ^ { - i } ) \right] } \end{array}$
+
+# 3.1 NON-CORRELATED FACTORIZATION ON THE JOINT POLICY
+
+In the multi-agent learning tasks, each agent can only control its own action; however, the resulting reward value depends on other agents’ actions. The $Q$ -function of each agent, $Q _ { \pi _ { \theta } } ^ { i }$ , is subject to the joint policy $\pi _ { \theta }$ πθconsisting of all agents’ policies. One common approach is to decouple the joint πθpolicy assuming conditional independence of actions from different agents (Albrecht & Stone, 2018):
+
+$$
+\pi _ { \theta } ( a ^ { i } , a ^ { - i } | s ) = \pi _ { \theta ^ { i } } ^ { i } ( a ^ { i } | s ) \pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s ) .
+$$
+
+The study regarding the topic of “centralized training with decentralized execution” in the deep RL domain, including MADDPG (Lowe et al., 2017), COMA (Foerster et al., 2017), MF-AC (Yang et al.,
+
+2018), Multi-Agent Soft- $Q$ (Wei et al., 2018), and LOLA (Foerster et al., 2018), can be classified into this category (see more clarifications in Appendix B). Although the non-correlated factorization of the joint policy simplifies the algorithm, this simplication is vulnerable because it ignores the agents’ connections, e.g. impacts of one agent’s action on other agents, and the subsequent reactions from other agents. One might argue that during training, the joint $Q$ -function should potentially guide each agent to learn to consider and act for the mutual interests of all the agents; nonetheless, a counter-example is that the non-correlated policy could not even solve the simplest two-player zero-sum differential game where two agents act in $x$ and $y$ with the reward functions defined by $( x y , - x y )$ . In fact, by following Eq. 2, both agents are reinforced to trace a cyclic trajectory that ,never converge to the equilibrium (Mescheder et al., 2017).
+
+It is worth clarifying that the idea of non-correlated policy is still markedly different from the independent learning (IL). IL is a naive method that completely ignore other agents’ behaviors. The objective of agent $i$ is simplified to $\eta ^ { i } ( \pi _ { \theta ^ { i } } )$ , depending only on $i$ ’s own policy $\pi _ { \theta ^ { i } }$ compared to Eq. 1. η πθ πθAs Lowe et al. (2017) has pointed out, in IL, the probability of taking a gradient step in the correct direction decreases exponentially with the increasing number of agents, letting alone the major issue of the non-stationary environment due to the independence assumption (Tuyls & Weiss, 2012).
+
+# 4 MULTI-AGENT PROBABILISTIC RECURSIVE REASONING
+
+In the previous section, we have shown the weakness of the learning algorithms that build on the noncorrelated factorization on the joint policy. Here we introduce the probabilistic recursive reasoning approach that aims to capture how the opponents believe about what the agent believes. Under such setting, we devise a new multi-agent policy gradient theorem. We start from assuming the true opponent conditional policy $\pi _ { \theta ^ { - i } } ^ { - i }$ is given, and then move onward to the practical case where it is πθapproximated through variational inference.
+
+# 4.1 PROBABILISTIC RECURSIVE REASONING
+
+The issue on the non-correlated factorization is that it fails to help each agent to consider the consequence of its action on others, which could lead to the ill-posed behaviors in the multi-agent learning tasks. On the contrary, people explicitly attribute contents such as beliefs, desires, and intentions to others in daily life. It is known that human beings are capable of using this ability recursively to make decisions. Inspired by this, here we integrate the concept of recursive reasoning into the joint policy modeling, and propose the new probabilistic recursive reasoning (PR2) framework. Specifically, we employ the nested process of belief reasoning where each agent simulates the reasoning process of other agents, thinking about how its action would affect others, and then make actions based on such predictions. The process can be nested in a form as ${ } " \mathrm { I }$ believe [that you believe (that I believe)]". Here we start from considering the level-1 recursion, as psychologist have found that humans tend to reason on average at one or two level of recursion (Camerer et al., 2004), and levels higher than two do not provide significant benefits (De Weerd et al., 2013a;b; de Weerd et al., 2017). Based on this, we re-formulate the joint policy by
+
+$$
+\pi _ { \theta } ( a ^ { i } , a ^ { - i } | s ) = \underbrace { \pi _ { \theta ^ { i } } ^ { i } ( a ^ { i } | s ) \pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } ) } _ { \mathrm { A g e n t } i ^ { \ast } \mathrm { s p e r s p e c t i v e } } = \underbrace { \pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s ) \pi _ { \theta ^ { i } } ^ { i } ( a ^ { i } | s , a ^ { - i } ) } _ { \mathrm { T h e ~ o p p o n e n t s ' ~ p e r s p e c t i v e } } .
+$$
+
+Similar ways of decomposition can also be found in dual learning (Xia et al., 2017) on machine translation. From the perspective of agent $i$ , the first equality in Eq. 3 indicates that the joint policy can be essentially decomposed into two parts. The conditional part $\pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } )$ represents what πθ ,actions would be taken by the opponents given the fact that the opponents know the current state of environment and agent $i$ ’s action; this is based on what agent $i$ believes other opponents might think about itself. Note that the way of thinking developed by agent $i$ regarding how others would consider of itself is also shaped by opponents’ original policy $\dot { \pi } _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s )$ , as this is also how the opponents πθactually act in the environment. Taking into account different potential actions that agent $i$ thinks the opponents would take, agent $i$ uses the marginal policy $\pi _ { \theta ^ { i } } ^ { i } ( a ^ { i } | s )$ to find the best response. To this end, a level-1 recursive procedure is established: $a ^ { i }  a ^ { - i }  a ^ { i }$ . The same inference logic can be applied to the opponents from their perspectives, as shown in the second equality of Eq. 3.
+
+Albeit intuitive, Eq. 3 may not be practical due to the requirement on the full knowledge regarding the actual conditional policy $\pi _ { \theta ^ { - i } } ^ { - i } \big ( a ^ { - i } | s , a ^ { i } \big )$ . A natural solution is that one approximates the actual policy via a best-fit model from a family of distributions. We denote this family as $\rho _ { \phi ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } )$ with learnable parameter $\phi ^ { - i }$ φ. PR2 is probabilistic as it considers the uncertainty of modeling $\pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } )$ φ. The reasoning structure is now established as shown in Fig. 1. With the recursive πθ ,joint policy defined in Eq. 3, the $n$ -agent learning task can therefore be formulated as
+
+![](images/87be3a2046761db8099ba965d62a5b3bf462bfd55f5a96fb7e87b94dd105dce0.jpg)  
+Figure 2: Diagram of multi-agent PR2 learning algorithms. It conducts decentralized training with decentralized execution. The light grey areas on two sides indicate decentralized execution for each agent. White areas give the decentralized learning procedures. All agents share the interaction experiences in the environment represented by dark area in the middle.
+
+$$
+\begin{array} { r l } & { \underset { \theta ^ { i } , \phi ^ { - i } } { \arg \operatorname* { m a x } } \ \eta ^ { i } \left( \pi _ { \theta ^ { i } } ^ { i } ( a ^ { i } \vert s ) \rho _ { \phi ^ { - i } } ^ { - i } ( a ^ { - i } \vert s , a ^ { i } ) \right) , } \\ & { \underset { \theta ^ { - i } , \phi ^ { i } } { \arg \operatorname* { m a x } } \ \eta ^ { - i } \left( \pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } \vert s ) \rho _ { \phi ^ { i } } ^ { i } ( a ^ { i } \vert s , a ^ { - i } ) \right) . } \end{array}
+$$
+
+With the new learning protocol defined in Eq. 4 and 5, each agent now learns its own policy as well as the approximated conditional policy of other agents given its own actions. In such a way, both the agent and the opponents can keep track of the joint policy by $\pi _ { \theta ^ { i } } ^ { i } \left( a ^ { i } | s \right) \rho _ { \phi ^ { - i } } ^ { - i } \left( a ^ { - i } | s , a ^ { i } \right) \xrightarrow { }$ $\pi _ { \theta } ( a ^ { i } , a ^ { - i } | s ) \gets \pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s ) \rho _ { \phi ^ { i } } ^ { i } ( a ^ { i } | s , a ^ { - i } )$ . Once converged, the resulting approximate satistfies: $\pi _ { \theta } ( a ^ { i } , a ^ { - i } | s ) = \pi _ { \theta ^ { i } } ^ { i } ( a ^ { i } | s ) \rho _ { \phi ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } ) = \pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s ) \rho _ { \phi ^ { i } } ^ { i } ( a ^ { i } | s , a ^ { - i } ) ,$ , according to Eq. 3.
+
+# 4.2 PROBABILISTIC RECURSIVE REASONING POLICY GRADIENT
+
+Given the true opponent policy $\pi _ { \theta ^ { - i } } ^ { - i }$ and that each agent tries to maximize its cumulative return in πθthe stochastic game with the objective defined in Eq. 1, we establish the policy gradient theorem by accounting for the PR2 joint policy decomposition in Eq. 3.
+
+Proposition 1. In a stochastic game, under the recursive reasoning framework defined by Eq. 3, the update for the multi-agent recursive reasoning policy gradient method can be derived as follows:
+
+$$
+\nabla _ { \theta ^ { i } } \eta ^ { i } = \mathbb { E } _ { s \sim p , a ^ { i } \sim \pi ^ { i } } \left[ \nabla _ { \theta ^ { i } } \log \pi _ { \theta ^ { i } } ^ { i } ( a ^ { i } | s ) \int _ { a ^ { - i } } \pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } ) Q ^ { i } ( s , a ^ { i } , a ^ { - i } ) \mathrm { d } a ^ { - i } \right] .
+$$
+
+# Proof. See Appendix B.2. 
+
+Proposition 1 states that each agent should improve its policy toward the direction of the best response after it takes into account all kinds of possibilities of how other agents would react if that action is taken. The term of $\pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } )$ can be regarded as the posterior estimation of agent $i$ ’s belief θabout how the opponents would respond to his action $a ^ { i }$ , given opponents’ true policy $\pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s )$ πθserving as the prior. Note that compared to the direction of policy update in the conventional multiagent policy gradient theorem (Wei et al., 2018), $\begin{array} { r } { \int _ { a ^ { - i } } \pi _ { \theta ^ { - i } } ^ { - i } \mathring { ( } a ^ { - i } \mathring { | } s ) \mathring { Q ^ { i } } ( s , a ^ { i } , a ^ { - i } ) \mathrm { d } a ^ { - i } } \end{array}$ , the direction of the gradient update in PR2 is guided by the term $\begin{array} { r } { \int _ { a ^ { - i } } \pi _ { \theta ^ { - i } } ^ { - i } \big ( a ^ { - i } | s , a ^ { i } \big ) Q ^ { i } \big ( s , a ^ { i } , a ^ { - i } \big ) \mathrm { d } a ^ { - i } } \end{array}$ .
+
+In practice, agent $i$ might not have access to the opponents’ actual policy parameters $\theta ^ { - i }$ , it is often needed to approximate $\pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } )$ by $\rho _ { \phi ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } )$ θ, thereby we propose Proposition 2.
+
+Proposition 2. In a stochastic game, under the recursive reasoning framework defined by Eq. 3, with the opponent policy approximated by $\rho _ { \phi ^ { - i } } ^ { - i } \left( a ^ { - i } | s , a ^ { i } \right)$ , the update for the multi-agent recursive φreasoning policy gradient method can be formulated as follows:
+
+$$
+\begin{array} { r l } & { \nabla _ { \theta ^ { i } } \eta ^ { i } = \mathbb { E } _ { s \sim p , a ^ { i } \sim \pi ^ { i } } \left[ \nabla _ { \theta ^ { i } } \log \pi _ { \theta ^ { i } } ^ { i } ( a ^ { i } | s ) \cdot \mathbb { E } _ { a ^ { - i } \sim \rho _ { \phi ^ { - i } } ^ { - i } } \left[ \frac { \pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } ) } { \rho _ { \phi ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } ) } Q ^ { i } ( s , a ^ { i } , a ^ { - i } ) \right] \right] . } \end{array}
+$$
+
+Proof. Substituting the approximated model $\rho _ { \phi ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } )$ for the true policy $\pi _ { \theta - i } ^ { - i }$ in Eq. 6. 
+
+Proposition 2 raises an important point: the difference between decentralized training (algorithms that do not require the opponents’ policies) with centralized learning (algorithms that require the opponents’ policies) can in fact be quantified by a term of importance weights, similar to the connection between on-policy and off-policy methods. If we find a best-fit approximation such that $\rho _ { \phi ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } ) \to \pi _ { \theta ^ { - i } } ^ { - i } \bar { ( } a ^ { - i } | \bar { s } , a ^ { i } )$ , then Eq.7 collapses into Eq. 6.
+
+Based on Proposition 2, we could provide multi-agent PR2 learning algorithm. As illustrated in Fig. 2, it is a decentralized-training-with-decentralized-execution algorithm. In this setting, agents share the experiences in the environment including state and historical joint actions, while each agent receive its rewards privately. Our method does not require the knowledge of other agents’ policy parameters. We list the pseudo-code of PR2-AC and PR2-Q in Appendix A. Finally, one last piece missing is how to find the best-fit approximation of $\rho _ { \phi ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } )$ .
+
+# 4.3 VARIATIONAL INFERENCE ON OPPONENT CONDITIONAL POLICY
+
+We adopt an optimization-based approximation to infer the unobservable $\rho _ { \phi ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } )$ via variational inference (Jordan et al., 1999). We first define the trajectory $\tau$ φup to time $t$ including the experiences of $t$ consecutive time stages, i.e. $\tau = [ ( s _ { 1 } , a _ { 1 } ^ { i } , a _ { 1 } ^ { - i } ) , \dot { \mathrm { ~ . ~ . ~ . ~ } } , ( \dot { s _ { t } } , a _ { t } ^ { i } , \dot { a } _ { t } ^ { - i } ) ]$ . In the probabilistic τ , ,reinforcement learning (Levine, 2018), the probability of $\tau$ , . . . , , ,being generated can be derived as
+
+$$
+p ( \tau ) = \left[ p ( s _ { 1 } ) \prod _ { t = 1 } ^ { T } p ( s _ { t + 1 } | s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) \right] \exp \left( \sum _ { t = 1 } ^ { T } r ^ { i } ( s _ { t } , a _ { t } , a _ { t } ^ { - i } ) \right) .
+$$
+
+Assuming the dynamics is fixed (i.e. the agent can not influence the environment transition probability), our goal is then to find the best approximation of $\pi _ { \theta ^ { i } } ^ { i } ( a _ { t } ^ { i } | s _ { t } ) \rho _ { \phi ^ { - i } } ^ { - i } ( a _ { t } ^ { - i } | s _ { t } , a _ { t } ^ { i } )$ such that the induced trajectory distribution $\hat { p } ( \tau )$ θ φ can match with the true trajectory probability $p ( \tau )$ :
+
+$$
+\hat { p } ( \tau ) = p ( s _ { 1 } ) \prod _ { t = 1 } ^ { T } p ( s _ { t + 1 } | s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) \pi _ { \theta ^ { i } } ^ { i } ( a _ { t } ^ { i } | s _ { t } ) \rho _ { \theta ^ { - i } } ^ { - i } ( a _ { t } ^ { - i } | s _ { t } , a _ { t } ^ { i } ) .
+$$
+
+In other words, we can optimize the opponents’ policy $\rho _ { \phi ^ { - i } } ^ { - i }$ via minimizing the $K L$ -divergence, i.e.
+
+$$
+\begin{array} { l } { \displaystyle D _ { \mathrm { K L } } ( \hat { p } ( \tau ) \| p ( \tau ) ) = - \mathbb { E } _ { \tau \sim \hat { p } ( \tau ) } \big [ \log p ( \tau ) - \log \hat { p } ( \tau ) \big ] } \\ { \displaystyle \qquad = - \sum _ { t = 1 } ^ { t - T } E _ { \tau \sim \hat { p } ( \tau ) } \left[ r ^ { i } \left( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } \right) + \mathcal { H } \left( \pi _ { \theta ^ { i } } ^ { i } \left( a _ { t } ^ { i } | s _ { t } \right) \rho _ { \phi ^ { - i } } ^ { - i } \left( a ^ { - i } | s _ { t } , a _ { t } ^ { i } \right) \right) \right] . } \end{array}
+$$
+
+Besides the reward term, the objective introduces an additional term of the conditional entropy on the joint policy $\mathcal { H } \left( \pi _ { \theta ^ { i } } ^ { i } \left( a _ { t } ^ { i } \vert s _ { t } \right) \rho _ { \phi ^ { - i } } ^ { - i } \left( a ^ { - i } \vert s _ { t } , a _ { t } ^ { i } \right) \right)$ that potentially promotes the explorations for both the agent $i$ θ φ’s best response and the opponents’ conditional policy. Note that the entropy here is conditioning not only on the state $s _ { t }$ but also on agent $i$ ’s action. Minimizing Eq. 10 gives us:
+
+Theorem 1. The optimal $Q$ -function for agent i that satisfies minimizing Eq. 10 is formulated as:
+
+$$
+Q _ { \pi _ { \theta } } ^ { i } ( s , a ^ { i } ) = \log \int _ { a ^ { - i } } \exp ( \boldsymbol { Q } _ { \pi _ { \theta } } ^ { i } ( s , a ^ { i } , a ^ { - i } ) ) \mathrm { d } a ^ { - i } .
+$$
+
+And the corresponding optimal opponent conditional policy reads:
+
+$$
+\rho _ { \phi ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } ) = { \frac { 1 } { Z } } \exp ( { \mathcal { Q } } _ { \pi _ { \theta } } ^ { i } ( s , a ^ { i } , a ^ { - i } ) - { \mathcal { Q } } _ { \pi _ { \theta } } ^ { i } ( s , a ^ { i } ) )
+$$
+
+Proof. See Appendix C. 
+
+![](images/404263110f079e45e78d9803c8fb76709f564762c09af7bd89d099270c34f449.jpg)  
+Figure 3: Learning paths on the iterated matrix game. a: IGA. b-d: PR2-Q.
+
+Theorem 1 states that the learning of $\rho _ { \phi ^ { - i } } ^ { - i } \left( a ^ { - i } | s , a ^ { i } \right)$ can be further converted to minimizing the $K L$ φ-divergence between the estimated policy $\rho _ { \phi ^ { - i } } ^ { - i }$ and the advantage function: $D _ { \mathrm { K L } } \left( \rho _ { \phi ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } ) \| \exp ( Q ^ { i } ( s , a ^ { i } , a ^ { - i } ) - Q ^ { i } ( s , a ^ { i } ) ) \right)$ . We can obtain a solution to Eq. 12 by mainφtaining two $Q$ -functions, and then iteratively update them. We prove the convergence under self-play when there is one equilibrium. This leads to a fixed-point iteration that resembles value iteration.
+
+Theorem 2. In a symmetric game with only one equilibrium, and the equilibrium meets one of the conditions: 1) the global optimum, i.e. $\mathbb { E } _ { \pi _ { * } } \left[ \hat { Q } _ { t } ^ { i } ( s ) \right] \ : \geq \ : \mathbb { E } _ { \pi } \left[ Q _ { t } ^ { i } ( s ) \right] ;$ ; 2) a saddle point, i.e. $\mathbb { E } _ { \pi _ { * } } \left[ Q _ { t } ^ { i } ( s ) \right] \geq \mathbb { E } _ { \pi ^ { i } } \mathbb { E } _ { \pi _ { * } ^ { - i } } \left[ Q _ { t } ^ { i } ( s ) \right] o r \mathbb { E } _ { \pi _ { * } } \left[ Q _ { t } ^ { i } ( s ) \right] \geq \mathbb { E } _ { \pi _ { * } ^ { i } } \bar { \mathbb { E } } _ { \pi ^ { - i } } \left[ Q _ { t } ^ { i } ( s ) \right] ,$ ; where $Q _ { * }$ and $\pi _ { * }$ are the π π π  π π  π πequilibrium value function and policy, respectively. The PR2 soft value iteration operator defined by:
+
+$$
+\mathcal { T Q } ^ { i } ( s , a ^ { i } , a ^ { - i } ) \triangleq r ^ { i } ( s , a ^ { i } , a ^ { - i } ) + \gamma \mathbb { E } _ { s ^ { \prime } , a ^ { i \prime } \sim p _ { s } , \pi ^ { i } } \left[ \log \int _ { a ^ { - i \prime } } \exp ( \mathcal { Q } ^ { i } ( s ^ { \prime } , a ^ { i \prime } , a ^ { - i \prime } ) ) \mathrm { d } a ^ { - i \prime } \right] ,
+$$
+
+is a contraction mapping.
+
+Proof. See Appendix D. 
+
+# 4.4 SAMPLING IN CONTINUOUS ACTION SPACE
+
+In continuous controls, getting the actions from the opponent policy $\rho _ { \phi ^ { - i } } ^ { - i } \left( a ^ { - i } | s , a ^ { i } \right)$ is challenging. ρφ ,In this work, we follow Haarnoja et al. (2017) to adopt the amortized Stein Variational Gradient Descent (SVGD) (Liu & Wang, 2016; Wang & Liu, 2016) in sampling from the soft Q-function. Compared to MCMC, Amortized SVGD is a computationally-efficient way to estimate $\rho _ { \phi ^ { - i } } ^ { - i } \left( a ^ { - i } | s , a ^ { i } \right)$ . Thanks to SVGD, agent $i$ ρφ ,is able to reason about potential consequences of opponent bavhaviors $\begin{array} { r } { \int _ { a ^ { - i } } \pi _ { \theta ^ { - i } } ^ { - i } \big ( a ^ { - i } | s , a ^ { i } \big ) \breve { Q } ^ { i } \big ( s , a ^ { i } , a ^ { - i } \big ) \mathrm { d } a ^ { - i } } \end{array}$ , and finally find the corresponding best response.
+
+# 5 EXPERIMENTS
+
+We evaluate the performance of PR2 methods on the iterated matrix games, differential games, and particle world environment. Those games can by design have a non-trivial equilibrium that requires certain levels of intelligent reasonings between agents. We compared our algorithm with a series of baselines. In the matrix game, we compare against IGA (Infinitesimal Gradient Ascent) (Singh et al., 2000). In the differential games, the baselines from multi-agent learning algorithms are MASQL (Multi-Agent Soft-Q) (Wei et al., 2018) and MADDPG (Lowe et al., 2017). We also including independent learning algorithms implemented through DDPG (Lillicrap et al., 2015). To compare against traditional method of opponent modeling, we include one baseline that is based on DDPG but with one additional opponent modeling unit that is trained in an online and supervised way to learn the most recent opponent policy, which is then fed into the critic. Similar approach has been implemented by Rabinowitz et al. (2018) in realizing machine theory of mind. Besides, we applied centralized Symplectic Gradient Adjustment (SGA) (Balduzzi et al., 2018) optimization for DDPG agents (DDPG-SGA), which has recently been found to help converge to a local equilibrium quickly.
+
+For the experiment settings, all the policies and $Q$ -functions are parameterized by the MLP with 2 hidden layers, each with 100 units ReLU activation. The sampling network $\xi$ for the $\rho _ { \phi ^ { - i } } ^ { - i }$ in SGVD ξ ρφfollows the standard normal distribution. In the iterated matrix game, we trained all the methods including the baselines for 500 iterations. In the differential game, we trained the agents for 350 iterations with 25 steps per iteration. For the actor-critic methods, we set the exploration noise to 0 1 .in first 1000 steps, and the annealing parameters for PR2-AC and MASQL are set to 0 5 to balance between the exploration and acting as the best response.
+
+![](images/3d07196412fb0aadba22cc270238fa7afb2c8937a06b2201e297e9e817082ee2.jpg)  
+PR2-AC.   
+Figure 4: Max of Two Quadratic Game.-10.0  -10.0
+
+![](images/3c34b3adcbdcd72ba79c0548a17ab610476381c613852364c1cd98759aa8abdf.jpg)  
+Figure 5: The learning path of Agent 1 ( $\mathbf { \dot { X } } - \mathbf { \dot { X } } - \mathbf { \dot { X } }$ -axis) vs. Agent 2 (y-axis).
+
+# 5.1 ITERATED MATRIX GAME
+
+In the matrix game, the payoffs are defined by: $R ^ { 1 } = \left[ \begin{array} { l l } { 0 } & { 3 } \\ { 1 } & { 2 } \end{array} \right]$ , and R2 $R ^ { 2 } = { \left[ \begin{array} { l l } { 3 } & { 2 } \\ { 0 } & { 1 } \end{array} \right] } .$ These exists the only Nash Equilibrium at (0 5 0 5). This game has been intensively investigated in multi. , .agent studies (Bowling & Veloso, 2001a;b). One reason is that in solving the Nash Equilibrium for this game, simply taking simultaneous gradient steps on both agent’s value functions will present the rotational behaviors on the gradient vector field; this leads to an endlessly iterative change of behaviors. Without considering the consequence of one agent’s action on the other agent beforehand, it is challenging for both players to find the equilibrium. Similar issue has been found on training the GANs (Goodfellow et al., 2014; Mescheder et al., 2017)
+
+The results are shown in Fig. 3. As expected, IGA fails to converge to the equilibrium but rotate around the equilibrium point. On the contrary, our method can find precisely the central equilibrium with a fully distributed fashion (see Fig. 3b). The convergence can also be justified by the agents’ policies in Fig. 3c, and the opponent’s policy that is maintained by each agent in Fig. 3d.
+
+# 5.2 DIFFERENTIAL GAME
+
+We adopt the same differential game, the Max of Two Quadratic Game, as Panait et al. (2006); Wei et al. (2018). The agents have continuous action space of $[ - 1 0 , 1 0 ]$ . Each agent’s reward depends on the joint action following the equations: $r ^ { 1 } \left( a ^ { 1 } , a ^ { 2 } \right) = r ^ { 2 } \left( a ^ { 1 } , a ^ { 2 } \right) = \operatorname* { m a x } \left( f _ { 1 } , f _ { 2 } \right)$ where $\begin{array} { r } { f _ { 1 } = 0 . 8 \times [ - ( \frac { a ^ { 1 } + 5 } { 3 } ) ^ { 2 } - ( \frac { a ^ { 2 } + 5 } { 3 } ) ^ { 2 } ] , f _ { 2 } = 1 . 0 \times [ - ( \frac { a ^ { 1 } - 5 } { 1 } ) ^ { 2 } - ( \frac { a ^ { 2 } - 5 } { 1 } ) ^ { 2 } ] + 1 0 } \end{array}$ , ,. The task poses a great .   , .  challenge to general gradient-based algorithms because gradient tends to points to the sub-optimal solution. The reward surface is shown in Fig. 4a; there is a local maximum 0 at $( - 5 , - 5 )$ and a global maximum 10 at $( 5 , 5 )$ ,, with a deep valley staying in the middle. If the agents’ policies are initialized to $( 0 , 0 )$ , (the red starred point) that lies within the basin of the left local maximum, the ,gradient based methods would tend to fail to find the global maximum equilibrium point due to the valley blocking the upper right area. The pathology of finding a suboptimal Nash equilibrium is also called relative over-generalization (Wei & Luke, 2016).
+
+![](images/e05881d34e2841a8ecf88373fbad6314a4c1d965270cfa4617b673ac92f116f5.jpg)  
+Figure 6: Performance of PR2-AC on the Particle World environment. Each bar shows the $0 - 1$ normalized score for agent in cooperative navigation task and the normalized advantage score (agent reward - adversary reward) in a set of competitive tasks. Higher score is better.
+
+We present the results in Fig. 4b, PR2-AC shows superior performance that manages to converge to the global equilibrium, while all the other baselines fall into the local basin on the left, except that the MASQL has small chance to find the optimal point. On top of the convergence result, it is worth noting that as the temperature annealing is required for energy-based RL methods, the learning outcomes of MASQL are extremely sensitive to the way of annealing, i.e. when and how to anneal the temperature to a small value during training is non-trivial. However, our method does not need to tune the the annealing parameter at all because the each agent is acting the best response to the approximated conditional policy, considering all potential consequences of the opponent’s response.
+
+Interestingly, by comparing the learning path in Fig. 4a against Fig. 5(a-e) where the scattered blue dots are the exploration trails at the beginning, we can tell that if the PR2-AC model finds the peak point in joint action space, the agents can quickly go through the shortcut out of the local basin in a clever way, while other algorithms just converge to the local equilibrium. This further justifies the effectiveness and benefits of conducting recursive reasoning with opponents. Apart from testing in the self-play setting, we also test the scenario when the opponent type is different. We pair PR2-AC with all four baseline algorithms in Fig. 5(f-i). Similar result can be found, that is, algorithm that has the function of taking into account the opponents (i.e. DDPG_OM & MADDPG) can converge to the local equilibrium even though not global, while DDPG and MASQL completely fails due to the inborn defect from the independent learning methods.
+
+# 5.3 PARTICLE WORLD ENVIRONMENTS
+
+We further test our method on the multi-state multi-player Particle World Environments (Lowe et al., 2017). This includes four testing scenarios: 1) Cooperative Navigation with 3 agents and 3 landmarks. Agents are collectively rewarded based on the proximity of any agent to each landmark while avoiding collisions; 2) Physical Deception with 1 adversary, 2 good agents, and 2 landmarks. All agents observe the positions of landmarks and other agents. Only one landmark is the true target landmark. Good agents are rewarded based on how close any of them is to the target landmark, and how well they deceive the adversary; 3) Keep-away with 1 agent, 1 adversary, and 1 landmark. Agent is rewarded based on distance to landmark. Adversary is rewarded if it push away the agent from the landmark; 4) Predator-prey with 1 prey agent who moves faster try to run away from 3 adversary predator who move slower but are motivated to catch the prey cooperatively.
+
+The PR2 methods are compared against a series of the centralized MARL methods in Fig. 6. Under the fully-cooperative setting (the left plot), PR2AC achieves the best performance over all baselines, even though it is a decentralized algorithm that does not have access to the exact opponent policies. Under the competitive settings where PR2AC rivals against the a set of adversary baselines, we find that PR2AC learners can beat all the baselines, including DDPG, DDPG-OM, and MASQL. The only exception is MADDPG, as it is suggested by the drop-down arrow. PR2AC performs particularly bad on the physical deception task. We believe it is mainly because the centralized critic can access the full knowledge of the exact policies of PR2-AC, but PR2-AC cannot access the models of its opponents in the reversed way; this could place PR2-AC in an inferior position during testing time as its deceptive strategy has been found out by the opponents already during training.
+
+# 6 CONCLUSION
+
+Inspired by the recursive reasoning capability of human intelligence, in this paper, we introduce a probabilistic recursive reasoning framework for multi-agent RL that follows "I believe that you believe that I believe". We adopt variational Bayes methods to approximate the opponents’ conditional policy, to which each agent finds the best response and then improve their own policy. The training and execution is full decentralized and the resulting algorithms, PR2-Q and PR2-AC, converge in selfplay when there is one Nash equilibrium. Our results on three kinds of testing beds with increasing complexity justify the advantages of learning to reason about the opponents in a recursive manner. In the future, we plan to investigate other approximation methods for the PR2 framework, and test our PR2 algorithm for the coordination task between AI agents such as coordinating autonomous cars before the traffic light.
+
+# REFERENCES
+
+Stefano V Albrecht and Peter Stone. Autonomous agents modelling other agents: A comprehensive survey and open problems. Artificial Intelligence, 258:66–95, 2018.
+
+David Balduzzi, Sebastien Racaniere, James Martens, Jakob Foerster, Karl Tuyls, and Thore Graepel. The mechanics of n-player differentiable games. arXiv preprint arXiv:1802.05642, 2018.
+
+Dipyaman Banerjee and Sandip Sen. Reaching pareto-optimality in prisoner’s dilemma using conditional joint action learning. Autonomous Agents and Multi-Agent Systems, 15(1):91–108, 2007.
+
+Thomas Bolander and Mikkel Birkegaard Andersen. Epistemic planning for single-and multi-agent systems. Journal of Applied Non-Classical Logics, 21(1):9–34, 2011.
+
+Michael Bowling. Convergence and no-regret in multiagent learning. In Advances in neural information processing systems, pp. 209–216, 2005.
+
+Michael Bowling and Manuela Veloso. Convergence of gradient dynamics with a variable learning rate. In ICML, pp. 27–34, 2001a.
+
+Michael Bowling and Manuela Veloso. Rational and convergent learning in stochastic games. In International joint conference on artificial intelligence, volume 17, pp. 1021–1026. Lawrence Erlbaum Associates Ltd, 2001b.
+
+Michael Bowling and Manuela Veloso. Multiagent learning using a variable learning rate. Artificial Intelligence, 136(2):215–250, 2002.
+
+George W Brown. Iterative solution of games by fictitious play. Activity analysis of production and allocation, 13(1):374–376, 1951.
+
+Colin F Camerer, Teck-Hua Ho, and Juin-Kuan Chong. A cognitive hierarchy model of games. The Quarterly Journal of Economics, 119(3):861–898, 2004.
+
+Colin F Camerer, Teck-Hua Ho, and Juin Kuan Chong. A psychological approach to strategic thinking in games. Current Opinion in Behavioral Sciences, 3:157–162, 2015.
+
+Caroline Claus and Craig Boutilier. The dynamics of reinforcement learning in cooperative multiagent systems. AAAI/IAAI, 1998:746–752, 1998.
+
+Bruno C Da Silva, Eduardo W Basso, Ana LC Bazzan, and Paulo M Engel. Dealing with nonstationary environments using context detection. In Proceedings of the 23rd international conference on Machine learning, pp. 217–224. ACM, 2006.
+
+Harmen De Weerd, Rineke Verbrugge, and Bart Verheij. Higher-order theory of mind in negotiations under incomplete information. In International Conference on Principles and Practice of MultiAgent Systems, pp. 101–116. Springer, 2013a.
+
+Harmen De Weerd, Rineke Verbrugge, and Bart Verheij. How much does it help to know what she knows you know? an agent-based simulation study. Artificial Intelligence, 199:67–92, 2013b.
+
+Harmen de Weerd, Rineke Verbrugge, and Bart Verheij. Negotiating with other minds: the role of recursive theory of mind in negotiation with incomplete information. Autonomous Agents and Multi-Agent Systems, 31(2):250–287, 2017.
+
+Daniel C Dennett. Two contrasts: folk craft versus folk science, and belief versus opinion. The future of folk psychology: Intentionality and cognitive science, pp. 135–148, 1991.
+
+Prashant Doshi and Piotr J Gmytrasiewicz. On the difficulty of achieving equilibrium in interactive pomdps. In PROCEEDINGS OF THE NATIONAL CONFERENCE ON ARTIFICIAL INTELLIGENCE, volume 21, pp. 1131. Menlo Park, CA; Cambridge, MA; London; AAAI Press; MIT Press; 1999, 2006.
+
+Prashant Doshi and Piotr J Gmytrasiewicz. Monte carlo sampling methods for approximating interactive pomdps. Journal of Artificial Intelligence Research, 34:297–337, 2009.
+
+Prashant Doshi and Dennis Perez. Generalized point based value iteration for interactive pomdps. In AAAI, pp. 63–68, 2008.
+
+Prashant Doshi, Yifeng Zeng, and Qiongyu Chen. Graphical models for interactive pomdps: representations and solutions. Autonomous Agents and Multi-Agent Systems, 18(3):376, 2009.
+
+Jakob Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. Counterfactual multi-agent policy gradients. arXiv preprint arXiv:1705.08926, 2017.
+
+Jakob Foerster, Richard Y Chen, Maruan Al-Shedivat, Shimon Whiteson, Pieter Abbeel, and Igor Mordatch. Learning with opponent-learning awareness. In Proceedings of the 17th International Conference on Autonomous Agents and MultiAgent Systems, pp. 122–130. International Foundation for Autonomous Agents and Multiagent Systems, 2018.
+
+Roy Fox, Ari Pakman, and Naftali Tishby. Taming the noise in reinforcement learning via soft updates. In Proceedings of the Thirty-Second Conference on Uncertainty in Artificial Intelligence, pp. 202–211. AUAI Press, 2016.
+
+Ya’akov Gal and Avi Pfeffer. A language for modeling agents’ decision making processes in games. In Proceedings of the second international joint conference on Autonomous agents and multiagent systems, pp. 265–272. ACM, 2003.
+
+Ya’akov Gal and Avi Pfeffer. Networks of influence diagrams: a formalism for representing agents’ beliefs and decision-making processes. Journal of Artificial Intelligence Research, 33:109–147, 2008.
+
+Vittorio Gallese and Alvin Goldman. Mirror neurons and the simulation theory of mind-reading. Trends in cognitive sciences, 2(12):493–501, 1998.
+
+Piotr J Gmytrasiewicz and Prashant Doshi. A framework for sequential planning in multi-agent settings. Journal of Artificial Intelligence Research, 24:49–79, 2005.
+
+Piotr J Gmytrasiewicz and Edmund H Durfee. A rigorous, operational formalization of recursive modeling. In ICMAS, pp. 125–132, 1995.
+
+Piotr J Gmytrasiewicz and Edmund H Durfee. Rational coordination in multi-agent environments. Autonomous Agents and Multi-Agent Systems, 3(4):319–350, 2000.
+
+Piotr J Gmytrasiewicz, Edmund H Durfee, and David K Wehe. A decision-theoretic approach to coordinating multi-agent interactions. In IJCAI, volume 91, pp. 63–68, 1991.
+
+Alvin I Goldman et al. Theory of mind. The Oxford handbook of philosophy of cognitive science, pp. 402–424, 2012.
+
+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.
+
+Adam S Goodie, Prashant Doshi, and Diana L Young. Levels of theory-of-mind reasoning in competitive games. Journal of Behavioral Decision Making, 25(1):95–108, 2012.
+
+Alison Gopnik and Henry M Wellman. Why the child’s theory of mind really is a theory. Mind & Language, 7(1-2):145–171, 1992.
+
+Robert M Gordon. Folk psychology as simulation. Mind & Language, 1(2):158–171, 1986.
+
+Amy Greenwald, Keith Hall, and Roberto Serrano. Correlated q-learning. In ICML, volume 3, pp. 242–249, 2003.
+
+Tuomas Haarnoja, Haoran Tang, Pieter Abbeel, and Sergey Levine. Reinforcement learning with deep energy-based policies. arXiv preprint arXiv:1702.08165, 2017.
+
+John C Harsanyi. Bargaining in ignorance of the opponent’s utility function. Journal of Conflict Resolution, 6(1):29–38, 1962.
+
+John C Harsanyi. Games with incomplete information played by bayesian players, i–iii part i. the basic model. Management science, 14(3):159–182, 1967.
+
+He He, Jordan Boyd-Graber, Kevin Kwok, and Hal Daumé III. Opponent modeling in deep reinforcement learning. In International Conference on Machine Learning, pp. 1804–1813, 2016.
+
+Junling Hu and Michael P Wellman. Nash q-learning for general-sum stochastic games. Journal of machine learning research, 4(Nov):1039–1069, 2003.
+
+Michael I Jordan, Zoubin Ghahramani, Tommi S Jaakkola, and Lawrence K Saul. An introduction to variational methods for graphical models. Machine learning, 37(2):183–233, 1999.
+
+Brenden M Lake, Tomer D Ullman, Joshua B Tenenbaum, and Samuel J Gershman. Building machines that learn and think like people. Behavioral and Brain Sciences, 40, 2017.
+
+Sergey Levine. Reinforcement learning and control as probabilistic inference: Tutorial and review. arXiv preprint arXiv:1805.00909, 2018.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+Michael L Littman. Markov games as a framework for multi-agent reinforcement learning. In Machine Learning Proceedings 1994, pp. 157–163. Elsevier, 1994.
+
+Michael L Littman. Friend-or-foe q-learning in general-sum games. In ICML, volume 1, pp. 322–328, 2001.
+
+Qiang Liu and Dilin Wang. Stein variational gradient descent: A general purpose bayesian inference algorithm. In Advances In Neural Information Processing Systems, pp. 2378–2386, 2016.
+
+Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, OpenAI Pieter Abbeel, and Igor Mordatch. Multi-agent actor-critic for mixed cooperative-competitive environments. In Advances in Neural Information Processing Systems, pp. 6379–6390, 2017.
+
+Lars Mescheder, Sebastian Nowozin, and Andreas Geiger. The numerics of gans. In Advances in Neural Information Processing Systems, pp. 1825–1835, 2017.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015.
+
+Christian J Muise, Vaishak Belle, Paolo Felli, Sheila A McIlraith, Tim Miller, Adrian R Pearce, and Liz Sonenberg. Planning over multi-agent epistemic states: A classical planning approach. In AAAI, pp. 3327–3334, 2015.
+
+Liviu Panait, Sean Luke, and R Paul Wiegand. Biasing coevolutionary search for optimal multiagent behaviors. IEEE Transactions on Evolutionary Computation, 10(6):629–645, 2006.
+
+Peng Peng, Ying Wen, Yaodong Yang, Quan Yuan, Zhenkun Tang, Haitao Long, and Jun Wang. Multiagent bidirectionally-coordinated nets: Emergence of human-level coordination in learning to play starcraft combat games. arXiv preprint arXiv:1703.10069, 2017.
+
+Brad E Pfeiffer and David J Foster. Hippocampal place-cell sequences depict future paths to remembered goals. Nature, 497(7447):74, 2013.
+
+David Premack and Guy Woodruff. Does the chimpanzee have a theory of mind? Behavioral and brain sciences, 1(4):515–526, 1978.
+
+David V Pynadath and Stacy C Marsella. Psychsim: Modeling theory of mind with decision-theoretic agents. In IJCAI, volume 5, pp. 1181–1186, 2005.
+
+Neil C Rabinowitz, Frank Perbet, H Francis Song, Chiyuan Zhang, SM Eslami, and Matthew Botvinick. Machine theory of mind. arXiv preprint arXiv:1802.07740, 2018.
+
+Nikolaus Robalino and Arthur Robson. The economic approach to ’theory of mind’. Phil. Trans. R. Soc. B, 367(1599):2224–2233, 2012.
+
+Sven Seuken and Shlomo Zilberstein. Formal models and algorithms for decentralized decision making under uncertainty. Autonomous Agents and Multi-Agent Systems, 17(2):190–250, 2008.
+
+Lloyd S Shapley. Stochastic games. Proceedings of the national academy of sciences, 39(10): 1095–1100, 1953.
+
+Yoav Shoham, Rob Powers, Trond Grenager, et al. If multi-agent learning is the answer, what is the question? Artificial Intelligence, 171(7):365–377, 2007.
+
+Satinder Singh, Michael Kearns, and Yishay Mansour. Nash convergence of gradient dynamics in general-sum games. In Proceedings of the Sixteenth conference on Uncertainty in artificial intelligence, pp. 541–548. Morgan Kaufmann Publishers Inc., 2000.
+
+Edward Jay Sondik. The optimal control of partially observable markov processes. Technical report, STANFORD UNIV CALIF STANFORD ELECTRONICS LABS, 1971.
+
+Ekhlas Sonu and Prashant Doshi. Scalable solutions of interactive pomdps using generalized and bounded policy iteration. Autonomous Agents and Multi-Agent Systems, 29(3):455–494, 2015.
+
+Richard S Sutton, Andrew G Barto, et al. Reinforcement learning: An introduction. MIT press, 1998.
+
+Richard 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.
+
+Edward C Tolman. Cognitive maps in rats and men. Psychological review, 55(4):189, 1948.
+
+Karl Tuyls and Gerhard Weiss. Multiagent learning: Basics, challenges, and prospects. Ai Magazine, 33(3):41, 2012.
+
+Friedrich Burkhard Von Der Osten, Michael Kirley, and Tim Miller. The minds of many: opponent modelling in a stochastic game. In Proceedings of the 25th International Joint Conference on Artificial Intelligence (IJCAI), AAAI Press, pp. 3845–3851, 2017.
+
+Dilin Wang and Qiang Liu. Learning to draw samples: With application to amortized mle for generative adversarial learning. arXiv preprint arXiv:1611.01722, 2016.
+
+Ermo Wei and Sean Luke. Lenient learning in independent-learner stochastic cooperative games. The Journal of Machine Learning Research, 17(1):2914–2955, 2016.
+
+Ermo Wei, Drew Wicke, David Freelan, and Sean Luke. Multiagent soft q-learning. AAAI, 2018.
+
+Yingce Xia, Tao Qin, Wei Chen, Jiang Bian, Nenghai Yu, and Tie-Yan Liu. Dual supervised learning. arXiv preprint arXiv:1707.00415, 2017.
+
+Yaodong Yang, Rui Luo, Minne Li, Ming Zhou, Weinan Zhang, and Jun Wang. Mean field multiagent reinforcement learning. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 5571–5580, Stockholmsmassan, Stockholm Sweden, 10–15 Jul 2018. PMLR.
+
+# APPENDIX
+
+A DECENTRALIZED MULTI-AGENT PROBABILISTIC RECURSIVE REASONING ALGORITHMS
+
+Algorithm 1 gives the step by step learning procedures for PR2-AC algorithm.
+
+<table><tr><td colspan="2">Algorithm 1: Multi-Agent Probabilistic Recursive Reasoning Actor Critic (PR2-AC).</td></tr><tr><td colspan="2">Result: Policy:πi, Opponent Recursive Reasoning: p-i(a-i |s,ai). 1 Initialize parameters 0i,Φ-i,ωi for each agent i,and the random process N for action exploration</td></tr><tr><td colspan="2">2 Assign target parameters of joint action Q-function: ωi ← ωi,and target policy parameter: 0i ←</td></tr><tr><td colspan="2">3 Di← empty replay buffer for each agent.</td></tr><tr><td colspan="2"></td></tr><tr><td colspan="2">4 for each episode do 5</td></tr><tr><td colspan="2">Initialize random process N for action exploration.</td></tr><tr><td colspan="2">6 for each step t do</td></tr><tr><td colspan="2">Given the current s,for each agent i, select action ai = μii(s) + Nt; 7</td></tr><tr><td colspan="2">Take the joint action (ai,a-i) and observe own reward ri and new state s&#x27;; 8</td></tr><tr><td colspan="2">9 Add the tuple (s,ai,a-i,ri,s&#x27;) in corresponding replay buffer Di;</td></tr><tr><td colspan="2">10 s↑s&#x27;; 11 for each agent i do</td></tr><tr><td colspan="2">12</td></tr><tr><td colspan="2">Sample a random mini-batch {(s,aj,aji,rj,sj)}=0 from D&#x27;; Get a&#x27; = μi for each state sj ; 13</td></tr><tr><td colspan="2">Sample{(s,)foreach&#x27; ad; 14 Sety²=+Y∑=Qu(s&#x27;,a,)；</td></tr><tr><td colspan="2">15</td></tr><tr><td colspan="2">Update the critic by minizingthelos(ω)=∑(y-Qu(sj,))²; 16 17 Update the actor using the sampled policy gradient:</td></tr><tr><td colspan="2"></td></tr><tr><td colspan="2">N M 1 eip（sj）Va 1 eini Q(sj,a,aj); N M j=0 k=0 18 19</td></tr><tr><td colspan="2">Compute 4p−i using empirical estimation:</td></tr><tr><td colspan="2">△(-s,a)[((s)）Q²(s)</td></tr><tr><td colspan="2">+(a(s))],</td></tr><tr><td colspan="2">where κ is a kernel function;</td></tr><tr><td colspan="2">20 21 Compute empirical gradient V$-i Jp-i ;</td></tr><tr><td colspan="2">Update $-i according to V-i Jp-i; 22</td></tr><tr><td colspan="2">23 end 24 Update target network parameters for each agent i:</td></tr><tr><td colspan="2">25 θ²&#x27;←20i+(1-λ)θi&#x27;;</td></tr><tr><td colspan="2"></td></tr><tr><td colspan="2">w←λw²+(1-1)ωi&#x27;;</td></tr><tr><td colspan="2">end 27 end</td></tr></table>
+
+The Algorithm 2 shows the variant of Decentralized Multi-Agent Probabilistic Recursive Reasoning. We can simply approximate the $\rho ^ { - i } ( a ^ { - i } | s , a ^ { i } )$ by counting: $\bar { \rho ^ { - i } } ( a ^ { - i } | s , a ^ { i } ) = C ( a ^ { i } , a ^ { - i } , s ) / C ( a ^ { i } , s )$ ρ ,in tabular if the state-action space is small, where $C$ ρ , , , / ,is the counting function. It this case, an agent
+
+# Algorithm 2: Multi-Agent Probabilistic Recursive Reasoning $Q$ -Learning (PR2-Q).
+
+x Result: Policy: $\pi ^ { i }$ , Opponent Recursive Reasoning: $\rho ^ { - i } ( a ^ { - i } | s , a ^ { i } )$ .
+
+2 Initialize $\mathcal { Q } ^ { i } ( s , a ^ { i } , a ^ { - i } )$ arbitrarily, set $\alpha$ ρas the learning rate, $\gamma$ ,as discount factor; , ,3 while not converge do
+
+Given the current $s$ , calculate the opponent best response $\rho ^ { - i } ( a ^ { - i } | s , a ^ { i } )$ according to:
+
+$$
+\rho ^ { - i } ( a ^ { - i } | s , a ^ { i } ) = \frac { 1 } { Z } \exp ( { \cal Q } ^ { i } ( s , a ^ { i } , a ^ { - i } ) - { \cal Q } ^ { i } ( s , a ^ { i } ) )
+$$
+
+Select and sample action $a ^ { i }$ based on the Recursive Reasoning $\rho ^ { - i } ( a ^ { - i } | s , a ^ { i } )$ ;
+
+$$
+\mathrm { s o f t m a x } ( \int _ { a ^ { - i } } \rho ^ { - i } ( a ^ { - i } | s , a ^ { i } ) Q ^ { i } ( s , a ^ { i } , a ^ { - i } ) )
+$$
+
+Observing joint-action $( a ^ { i } , a ^ { - i } )$ , reward $r ^ { i }$ , and next state $s ^ { \prime }$ ;
+
+$$
+\begin{array} { c } { { Q ^ { i } ( s , a ^ { i } , a ^ { - i } ) \xleftarrow { } { } \textstyle \left( 1 - \alpha \right) Q ^ { i } ( s , a ^ { i } , a ^ { - i } ) + \alpha ( r ^ { i } + \gamma V ^ { i } ( s ^ { \prime } ) ) } } \\ { { Q ^ { i } ( s , a ^ { i } ) \xleftarrow { } { } \textstyle \left( 1 - \alpha \right) Q ^ { i } ( s , a ^ { i } ) + \alpha ( r ^ { i } + \gamma V ^ { i } ( s ^ { \prime } ) ) } } \end{array}
+$$
+
+where,
+
+$$
+V ^ { i } ( s ) = \operatorname* { m a x } _ { a ^ { i } } \int _ { a ^ { - i } } \rho ^ { - i } ( a ^ { - i } | s , a ^ { i } ) Q ^ { i } ( s , a ^ { i } , a ^ { - i } )
+$$
+
+10 end
+
+only needs to learn a joint action $Q$ -function, and if the game is static, our method would degenerate to Conditional Joint Action Learning (CJAL) (Banerjee & Sen, 2007).
+
+B MULTI-AGENT POLICY GRADIENT
+
+# B.1 MULTI-AGENT NON-CORRELATED POLICY GRADIENT
+
+Since $\pi _ { \theta } \left( a ^ { i } , a ^ { - i } | s \right) = \pi _ { \theta ^ { i } } ^ { i } \left( a ^ { i } \right) \pi _ { \theta ^ { - i } } ^ { - i } \left( a ^ { - i } | , a ^ { i } \right) = \pi _ { \theta ^ { - i } } ^ { - i } \left( a ^ { - i } | s \right) \pi _ { \theta ^ { i } } ^ { i } \left( a ^ { i } | s , a ^ { - i } \right) , \pi _ { \theta } \left( a ^ { i } , a ^ { - i } | s \right) = \pi _ { \theta ^ { - i } } ^ { i } \left( a ^ { - i } | s \right) \pi _ { \theta ^ { i } } ^ { i } \left( a ^ { i } | s , a ^ { - i } \right) .$ can be πθ ,factorized as $\pi _ { \theta ^ { i } } ^ { i } ( a ^ { i } | s ) \pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s )$ if $a ^ { i }$ ,and $a ^ { - i }$ πθ πθ , πθ ,are non-correlated. We follow the policy gradient πθ πθformulation (Sutton et al., 2000; Wei et al., 2018) using Leibniz integral rule and Fubini’s theorem which can give us Multi-Agent Non-correlated Policy Gradient:
+
+$$
+\begin{array} { r l } & { \eta ^ { i } = \displaystyle \int _ { s } \int _ { a ^ { i } } \int _ { a ^ { - i } } \pi ( a ^ { i } , a ^ { - i } | s ) { \mathcal Q } ^ { i } ( s , a ^ { i } , a ^ { - i } ) \mathrm { d } a ^ { - i } \mathrm { d } a ^ { i } \mathrm { d } s } \\ & { \quad = \displaystyle \int _ { s } \int _ { a ^ { i } } \int _ { a ^ { - i } } \pi ^ { i } ( a ^ { i } | s ) \pi ^ { - i } ( a ^ { - i } | s ) { \mathcal Q } ^ { i } ( s , a ^ { i } , a ^ { - i } ) \mathrm { d } a ^ { - i } \mathrm { d } a ^ { i } \mathrm { d } s } \\ & { \quad = \displaystyle \int _ { s } \int _ { a ^ { i } } \pi ^ { i } ( a ^ { i } | s ) \int _ { a ^ { - i } } \pi ^ { - i } ( a ^ { - i } | s ) { \mathcal Q } ^ { i } ( s , a ^ { i } , a ^ { - i } ) \mathrm { d } a ^ { - i } \mathrm { d } a ^ { i } \mathrm { d } s . } \end{array}
+$$
+
+Suppose the $\pi ^ { i } ( a ^ { i } )$ is parameterized by $\theta ^ { i }$ , and we apply the gradient over the $\eta ^ { i }$ :
+
+$$
+\begin{array} { r l } & { \nabla _ { \theta ^ { i } } \eta ^ { i } = \displaystyle \int _ { s } \int _ { a ^ { i } } \nabla _ { \theta ^ { i } } \pi _ { \theta _ { i } } ^ { i } ( a ^ { i } | s ) \int _ { a ^ { - i } } \pi ^ { - i } ( a ^ { - i } | s ) Q ^ { i } ( s , a ^ { i } , a ^ { - i } ) \mathrm { d } a ^ { - i } \mathrm { d } a ^ { i } \mathrm { d } s } \\ & { \quad \quad \quad = \mathbb { E } _ { s \sim p , a ^ { i } \sim \pi ^ { i } } [ \nabla _ { \theta ^ { i } } \log \pi ^ { i } ( a ^ { i } | s ) \int _ { a ^ { - i } } \pi ^ { - i } ( a ^ { - i } | s ) Q ^ { i } ( s , a ^ { i } , a ^ { - i } ) \mathrm { d } a ^ { - i } ] . } \end{array}
+$$
+
+In practice, off-policy is more data-efficient. In MADDPG (Lowe et al., 2017) and COMA (Foerster et al., 2017), the replay buffer is introduced in a centralized deterministic actor-critic method for off-policy training. They apply batch sampling to the centralized critic which gives the joint-action $Q$ -values:
+
+$$
+\nabla _ { \theta ^ { i } } \eta ^ { i } = \mathbb { E } _ { s , a ^ { i } , a ^ { - i } \sim D } [ \nabla _ { \theta ^ { i } } \mu _ { \theta ^ { i } } ^ { i } ( a ^ { i } | s ) \nabla _ { a ^ { i } } Q ^ { i } ( s , a ^ { i } , a ^ { - i } ) | _ { a ^ { i } = \mu ^ { i } ( s ) } ] .
+$$
+
+# B.2 MULTI-AGENT RECURSIVE REASONING POLICY GRADIENT
+
+Proposition 1. In a stochastic game, under the recursive reasoning framework defined by Eq. 3, the update rule for the multi-agent recursive reasoning policy gradient method can be devised as follows:
+
+$$
+\nabla _ { \theta ^ { i } } \eta ^ { i } = \mathbb { E } _ { s \sim p , a ^ { i } \sim \pi ^ { i } } \left[ \nabla _ { \theta ^ { i } } \log \pi _ { \theta ^ { i } } ^ { i } ( a ^ { i } | s ) \int _ { a ^ { - i } } \pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } ) Q ^ { i } ( s , a ^ { i } , a ^ { - i } ) \mathrm { d } a ^ { - i } \right] .
+$$
+
+Proof: As following.
+
+If we apply the chain rule to factorize the joint policy to: $\pi _ { \theta } ( a ^ { i } , a ^ { - i } | s ) = \pi _ { \theta ^ { i } } ^ { i } ( a ^ { i } | s ) \pi _ { \theta ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } ) .$ πθ ,Then, we can have multi-agent recursive reasoning objective function as:
+
+$$
+\begin{array} { r l } & { \eta ^ { i } = \displaystyle \int _ { s } \int _ { a ^ { i } } \int _ { a ^ { - i } } \pi ( a ^ { i } , a ^ { - i } | s ) { \mathcal Q } ^ { i } ( a ^ { i } , a ^ { - i } ) \mathrm { d } a ^ { - i } \mathrm { d } a ^ { i } \mathrm { d } s } \\ & { \quad = \displaystyle \int _ { s } \int _ { a ^ { i } } \pi ^ { i } ( a ^ { i } | s ) \int _ { a ^ { - i } } \pi ^ { - i } ( a ^ { - i } | s , a ^ { i } ) { \mathcal Q } ^ { i } ( s , a ^ { i } , a ^ { - i } ) \mathrm { d } a ^ { - i } \mathrm { d } a ^ { i } \mathrm { d } s . } \end{array}
+$$
+
+Compare to Eq. 14, $a ^ { - i }$ in Eq. 18 is additionally conditioned on $a ^ { i }$ . We introduce agent $i ^ { \prime }$ a action $a ^ { i }$ into other agents’s policies, leading to $\pi ^ { - i } \dot { ( } a ^ { - i } | s , a ^ { i } )$ . We now compute the policy gradient π ,analytically. Following the single agent Policy Gradient Theorem with Leibniz integral rule and Fubini’s theorem, we get the multi-Agent Recursive Reasoning Policy Gradient:
+
+$$
+\nabla _ { \theta ^ { i } } \eta ^ { i } = \mathbb E _ { s \sim p , a ^ { i } \sim \pi ^ { i } } \big [ \nabla _ { \theta ^ { i } } \log \pi ^ { i } ( a ^ { i } | s ) \int _ { a ^ { - i } } \pi ^ { - i } ( a ^ { - i } | s , a ^ { i } ) Q ^ { i } ( s , a ^ { i } , a ^ { - i } ) \mathrm { d } a ^ { - i } \big ] .
+$$
+
+However, in practice, the agent may not get access to other agents’ policies. We need to infer the other agents’ policies. We let $\rho _ { \phi _ { - i } } ^ { - i } ( \stackrel { \bullet } { a } ^ { - i } | s , \stackrel { \smile } { a } ^ { i } )$ denotes the parameterized opponent conditional policy of agent $i$ φto approximate other agents policies, i.e, $\pi ^ { - i } ( a ^ { - i } | s , a ^ { i } )$ . Then we have Decentralized πMulti-Agent Recursive Reasoning Policy Gradient comes as:
+
+$$
+\begin{array} { r l } & { \nabla _ { \theta ^ { i } } \eta ^ { i } \approx \mathbb E _ { s \sim p , a ^ { i } \sim \pi ^ { i } } \bigl [ \nabla _ { \theta ^ { i } } \log \pi _ { \theta ^ { i } } ^ { i } \bigl ( a ^ { i } | s \bigr ) \int _ { a ^ { - i } } \rho _ { \phi _ { - i } } ^ { - i } \bigl ( a ^ { - i } | s , a ^ { i } \bigr ) Q ^ { i } ( s , a ^ { i } , a ^ { - i } ) \mathrm { d } a ^ { - i } \bigr ] } \\ & { \qquad = \mathbb E _ { s \sim p , a ^ { i } \sim \pi ^ { i } } \bigl [ \nabla _ { \theta ^ { i } } \log \pi _ { \theta ^ { i } } ^ { i } \bigl ( a ^ { i } | s \bigr ) Q _ { \rho _ { \theta _ { - i } } ^ { - i } } ^ { i } \bigr ( s , a ^ { i } \bigr ) \bigr ] . } \end{array}
+$$
+
+In Eq. 20, the gradient for agent $i$ is scaled by $\begin{array} { r } { Q _ { \rho _ { \phi _ { - i } } ^ { - i } } ^ { i } \left( s , a ^ { i } \right) = \int _ { a ^ { - i } } \rho _ { \phi _ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } ) Q ^ { i } ( s , a ^ { i } , a ^ { - i } ) \mathrm { d } a ^ { - i } . } \end{array}$ The trajectories generated by updated policy would help to train $\rho _ { \phi _ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } )$ and $\mathcal { Q } ^ { i } ( s , a ^ { i } , a ^ { - i } )$ . φThese steps form a Expectation-Maximization style learning procedures: first, fix $\rho _ { \phi _ { - i } } ^ { - i }$ and $\mathcal { Q } ^ { i } ( s , a ^ { i } , a ^ { - i } )$ to improve $\pi _ { \theta ^ { i } } ^ { i } ( a ^ { i } | s )$ ; then, improve $\rho _ { \phi _ { - i } } ^ { - i }$ and $\mathcal { Q } ^ { i } ( s , a ^ { i } , a ^ { - i } )$ φ by the trajectories generated by $\pi _ { \theta ^ { i } } ^ { i } ( a ^ { i } | s )$ θ φ. Furthermore, since PR2 method do not require opponents’ actual private policies, πθDecentralized Multi-Agent Recursive Reasoning Policy Gradient can be decoupled from other agents’ on-policies or target policies. In other words, the training can be conducted in an off-policy fashion by sampling mini-batches from the memory buffer $D$ with the help of the learned $\hat { \rho } _ { \phi _ { - i } } ^ { - i } ( \stackrel { . } { a } ^ { - i } | s , a ^ { i } )$ from $\mathcal { Q } ^ { i } ( s , a ^ { i } , a ^ { - i } )$ . 
+
+C OPPONENT CONDITIONAL POLICY INFERENCE VIA OPTIMAL TRAJECTORY
+
+Theorem 1. The optimal $Q$ -function for agent i that satisfies minimizing Eq. 10 is formulated as:
+
+$$
+Q _ { \pi _ { \theta } } ^ { i } ( s , a ^ { i } ) = \log \int _ { a ^ { - i } } \exp ( \boldsymbol { Q } _ { \pi _ { \theta } } ^ { i } ( s , a ^ { i } , a ^ { - i } ) ) \mathrm { d } a ^ { - i } .
+$$
+
+And the corresponding optimal opponent conditional policy reads:
+
+$$
+\rho _ { \phi ^ { - i } } ^ { - i } ( a ^ { - i } | s , a ^ { i } ) = { \frac { 1 } { Z } } \exp ( { \mathcal { Q } } _ { \pi _ { \theta } } ^ { i } ( s , a ^ { i } , a ^ { - i } ) - { \mathcal { Q } } _ { \pi _ { \theta } } ^ { i } ( s , a ^ { i } ) )
+$$
+
+Proof. As following.
+
+Follow the proof in Levine (2018); Haarnoja et al. (2017), we first give the overall distribution by:
+
+$$
+p ( \tau ) = [ p ( s _ { 1 } ) \prod _ { t = 1 } ^ { T } p ( s _ { t + 1 } | s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) ] \exp ( \sum _ { t = 1 } ^ { T } r ^ { i } ( s _ { t } , a _ { t } , a _ { t } ^ { - i } ) ) .
+$$
+
+We can adopt an optimization-based approach to approximate the opponent conditional policy, in which case the goal is to fit an approximation $\pi ( a _ { t } ^ { i } , \tilde { a _ { t } ^ { - i } } | s _ { t } ) \approx \pi ^ { i } ( a _ { t } ^ { i } | \tilde { s _ { t } } ) \rho ^ { - i } ( a _ { t } ^ { - i } | s _ { t } , a _ { t } ^ { i } )$ such that the trajectory distribution,
+
+$$
+\hat { p } ( \tau ) = p ( s _ { 1 } ) \prod _ { t = 1 } ^ { T } p ( s _ { t + 1 } | s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) \pi _ { \theta ^ { i } } ^ { i } ( a _ { t } ^ { i } | s _ { t } ) \rho _ { \theta ^ { - i } } ^ { - i } ( a _ { t } ^ { - i } | s _ { t } , a _ { t } ^ { i } ) ,
+$$
+
+has high likelihood to be observed. In the case of exact inference, as derived in the previous section, $D _ { \mathrm { K L } } ( \bar { \hat { p } } ( \tau ) \lVert p ( \tau ) ) = 0$ . We can therefore view the inference process as minimizing the $K L$ -divergence:
+
+$$
+D _ { \mathrm { K L } } \big ( \hat { p } ( \tau ) \lVert p ( \tau ) \big ) = - \mathbb { E } _ { \tau \sim \hat { p } ( \tau ) } [ \log p ( \tau ) - \log \hat { p } ( \tau ) ] .
+$$
+
+Negating both sides and substituting, we get:
+
+$$
+\begin{array} { r l } { - D _ { \mathrm { K L } } ( \hat { \rho } ( \tau ) \| p ( \tau ) ) = } & { \mathbb { E } _ { \tau \sim \hat { \phi } ( \tau ) } \| \mathrm { B o g } ( p ( s _ { \tau } ) ) + \displaystyle \sum _ { t = 1 } ^ { T } ( \log p ( \hat { x } _ { t + 1 } | s _ { t } , a _ { t } , a _ { t } ^ { - t } ) + r ^ { t } ( s _ { t } , a _ { t } ^ { t } , a _ { t } ^ { - t } ) ) } \\ & { - \log p ( s _ { \tau } ) - \displaystyle \sum _ { t = 1 } ^ { T } ( \log p ( s _ { t + 1 } | s _ { t } , a _ { t } ^ { t } , a _ { t } ^ { - t } ) + \log \pi ( a _ { t } ^ { t } , a _ { t } ^ { - t } | s _ { t } ) ) \| } \\ & { - \displaystyle \sum _ { t = 1 } ^ { T } ( \log p ( s _ { t + 1 } | s _ { t } , a _ { t } ^ { t } , a _ { t } ^ { - t } ) + \log \pi ( a _ { t } ^ { t } , a _ { t } ^ { t } | s _ { t } ) ) } \\ & { = \mathbb { E } _ { \tau \sim \hat { \phi } ( \tau ) } \| \displaystyle \sum _ { t = 1 } ^ { T } r ^ { t } ( s _ { t } , a _ { t } ^ { t } , a _ { t } ^ { - t } ) - \log \pi ( a _ { t } ^ { t } , a _ { t } ^ { - t } | s _ { t } ) \| } \\ & { = \displaystyle \sum _ { t = 1 } ^ { T } \mathbb { E } _ { \tau \to t } \frac { 1 } { ( s _ { t } , a _ { t } ^ { t } , a _ { t } ^ { t - 1 } ) \sim \hat { \phi } ( s _ { t + 1 } , a _ { t } ^ { t - t } ) } \| r ^ { t } ( s _ { t } , a _ { t } ^ { t } , a _ { t } ^ { - t } ) - \log \pi ( a _ { t } ^ { t } , a _ { t } ^ { - t } | s _ { t } ) \| } \\ &  - \displaystyle \sum _ { t = 1 } ^ { T } \mathbb { E } _ { \tau \to t } \frac { 1 } { ( s _ { t } , a _ { t } ^ { t } , a _ { t } ^ { t } , r ^ { t } ) \sim \hat { \phi } ( s _ { t + 1 } , a _ { t } ^ { t } , a _ { t } ^ { t - t } ) \| } \\ &  - \displaystyle \sum _ { t = 1 } ^ { T } \mathbb { E }  \end{array}
+$$
+
+where $\mathcal { H }$ is the entropy term. In the recursive case, we can rewrite the objective as follows:
+
+$$
+Q ^ { i } ( s , a ^ { i } ) = \log \int _ { a ^ { - i } } \exp ( Q ^ { i } ( s , a ^ { i } , a ^ { - i } ) ) \mathrm { d } a ^ { - i } .
+$$
+
+This corresponds to a standard bellman backup with a soft maximization for the value function. choosing optimal opponent recursive reasoning policy
+
+$$
+\rho ^ { - i } ( a ^ { - i } | s , a ^ { i } ) = \frac { 1 } { Z } \exp ( { \cal Q } ^ { i } ( s , a ^ { i } , a ^ { - i } ) - { \cal Q } ^ { i } ( s , a ^ { i } ) ) .
+$$
+
+Then we can have the objective function:
+
+$$
+\begin{array} { r l } & { J ^ { i } \big ( \phi ^ { - i } \big ) = \displaystyle \sum _ { t = 1 } ^ { T } \mathbb { E } _ { ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) \sim \hat { p } ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) } \big [ r ^ { i } ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) } \\ & { \qquad + \mathcal { H } \big ( \rho _ { \phi ^ { - i } } ^ { - i } ( a _ { t } ^ { - i } | s _ { t } , a _ { t } ^ { i } ) \big ) + \mathcal { H } \big ( \pi _ { \theta ^ { i } } ^ { i } ( a _ { t } ^ { i } | s _ { t } ) \big ) \big ] . } \end{array}
+$$
+
+Then the gradient is then given by:
+
+$$
+\begin{array} { r l } & { \nabla _ { \phi ^ { - i } } J ^ { i } ( \phi ^ { - i } ) = \displaystyle \sum _ { t = 1 } ^ { T } \mathbb { E } _ { ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) \sim p ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) } [ \nabla _ { \phi ^ { - i } } \log \rho _ { \phi ^ { - i } } ^ { - i } ( a _ { t } ^ { - i } | s _ { t } , a _ { t } ^ { i } ) ( \displaystyle \sum _ { t ^ { \prime } = t } ^ { T } r ^ { i } ( s _ { t ^ { \prime } } , a _ { t ^ { \prime } } ^ { i } , a _ { t ^ { \prime } } ^ { - i } ) ] } \\ & { \qquad + \nabla _ { \phi ^ { - i } } \displaystyle \sum _ { t = 1 } ^ { T } \mathbb { E } _ { ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) \sim p ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) } [ \mathcal { H } ( \rho _ { \phi ^ { - i } } ^ { - i } ( a _ { t } ^ { - i } | s _ { t } , a _ { t } ^ { i } ) ) + \mathcal { H } ( \pi _ { \theta ^ { i } } ^ { i } ( a _ { t } ^ { i } | s _ { t } ) ) ] . } \end{array}
+$$
+
+The gradient of the entropy terms is given by:
+
+$$
+\begin{array} { r l } & { \nabla _ { \phi ^ { - i } } \mathcal { H } ( \rho _ { \phi ^ { - i } } ^ { - i } ) = - \nabla _ { \phi } \mathbb { E } _ { ( s _ { t } , a _ { t } ^ { i } ) \sim p ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) } [ \mathbb { E } _ { a _ { t } ^ { - i } \sim \rho _ { \phi ^ { - i } } ^ { - i } ( a _ { t } ^ { - i } \mid s _ { t } , a _ { t } ^ { i } ) } [ \log \rho _ { \phi ^ { - i } } ^ { - i } ( a _ { t } ^ { - i } | s _ { t } , a _ { t } ^ { i } ) ] ] } \\ & { \qquad = - \mathbb { E } _ { ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) \sim p ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) } [ \nabla _ { \phi } \log \rho _ { \phi ^ { - i } } ^ { - i } ( a _ { t } ^ { - i } | s _ { t } , a _ { t } ^ { i } ) ( 1 + \log \rho _ { \phi ^ { - i } } ^ { - i } ( a _ { t } ^ { - i } | s _ { t } , a _ { t } ^ { i } ) ] . } \end{array}
+$$
+
+We can do the same for $\nabla _ { \phi ^ { - i } } \mathcal { H } ( \pi _ { \theta ^ { i } } ^ { i } )$ , and substitute these back we have:
+
+$$
+\begin{array} { r l r } & { } & { \nabla _ { \phi ^ { - i } } J ^ { i } \big ( \phi ^ { - i } \big ) = \displaystyle \sum _ { t = 1 } ^ { T } \mathbb { E } _ { ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) \sim p ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) } [ \nabla _ { \phi ^ { - i } } \log \rho _ { \phi ^ { - i } } ^ { - i } ( a _ { t } ^ { - i } | s _ { t } , a _ { t } ^ { i } ) } \\ & { } & { \displaystyle ( \sum _ { t ^ { \prime } = t } ^ { T } r ^ { i } \big ( s _ { t ^ { \prime } } , a _ { t ^ { \prime } } ^ { i } , a _ { t ^ { \prime } } ^ { - i } \big ) - \log \rho _ { \phi ^ { - i } } ^ { - i } ( a _ { t ^ { \prime } } ^ { - i } | s _ { t } , a _ { t ^ { \prime } } ^ { i } ) - \log \pi _ { \theta ^ { i } } ^ { i } ( a _ { t } ^ { i } | s _ { t } ) - 1 ) ] . } \end{array}
+$$
+
+The $- 1$ comes from the derivative of the entropy terms, and replacing $- 1$ with a state and self-action dependent baseline $b ( s _ { t ^ { \prime } } , a _ { t ^ { \prime } } ^ { i } )$ we can obtain the approximated gradient for $\phi$ :
+
+$$
+\begin{array} { r l } & { \begin{array} { r l } & { c _ { \nu , k } ^ { \prime \prime } ( s ^ { - 1 } ) = \displaystyle \sum _ { i = 1 } ^ { N } \mathbb { E } _ { \nu \leq i \leq j \leq j \leq N < 0 , \nu \leq i \leq i \leq 2 , j \geq 1 } \mathbb { E } _ { \nu \leq i \leq j \leq i \leq \nu } \mathbb { E } _ { \nu \leq i \leq i \leq \nu } \mathbb { E } _ { \nu \leq i \leq i \leq \nu } \mathbb { E } _ { \nu \leq i \leq i \leq \nu } \mathbb { E } _ { \nu \leq i \leq i \leq \nu } \mathbb { E } _ { \nu \leq i \leq \nu } } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \quad \quad \quad \quad \quad \quad \quad \quad } \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad  \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad  \quad \quad \quad \quad \quad \quad \quad \quad \quad  \quad \quad \quad \quad \quad \quad  \\ & & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad  \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad  \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad  \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad  \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad  \quad \quad \quad \quad \quad \quad \quad \quad  \\ & & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & &  \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad  \end{array} \end{array}
+$$
+
+$$
+\begin{array} { r l r }   { = \sum _ { t = 1 } ^ { T } \mathbb { E } _ { ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) \sim p ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) } [ ( \nabla _ { \phi ^ { - i } } \mathcal { Q } _ { t } ^ { i } ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) - \nabla _ { \phi ^ { - i } } \mathcal { Q } _ { t } ^ { i } ( s _ { t } , a _ { t } ^ { i } ) ) } \\ & { } & { ( \hat { \mathcal { Q } } _ { t } ^ { i } ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) - \mathcal { Q } _ { t } ^ { i } ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } ) ) ] , } \end{array}
+$$
+
+where $\hat { Q } _ { t } ^ { i } \big ( s _ { t } , a _ { t } ^ { i } , a _ { t } ^ { - i } \big )$ is is an empirical estimate of the $Q$ -value of the policy. 
+
+D SOFT BELLMAN EQUATION AND SOFT VALUE ITERATION
+
+Theorem 2. In a symmetric game with only one equilibrium, and the equilibrium meets one of the conditions: 1) the global optimum, i.e. $\mathbb { E } _ { \pi _ { * } } \left[ \hat { \boldsymbol { Q } } _ { t } ^ { i } ( s ) \right] \geq \mathbb { E } _ { \pi } \left[ \boldsymbol { Q } _ { t } ^ { i } ( s ) \right] ; 2 )$ a saddle point, i.e.
+
+$\mathbb { E } _ { \pi _ { * } } \left[ \boldsymbol { Q } _ { t } ^ { i } ( s ) \right] \geq \mathbb { E } _ { \pi ^ { i } } \mathbb { E } _ { \pi _ { * } ^ { - i } } \left[ \boldsymbol { Q } _ { t } ^ { i } ( s ) \right]$ or $\mathbb { E } _ { \pi _ { * } }$ $\tau _ { * } \left[ Q _ { t } ^ { i } ( s ) \right] \ \geq \ \mathbb { E } _ { \pi _ { * } ^ { i } } \mathbb { E } _ { \pi ^ { - i } } \left[ Q _ { t } ^ { i } ( s ) \right]$ ; where $Q _ { * }$ and $\pi _ { * }$ are the π π π  π π π πequilibrium value function and policy, respectively. The PR2 soft value iteration operator defined by:
+
+$$
+\mathcal { T Q } ^ { i } ( s , a ^ { i } , a ^ { - i } ) \triangleq r ^ { i } ( s , a ^ { i } , a ^ { - i } ) + \gamma \mathbb { E } _ { s ^ { \prime } , a ^ { i \prime } \sim p _ { s } , \pi ^ { i } } \left[ \log \int _ { a ^ { - i \prime } } \exp ( \mathcal { Q } ^ { i } ( s ^ { \prime } , a ^ { i \prime } , a ^ { - i \prime } ) ) \mathrm { d } a ^ { - i \prime } \right] ,
+$$
+
+is a contraction mapping.
+
+Proof. As following:
+
+Based on Eq. 11 & 12 in Theorem 1, we can have the PR2 soft value iteration rules shown as:
+
+$$
+\begin{array} { r l } & { \textstyle \int _ { \pi } ^ { i } ( s , a ^ { i } , a ^ { - i } ) = r ^ { i } ( s , a ^ { i } , a ^ { - i } ) + \gamma \mathbb { E } _ { s ^ { \prime } \sim p _ { s } } [ \mathcal { H } ( \pi ^ { i } ( a ^ { i } \vert s ) \pi ^ { - i } ( a ^ { - i } \vert s , a ^ { i } ) ) + \mathbb { E } _ { a ^ { - i \prime } \sim \pi ^ { - i } ( \cdot \vert s ^ { \prime } , a ^ { i \prime } ) } \big [ Q _ { \pi } ^ { i } ( s ^ { \prime } , a ^ { i \prime } , a } \\ & { \textstyle \qquad = r ^ { i } ( s , a ^ { i } , a ^ { - i } ) + \gamma \mathbb { E } _ { s ^ { \prime } \sim p _ { s } } [ Q _ { \pi } ^ { i } ( s ^ { \prime } , a ^ { i \prime } ) ] . } \end{array}
+$$
+
+Correspondingly, we define the soft value iteration operator $\mathcal { T }$ :
+
+$$
+\mathcal { T Q } ^ { i } ( s , a ^ { i } , a ^ { - i } ) \triangleq r ^ { i } ( s , a ^ { i } , a ^ { - i } ) + \gamma \mathbb { E } _ { s ^ { \prime } , a ^ { i \prime } \sim p _ { s } , \pi ^ { i } } \left[ \log \int _ { a ^ { - i \prime } } \exp ( \mathcal { Q } ^ { i } ( s ^ { \prime } , a ^ { i \prime } , a ^ { - i \prime } ) ) \mathrm { d } a ^ { - i \prime } \right] .
+$$
+
+In a symmetric game with either one global equilibrium or saddle equilibrium, it has been shown by Yang et al. (2018) (see condition $1 \& 2$ in Theorem 1) that the payoff at the equilibrium point is unique. This validates applying the similar idea in proving the contraction mapping of soft-value iteration operator in the single agent case (see Lemma 1 in Fox et al. (2016)). We include it here to stay self-contained.
+
+We first define a norm on $Q$ -values as $\begin{array} { r } { \| Q _ { 1 } ^ { i } - Q _ { 2 } ^ { i } \| \triangleq \operatorname* { m a x } _ { s , a ^ { i } , a ^ { - i } } | Q _ { 1 } ^ { i } ( s , a ^ { i } , a ^ { - i } ) - Q _ { 2 } ^ { i } ( s , a ^ { i } , a ^ { - i } ) | . } \end{array}$ Suppose $\varepsilon = \lVert Q _ { 1 } ^ { i } - Q _ { 2 } ^ { i } \rVert$ , then
+
+$$
+\begin{array} { l } { \log \displaystyle \int _ { a ^ { - i \prime } } \exp ( Q _ { 1 } ^ { i } ( s ^ { \prime } , a ^ { i \prime } , a ^ { - i \prime } ) ) \mathrm { d } a ^ { - i \prime } \leq \log \displaystyle \int _ { a ^ { - i \prime } } \exp ( Q _ { 2 } ^ { i } ( s ^ { \prime } , a ^ { i \prime } , a ^ { - i \prime } ) + \varepsilon ) \mathrm { d } a ^ { - i \prime } } \\ { = \log \displaystyle \int _ { a ^ { - i \prime } } \exp ( \varepsilon ) \exp ( Q _ { 2 } ^ { i } ( s ^ { \prime } , a ^ { i \prime } , a ^ { - i \prime } ) ) \mathrm { d } a ^ { - i \prime } } \\ { = \varepsilon + \log \displaystyle \int _ { a ^ { - i \prime } } \exp ( Q _ { 2 } ^ { i } ( s ^ { \prime } , a ^ { i \prime } , a ^ { - i \prime } ) ) \mathrm { d } a ^ { - i \prime } } \end{array}
+$$
+
+Similarly, $\begin{array} { r } { \log \int _ { a ^ { - i \prime } } \exp \bigl ( Q _ { 1 } ^ { i } \bigl ( s ^ { \prime } , a ^ { i \prime } , a ^ { - i \prime } \bigr ) \bigr ) \mathrm { d } a ^ { - i \prime } \leq - \varepsilon + \log \int _ { a ^ { - i \prime } } \exp \bigl ( Q _ { 2 } ^ { i } \bigl ( s ^ { \prime } , a ^ { i \prime } , a ^ { - i \prime } \bigr ) \bigr ) \mathrm { d } a ^ { - i \prime } } \end{array}$ . Therefore $\lVert \mathcal { I } Q _ { 1 } ^ { i } - \mathcal { T } Q _ { 2 } ^ { i } \rVert \leq \gamma \varepsilon = \gamma \lVert Q _ { 1 } ^ { i } - Q _ { 2 } ^ { i } \rVert$ .