Add files using upload-large-folder tool

parse/train/HyxfGCVYDr/HyxfGCVYDr.md

@@ -0,0 +1,263 @@
+# ONE GENERATION KNOWLEDGE DISTILLATION BYUTILIZING PEER SAMPLES
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Knowledge Distillation is a widely used technique in recent deep learning research to obtain small and simple models whose performance is on a par with their large and complex counterparts. Standard Knowledge Distillation tends to be time-consuming because of the training time spent to obtain a teacher model that would then provide guidance for the student model. It might be possible to cut short the time by training a teacher model on the fly, but it is not trivial to have such a high-capacity teacher that gives quality guidance to student models this way. To improve this, we present a novel framework of Knowledge Distillation exploiting dark knowledge from the whole training set. In this framework, we propose a simple and effective implementation named Distillation by Utilizing Peer Samples (DUPS) in one generation. We verify our algorithm on numerous experiments. Compared with standard training on modern architectures, DUPS achieves an average improvement of $1 \% - 2 \%$ on various tasks with nearly zero extra cost. Considering some typical Knowledge Distillation methods which are much more time-consuming, we also get comparable or even better performance using DUPS.
+
+# 1 INTRODUCTION
+
+Recent years have witnessed continuous development of deep neural network models. A general trend is that improvements in model performance are usually coupled with more complex architecture designs and higher cost of computation. In order to obtain more compact models with higher quality, the idea of Knowledge Distillation (KD) first emerged in the form of knowledge transfer between models (Bucilua et al., 2006). KD takes advantage of the “dark knowledge” by transfer- ˇ ring it from teacher models to student models so as to facilitate the latter’s training process (Hinton et al., 2015). Student models, with the availability of softened output vectors from teacher models in KD, have access to richer information in comparison to directly learning from hard labels provided by training set. KD significantly improves smaller models’ performance, and thus it further allows model compression.
+
+Although great progress has been made in this area, much more training cost is incurred due to involved time-consuming mid-output (e.g. feature maps) alignment when training student models, on top of extra training of a huge teacher model. It is ad meaningful objective of finding more efficient KD methods. Recent works by (Furlanello et al., 2018) and (Lan et al., 2018b) show that a stronger teacher model is not the necessary condition for improving the student model. Their research shows that it is possible that the student model’s performance can be significantly improved by an identically structured teacher model. Although the techniques remain inefficient due to the cost of multi-generation (at least one extra) training of teacher models, these works give important hints that cheaper teachers with considerable effectiveness may exist. Recently (Yang et al., 2018) extend these works, trying to obtain continuously improved teachers by introducing the cyclic learning rate technique in one-generation training. They propose Snapshot Distillation (SD), which uses models obtained from earlier checkpoints as teachers and skips the process of separately training a teacher model.
+
+Inspired by recent interesting ideas of dataset distillation (Wang et al., 2019) for objectives on other research areas, we propose a novel approach for KD in this paper. Instead of relying on the assitance of a separate teacher model or checkpoint, we exploit hidden knowledge in the dataset to generate a surrogate teacher. Specifically, we first define a more general framework of knowledge distillation utilizing the whole dataset to generate extra supervision signals, rather than using a single sample alone. Then we propose a very simple yet effective implementation of one-generation KD, called Distillation by Utilizing Peer Samples (DUPS). In DUPS, each sample borrows continuously boosted secondary information from a random subset of peer samples belonging to the same category on the fly.
+
+We perform extensive experiments on CIFAR100 dataset, with various modern architectures such as PreActResNet, WideResNet, and ResNeXt, demonstrating that our proposed DUPS gains significant improvement compared to standard SGD training with nearly zero extra computation cost. DUPS also outperforms recent one-generation KD method SnapShot Distillation (Yang et al., 2018) on most architectures. Moreover, we validate our algorithm on more practical tasks, include ImageNet classification, transfer learning, and language model. Experiments show that DUPS is generally effective across different tasks.
+
+In summary, our main contributions include: 1) To the best of our knowledge, we are the first to propose an extension framework of Knowledge Distillation utilizing the whole training set other than a single sample. 2) Under this framework we implement a general on-the-fly algorithm DUPS which achieves significant improvement at almost no extra cost.
+
+The rest of the paper is organized as follows. Section 2 presents prior works related to this paper. Section 3 introduces our methodology of the general knowledge distillation framework. Section 4 demonstrates our experimental results and provides some discussions. Section 5 concludes the paper.
+
+# 2 RELATED WORK
+
+# 2.1 KNOWLEDGE DISTILLATION
+
+Methodologies and Applications In a traditional KD approach, a separate and typically timeconsuming phase is unavoidable to first obtain a complex teacher model. The softened outputs of the teacher model are then utilized to train a student model that has a much simpler network structure (Hinton et al., 2015). Other works further develop this idea, such as aligning feature maps, grammian matrix or activation boundaries (Romero et al., 2014; Zagoruyko & Komodakis, 2016; Yim et al., 2017; Heo et al., 2018). KD is typically used to get compact models with high performance or for purely purpose of model quality improvement (Furlanello et al., 2018; Lan et al., 2018b; Yang et al., 2018). In addition to these general works, KD is widely demonstrated to be effective on various modern practical tasks, including transfer learning (Li et al., 2019), object detection (Chen et al., 2017), visual relationship detection (Yu et al., 2017) and so on. Despite its effectiveness, one common limitation is the improved performance of student networks in traditional KD is achieved at the cost of extra training time to obtain the teacher model in the first place.
+
+Efficiency of Knowledge Distillation Recently researchers have begun paying more attention to the inefficiency problem of KD. In the scenario of large scale training, (Anil et al., 2018) proposed online distillation which trains multiple copies of a model in a distributed system, at the expense of involving more activated devices simultaneously. It becomes challenging to distill knowledge in one generation because the model currently being trained lacks the capacity to be a good teacher model for itself. SnapShot Distillation ameliorates this problem by utilizing cyclic learning rate (Yang et al., 2018). They divide the whole training process into a few mini-generations, using cosine annealing learning rate policy (Loshchilov & Hutter, 2016) in each mini-generation so as to ensure the teacher models’ quality. Other works tackle the problem by implementing architecture-specific knowledge transfer techniques, e.g. adding new branches or connections to the original model structure (Lan et al., 2018a; Zhang et al., 2019; Hahn & Choi, 2019).
+
+In this paper, we mainly focus on architecture-agnostic KD that aims to use inter-class information to improve general supervision.
+
+# 2.2 LABEL PROPAGATION
+
+Although rarely mentioned, KD is closely related to the area of label propagation. Some early works exploit language knowledge related to image classification objects to help improve the performance of the latter. For example, (Deng et al., 2010; Verma et al., 2012; Akata et al., 2015) draw on external knowledge such as well-constructed language database WordNet, annotated attributes of each instance, or other dataset with hierarchical semantic labels. Recently (Bagherinezhad et al., 2018) utilize the idea of KD to obtain a refined label of a specific crop by a pre-trained teacher model, offering more accurate targets for cropped input images. Another popular idea is to construct propagated labels for effective regularization. (Szegedy et al., 2016) introduce Label Smoothing (LS) which softens the labels in the dataset: instead of being a one-hot encoding vector, the label after LS becomes smoother in distribution over all entries in the vector. It’s a very useful technique in practice till today. Some recent works further analyze the effectiveness of LS or other label-disturb methods (Pereyra et al., 2017; Muller et al., 2019). In this paper We will show that, albeit being similar in appearance, the continuously boosted softened target generated by the whole dataset is more than a data-agnostic regularizer like Label Smoothing.
+
+# 3 METHODOLOGY
+
+# 3.1 TYPICAL FORM OF KD
+
+Without loss of generality, we first define a typical formulation of KD based on past works (Hinton et al., 2015; Furlanello et al., 2018; Yang et al., 2018) in the classical classification setting. Let $\mathcal { D } \in \mathcal { X } { \times } \mathcal { Y }$ be the training set which contains $n$ labelled training samples and $C$ classes. Each sample is denoted by $( \mathbf { x _ { i } } , y _ { i } ) \in \mathbf { \bar { \mathcal { D } } }$ , where $y _ { i } \in \{ 1 , 2 , \ldots , C \}$ . We define our objective network $f _ { S } ( { \bf x } , \overbar { \theta } ) :$ $\mathcal { X } \mapsto \mathcal { V }$ parameterized with $\pmb \theta$ as the mapping function. Commonly in practice, we use the cross entropy function to metric the distance between ground-truth one-hot labels and outputs generated by $f _ { S }$ . For traditional KD, we need to introduce another optimized solution $\pmb { \theta } ^ { \prime }$ of a particular function $f _ { T }$ into the final loss function. We omit normal regularization terms such as $L ^ { \dot { 2 } }$ normalization of parameters for the sake of simplicity. Upon some input sample $\mathcal { D } _ { i } = ( \mathbf { x _ { i } } , y _ { i } )$ , we get
+
+$$
+\mathcal { L } ( \mathcal { D } _ { i } ; \pmb { \theta } ) = \lambda _ { C E } \cdot \mathcal { L } _ { C E } [ y _ { i } , \pmb { f } _ { S } ( \mathbf { x _ { i } } ; \pmb { \theta } ) ] + \lambda _ { K D } \cdot \mathcal { L } _ { K D } [ \pmb { f } _ { S } ( \mathbf { x _ { i } } ; \pmb { \theta } ) , \pmb { f } _ { T } ( \mathbf { x _ { i } } ; \pmb { \theta } ^ { \prime } ) ]
+$$
+
+, where $\lambda _ { C E }$ and $\lambda _ { K D }$ are hyperparameters to balance the relative contribution of the cross entropy term and knowledge distillation term. $\mathcal { L } _ { K D }$ is typically computed by cross entropy (Furlanello et al., 2018; Hahn & Choi, 2019) or Kullback Leibler divergence (Lan et al., 2018a; Yang et al., 2018) between the logits produced by the teacher model and the student model. Note that $f _ { T }$ can be identical in structure as $f _ { S }$ , as demonstrated by the successful implementations of Born-Again Network (Furlanello et al., 2018), Self-Referenced Network (Lan et al., 2018a) and Snapshot Distillation (Yang et al., 2018). For one generation distillation, since there isn’t an external training process of a teacher model, the teacher signal ${ \pmb f } _ { T } ( { \bf x } _ { \bf i } ; { \pmb \theta } ^ { \prime } )$ for sample $\mathcal { D } _ { i }$ is generated from the internal of training procedure or dataset. For example, Snapshot Distillation uses a sequence of checkpoints at the end of each training cycle ${ \pmb \theta } ^ { \prime } \in \{ { \pmb \theta } ^ { c _ { 1 } } , { \pmb \theta } ^ { c _ { 2 } } , \dots \}$ as teacher solutions.
+
+# 3.2 EXTENDED FORM OF KD
+
+We will extend the formulation of KD, making it more compatible with commonly used neural network architectures and algorithms. In the above typical framework, KD loss term is with respect to some sample $\mathcal { D } _ { i } = ( \mathbf { x _ { i } } , y _ { i } )$ . In contrast, our proposed KD framework has its KD term as a function of the whole dataset $\mathcal { D }$ . Thus with the help of dataset $\mathcal { D }$ and some internal or external obtained supplementary teacher solution(s) $\pmb { \theta } ^ { \prime }$ , we have
+
+$$
+\mathcal { L } ( \mathcal { D } _ { i } ; \pmb { \theta } ) = \lambda _ { C E } \cdot \mathcal { L } _ { C E } [ y _ { i } , \pmb { f } _ { S } ( \mathbf { x _ { i } } ; \pmb { \theta } ) ] + \lambda _ { K D } \cdot \mathcal { L } _ { K D } [ \pmb { f } _ { S } ( \mathbf { x _ { i } } ; \pmb { \theta } ) , \pmb { f } _ { T } ( \mathcal { D } _ { i } ; \pmb { \theta } ^ { \prime } , \mathcal { D } ) ]
+$$
+
+. The notation for teacher signal changes from ${ \pmb f } _ { T } ( { \bf x } _ { \bf i } ; { \pmb \theta } ^ { \prime } )$ to ${ \pmb f } _ { T } ( \mathcal { D } _ { i } ; { \pmb \theta } ^ { \prime } , \mathcal { D } )$ because the teacher model requires the label $y _ { i }$ and at least part of the dataset to effectively utilize dataset information in our KD. We note that implementations of traditional KD by (Hinton et al., 2015), Born-Again Network (Furlanello et al., 2018) and Snapshot Distillation (Yang et al., 2018) can be seen as special cases of the above general formulation whose distilled information only depends on the input sample while ignoring others.
+
+# 3.3 TEACHER SIGNAL UTILIZING PEER SAMPLES
+
+The most straightforward idea of leveraging other samples to help is to utilize similar samples. Given a training sample $\mathcal { D } _ { i } = ( \mathbf { x _ { i } } , y _ { i } )$ , we random select $n$ peer samples in the same category of training set, noted by
+
+$$
+Y _ { y _ { i } } = \{ ( \mathbf { x _ { k _ { 1 } } } , y _ { i } ) , ( \mathbf { x _ { k _ { 2 } } } , y _ { i } ) , . . . , ( \mathbf { x _ { k _ { n } } } , y _ { i } ) \} \subset \mathcal { D }
+$$
+
+. With the help of these peer samples, we get teaching signal with respect to $D _ { i }$ as below
+
+$$
+\pmb { f } _ { T } ( { \mathscr { D } _ { i } ; \pmb { \theta } ^ { \prime } } , { \mathscr { D } } ) = \pmb { f } _ { T } ( \mathscr { D } _ { i } ; \pmb { \theta } ^ { \prime } , Y _ { y _ { i } } )
+$$
+
+. As shown above, we do not focus on how one single instance could provide the student model with secondary information that is not directly available from the dataset labels (Hinton et al., 2015; Yang et al., 2019); rather, we aim to find a general trend that reveals the extent of some statistical characteristics, e.g. inter-class similarity, by utilizing peer samples. There are two benefits. First, since such information is relatively static or stable for a period of training procedure and can be shared among samples of the same category, it is cheap to obtain and store in memory. Second, teaching signals voted by a cluster of samples may offer more reliable secondary information comparing with that produced by a sub-optimized checkpoint found before training completes.
+
+# 3.4 DUPS IMPLEMENTATION
+
+Similar to SnapShot Distillation proposed by (Yang et al., 2018), our method achieves on-the-fly distillation within one generation of training by dividing the training process into $m$ stages, with each stage consisting of $t$ epochs. However, an important difference is that our method do not strongly depend on cyclic learning rate for obtaining reliable teaching signal. Let $M$ be the set of such stages and $T$ be the set of epochs. Then $M = \{ M _ { 1 } , M _ { 2 } , . . . , M _ { m } \}$ , and for each $i$ such that $1 \leq i \leq m$ , $M _ { i } = \{ T _ { ( i - 1 ) \times t + 1 } , T _ { ( i - 1 ) \times t + 2 } , \ldots , T _ { ( i - 1 ) \times t + ( t - 1 ) } , T _ { i \times t } \} .$ . We follow the algorithm in Alg. 1 to implement DUPS. For a sample $\mathcal { D } _ { i } = ( \mathbf { x _ { i } } , y _ { i } )$ , its peer samples, denoted by $Y _ { y _ { i } }$ , are a random subset of the all samples found in the same category. Hence,
+
+$$
+Y _ { y _ { i } } \subset \{ ( \mathbf { x } , y ) \in \mathcal { D } \mid y = y _ { i } \}
+$$
+
+. For specific implementation, we share teacher signal among samples of the same category. Thus, Eq. 3 is further simplified to
+
+$$
+\forall D _ { j } \in \{ ( \mathbf { x } , y ) \in \mathcal { D } \mid y = y _ { i } \} , f _ { T } ( \mathcal { D } _ { j } ; \pmb { \theta } ^ { \prime } , \mathcal { D } ) = f _ { T } ( Y _ { y _ { i } } ; \pmb { \theta } ^ { \prime } )
+$$
+
+, which means the teacher signal ${ \pmb f } _ { T }$ for sample $D _ { j } = ( \mathbf { x _ { j } } , y _ { j } )$ only depends on the sample’s label $y _ { j }$ but not its data input $\mathbf { x _ { j } }$ . $\mathcal { D }$ is omitted in $\pmb { f } _ { T } ( Y _ { y _ { i } } ; \pmb { \theta } ^ { \prime } )$ as the last parameter because only $Y _ { y _ { j } } \subset \mathcal { D }$ is utilized.
+
+Formally, let the teacher signal for each category with label $y _ { i }$ at stage $M _ { n }$ be $f _ { T } ^ { n } ( Y _ { y _ { i } } ; \pmb { \theta } ^ { \prime } )$ , where $n$ is the index of the current training stage. We denote the checkpoint of student model $f _ { S }$ at the end of $n ^ { t h }$ stage be $\pmb { \theta } ^ { n }$ . We define $\pmb { f } _ { T } ^ { 1 } ( Y _ { y _ { i } } ; \mathbf { \bar { \theta } } ^ { \prime } )$ to be zero. The rest of teacher signals are computed based on
+
+$$
+\pmb { f } _ { T } ^ { n } ( Y _ { y _ { i } } ; \pmb { \theta } ^ { \prime } ) = \frac { 1 } { \| Y _ { y _ { i } } \| } \sum _ { ( \mathbf { x } , y ) \in Y _ { y _ { i } } } \pmb { f } _ { S } ( \mathbf { x } ; \pmb { \theta } ^ { n - 1 } )
+$$
+
+. The average softened logit of each category obtained at the last epoch of each stage is used as the “teacher model” for training of student model at next stage. In total, there are $m - 1$ iterations of knowledge distillation between “teacher models” and “student models” in the whole training process.
+
+Input: Current epoch $T _ { c } \in M _ { n }$ , the set of training samples $\mathcal { D }$ Output: Improved neural network model parameters $\pmb \theta$
+
+1 for each batch $\boldsymbol { B }$ in $\mathcal { D }$ do
+
+2 for each sample $( \mathbf { x _ { j } } , y _ { j } )$ in $\boldsymbol { B }$ do   
+3 Compute the logits $l$ and prediction ${ \bf \nabla } f _ { S } ( { \bf x _ { j } } )$ produced by the current model;   
+4 Compute cross entropy loss $\mathcal { L } _ { C E }$ using $f _ { S } ( \bf { x } _ { j } )$ and ${ \tt y } _ { j }$   
+5 if $M _ { n }$ is the first stage $M _ { 1 }$ then   
+6 Set knowledge distillation loss $\mathcal { L } _ { K D }$ to be ${ f _ { T } ^ { 1 } } ( Y _ { y _ { j } } ; \pmb { \theta } ^ { \prime } ) = 0$ ;   
+7 else   
+8 Compute knowledge distillation loss $\mathcal { L } _ { K D }$ using $l$ and $f _ { T } ^ { n } ( Y _ { y _ { j } } ; \pmb { \theta } ^ { \prime } )$ where   
+$Y _ { y _ { j } } = \{ ( \mathbf { x } , y ) \in \mathcal { D } \mid y = y _ { j } \}$ ;   
+9 Obtain the total loss (Eq 2);   
+10 Calculate the average loss of this batch;   
+11 Update model parameters;
+
+12 if $T _ { c }$ is the last epoch in the current stage $M _ { n }$ then
+
+13 Update $\pmb { f } _ { T } ^ { n - 1 } ( Y _ { y _ { p } } ; \pmb { \theta } ^ { \prime } )$ to $f _ { T } ^ { n } ( Y _ { y _ { p } } ; \pmb { \theta } ^ { \prime } )$ using the corresponding set of peer samples $Y _ { y _ { p } }$ for all $y _ { p } \in \{ 1 , 2 , \ldots , C \}$ (Eq 5);
+
+# 4 EXPERIMENTS
+
+# 4.1 TASKS AND DATASETS
+
+Image Classification We use CIFAR100 (Krizhevsky, 2009) and ImageNet (Deng et al., 2009) to test the performance of DUPS on image classification task. CIFAR 100 contains RGB images categorized into 100 classes, with each class composing 600 images. There are 500 training images and 100 testing images in each class. ImageNet is a tree-structured image database created according to the WordNet hierarchy. It consists of more than 20K categories and a total of 14 million images. We use the popular subset ILSVRC2012 which containing 1.3M images covering 1K categories. We do not conduct experiments on CIFAR10 because it has been empirically observed that, due to the lack of fine-level categorization in CIFAR10, neural networks do not significantly benefit from distillations between teacher and student models (Yang et al., 2018; Furlanello et al., 2018).
+
+Transfer Learning We use ImageNet as the source dataset and have 4 different datasets as the target dataset in the transfer learning task, covering typical types of plants, animals, objects and texture . The 4 target datasets are (1) Flower102 (Nilsback & Zisserman, 2008) which contains 102 categories of 8189 flower images, (2) Caltech-UCSD Birds-200-2011 (Wah et al., 2011), which has 11,788 images classified into 200 categories, (3) FGVC-Aircraft (Maji et al., 2013) which composes 10,000 images of aircraft across 100 aircraft models, and (4) Describable Textures Dataset (DTD) (Cimpoi et al., 2015) which is a texture database, consisting of 5640 images, organized according to a list of 47 terms (categories).
+
+Natural Language Processing We use Penn Tree Bank (PTB) dataset (Marcus et al., 1993) to evaluate the performance of DUPS on language modeling.
+
+# 4.2 EXPERIMENT SETTINGS
+
+Image Classification We train all models except DenseNet for image classification in 160 epochs. For DenseNet we train 240 epochs because it converges slower. The initial learning rate is 0.1 for all architectures. Training batch size is 64. We use standard SGD optimizer with momentum 0.9 and weight decay 0.0001. We apply standard data augmentation the same way as the Pytorch official examples on both CIFAR100 and ImageNet classification task. For CIFAR100, we pad the input
+
+Table 1: Test accuracy on CIFAR100. SGD refers to models trained with standard Stochastic Gradient Descent optimizer. LS are models improved by using Label Smoothing technique. SD are the models trained with SnapShot Distillation method. Finally, DUPS and ${ \mathrm { D U P S } } +$ are our methods proposed in this paper. The difference between DUPS and ${ \mathrm { D U P S } } +$ is that ${ \mathrm { D U P S } } +$ uses cyclic learning rate while DUPS does not.
+
+<table><tr><td>Model</td><td>SGD</td><td>LS</td><td>DUPS</td><td>SD</td><td>DUPS+</td></tr><tr><td>PreActResNet18</td><td>0.7646</td><td>0.7795</td><td>0.7785</td><td>0.7729</td><td>0.7794</td></tr><tr><td>PreActResNet34</td><td>0.7701</td><td>0.7729</td><td>0.7823</td><td>0.7665</td><td>0.7785</td></tr><tr><td>PreActResNet50</td><td>0.7687</td><td>0.7798</td><td>0.7847</td><td>0.7809</td><td>0.7877</td></tr><tr><td>PreActResNet101</td><td>0.7756</td><td>0.7829</td><td>0.7882</td><td>0.7788</td><td>0.7899</td></tr><tr><td>DenseNet40(240)</td><td>0.7003</td><td>0.7034</td><td>0.7101</td><td>0.7115</td><td>0.7174</td></tr><tr><td>DenseNet100(240)</td><td>0.7515</td><td>0.7559</td><td>0.7557</td><td>0.7657</td><td>0.7617</td></tr><tr><td>WideResNet28x10</td><td>0.7968</td><td>0.7996</td><td>0.8028</td><td>0.8013</td><td>0.8062</td></tr><tr><td>ResNeXt29_8x64d</td><td>0.8017</td><td>0.8103</td><td>0.8184</td><td>=</td><td>=</td></tr></table>
+
+images by 4 pixels, and then randomly crop a sub-region of $3 2 \times 3 2$ and randomly do a horizontal flip. For ImageNet, we first randomly crop a sub-region of $2 2 4 \times 2 2 4$ and randomly do a horizontal flip. We normalize the input data as done in common practice.
+
+Transfer Learning We use ResNet-101 as the base model to apply DUPS. We train the model with 40 epochs and the batch size for training is 64. SGD optimizer is used with a momentum of 0.9. The initial learning rate is set to 0.01 and the weight decay is set to 0.0001. We use exactly the same data augmentation methods as in ImageNet classification task.
+
+Natural Language Processing We validate the performance of DUPS on three regularized LSTM models with varying depth. For the large model, we use 1500 hidden units and train 55 epochs. The learning rate decays by $1 / 1 . 5$ after 15 epochs. Its dropout rate is set to be 0.65 and dropout is applied to all non-recurrent connections. The medium model consists of 650 hidden units. We train it with 40 epochs. The learning rate decays by 0.8 after 5 epochs. Its dropout rate is 0.5. The small model has 200 hidden units. It is trained in 15 epochs. The learning rate remains as the initial value for 4 epochs and then starts to decay at the rate of 0.5. No dropout is used in the small model. For all three models, the initial learning rate is 20.
+
+While training DUPS to compare with models trained with SGD optimizer or label smoothing technique in the three tasks, we use cosine annealing policy to update learning rates for all these models. In order to make fair comparisons with Snapshot Distillation, we upgrade our DUPS with cyclic learning rate policy, which is named ${ \mathrm { D U P S } } +$ . Within each cycle , ${ \mathrm { D U P S } } +$ uses cosine annealing learning rate.
+
+For hyper-parameters specific to DUPS, we also use a common setting for all tasks following instructions from some empirical studies. We set $\lambda _ { C E }$ to 0.8 and $\lambda _ { K D }$ to 0.2. The Kullback Leibler divergence is used to calculate knowledge distillation term. We use temperature of 6 to soften the logits. We divide the training process into 10 stages for image classification tasks and 5 stages for transfer learning and language model tasks.
+
+# 4.3 EXPERIMENT RESULTS
+
+We present our experiment results and give insights into the advantages as well as disadvantages using DUPS. We achieve this by comparing DUPS with models trained with SGD, and sometimes with closely related algorithms, namely Label Smoothing and Snapshot Distillation. Although SnapShot Ensembles (Huang et al., 2017) also offers ideas on which we further develop, we do not carry out duplicate experiments to compare with it because (Yang et al., 2018) have already made comparisons between Snapshot Distillation and SnapShot Ensembles. Therefore, we directly compare our proposed DUPS with SnapShot Distillation.
+
+Image Classification Table. 1 shows that our DUPS implementation consistently and significantly improve baseline models in accuracy for the vast majority of neural network architectures we tested.
+
+Table 2: Training Time of Different Algorithms on PreActResNet50 and WideResNet28x10. All abbreviations follow the same rule as in Table. 1. We run experiments on Tesla V100 GPUs and normalize the training time of SGD to 1 for simplified comparison.   
+
+<table><tr><td>Model</td><td>SGD</td><td>LS</td><td>SD</td><td>DUPS</td></tr><tr><td>PreActResNet50</td><td>1</td><td>~1</td><td>1.32</td><td>1.04</td></tr><tr><td>WideResNet28x10</td><td>1</td><td>~1</td><td>1.27</td><td>1.01</td></tr></table>
+
+Table 3: Top-1 Test accuracy on ImageNet. All abbreviations follow the same rule as in Table. 1.   
+
+<table><tr><td>Model</td><td>SGD</td><td>LS</td><td>DUPS</td></tr><tr><td>ResNet50</td><td>76.58</td><td>76.69</td><td>77.58</td></tr><tr><td>ResNet101</td><td>77.86</td><td>78.41</td><td>78.74</td></tr><tr><td>ResNet152</td><td>78.17</td><td>78.63</td><td>79.06</td></tr></table>
+
+The improvement is generally within $1 \% - 2 \%$ in comparison to models trained with the standard SGD optimizer. We notice that more complex architectures do not always perform better than simpler ones, while DUPS achieves stable improvement. We can observe a similar trend in Table. 3 when we apply DUPS to different models on ImageNet.
+
+For the majority of the models we tested, DUPS also outperforms Label Smoothing (LS) in image classification. Although DUPS does not beat LS on PreActResNet18 and DenseNet100, the difference is relatively marginal. When compared with a recently proposed KD method SnapShot Distillation, DUPS shows comparable performance even though the SD uses a more complicated learning rate policy. We also demonstrate that ${ \mathrm { D U P S } } +$ which combines cyclic learning rate outperforms SD in most cases. However we noticed that leveraging cyclic learning rate doesn’t always bring benefit. In addition, DUPS obtains the improved results with significantly less training time than that SD needs as showed in Table. 2.
+
+Transfer Learning We fixed our test model to be ResNet101 and perform experiments on the chosen datasets. Results in Table. 4 indicate that, compared with models trained using SGD, DUPS improves the transfer learning outcomes on all four datasets, and the improvements range from $0 . 4 6 \%$ to $1 . 7 8 \%$ . These results testify that DUPS can enhance model performance on varying datasets.
+
+In contrast, LS does not always yield positively improved results. Furthermore, the extent of improvement LS brings is considerably less than that of DUPS, as shown by the statistics.
+
+Natural Language Processing Last but not least, we investigate the effectiveness of DUPS on language modeling. As shown in Table 5, the use of DUPS reduces the perplexity value by a proportion of $1 . 5 \% { \sim } 4 . 1 \%$ on all three models. Note that the model displays better performance when the perplexity value is low in language modeling. Since DUPS significantly lowers the perplexity values to both small and large size of the LSTM models, its effectiveness is not hindered by scaling the size of the model in this task. This flexibility is another advantage of DUPS.
+
+# 4.4 DISCUSSIONS
+
+Here we give a short discussion about how and why DUPS brings benefits. We first demonstrate some empirical characteristics of DUPS observed in our experiments. We plot the learning curve of the whole training procedure of PreActResNet18 as Fig. 1. For better demonstration purpose, we divide the training process into only 4 stages for DUPS training, with each stage consisting of 40 epochs. We observe that SGD and DUPS display almost the same standard of performance in the first stage as expected. While at the 41th epoch, both training and test accuracy of DUPS get a sharp rise due to involving teacher signal generated in the 40th epoch. Then both training and test accuracy drop slightly for a few epochs, and then return to the trend of slowly rising for the remaining epochs until next stage. A similar phenomenon also appears at the beginning of next stage, although the magnitude of accuracy improvement becomes much more smaller. As the model reaches the beginning of final stage, we no longer see increases in accuracy since training is nearly saturated. We notice that since the first sharp rising, DUPS continuously outperforms SGD by a stable gap for the following training epochs until convergence.
+
+Table 4: Test accuracy using ResNet101 on various datasets. All abbreviations follow the same rule as in Table. 1 or explained in Section 4.1.   
+
+<table><tr><td>Dataset</td><td>SGD</td><td>LS</td><td>DUPS</td></tr><tr><td>Flower102</td><td>0.9179</td><td>0.9279</td><td>0.9294</td></tr><tr><td>FGVC_Aircraft</td><td>0.7741</td><td>0.7675</td><td>0.7787</td></tr><tr><td>DTD</td><td>0.6646</td><td>0.6705</td><td>0.6824</td></tr><tr><td>CUB_200_2011</td><td>0.8172</td><td>0.8152</td><td>0.8246</td></tr></table>
+
+Table 5: Perplexity value of the model using LSTM on Penn Treebank. Lower is better. All abbreviations follow the same rule as in Table. 1 or explained in Section 4.1.   
+
+<table><tr><td>Model Size</td><td>SGD</td><td>LS</td><td>DUPS</td></tr><tr><td>Small</td><td>129.7</td><td>129.1</td><td>125.4</td></tr><tr><td>Medium</td><td>95.3</td><td>96.7</td><td>93.9</td></tr><tr><td>Large</td><td>89.2</td><td>88.7</td><td>85.7</td></tr></table>
+
+We also investigate the influence of different choices of hyper-parameters specific to DUPS. The most important two are the number of stages and number of random peer samples. We run a grid search method to validate different combinations of these two variables. We use update intervals, or equivalently number of epochs per stage, instead of number of stages for clarity in this experiments. In Fig. 2 we see that performance of DUPS does not seem to be very sensitive to most combinations of the hyperparameters. When the number of peer samples increases to 5 or more, model accuracy tends to be over $7 7 . 3 \%$ . Even when the number of peer samples is low, a good choice of the value of update interval can boost the model performance significantly. For example, when number of peer samples is 1 and update interval is set to be between 20 to 40, DUPS still delivers satisfying results which is comparable to its best performance. Low accuracy of the model only happens consistently when the value of update interval is large. If update interval is set to 80, the model, teacher-student knowledge transfer only takes place once during the whole training process. Consequently, the opportunity to distill the knowledge obtained from the dataset is too rare for the model to benefit from DUPS.
+
+# 5 CONCLUSION
+
+In this paper, we have introduced a general framework for one-generation KD: We incorporate the information contained within the dataset into teacher-student optimization. We have also proposed an effective implementation of this general framework named DUPS. With extensive experiments, this simple yet effective algorithm is verified to be effective in improving model performance in tasks like image classification, transfer learning and language modeling with almost no additional cost in training resources. The demonstrated success of DUPS imply that utilizing dataset information during training potentially allow us to gain even more benefits.
+
+# REFERENCES
+
+Zeynep Akata, Florent Perronnin, Zaid Harchaoui, and Cordelia Schmid. Label-embedding for image classification. IEEE transactions on pattern analysis and machine intelligence, 38(7): 1425–1438, 2015.
+
+Rohan Anil, Gabriel Pereyra, Alexandre Passos, Robert Orm ´ andi, George E. Dahl, and Geof- ´ frey E. Hinton. Large scale distributed neural network training through online distillation. ArXiv, abs/1804.03235, 2018.
+
+Hessam Bagherinezhad, Maxwell Horton, Mohammad Rastegari, and Ali Farhadi. Label refinery: Improving imagenet classification through label progression. ArXiv, abs/1805.02641, 2018.
+
+![](images/218ae22caf35ae5d9c1bdbd085e38820c13df95244eadc4c925bd92077db863d.jpg)  
+Figure 1: SGD and DUPS Learning Curves on PreActResNet18
+
+![](images/c993c9b619198602681a11af305f6f44f51861d85183ad63060e3f262cd83d73.jpg)  
+Figure 2: DUPS hyperparameter experiment on PreActResNet18
+
+Cristian Bucilua, Rich Caruana, and Alexandru Niculescu-Mizil. Model compression. In ˇ Proceedings of the 12th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’06, pp. 535–541, New York, NY, USA, 2006. ACM.
+
+Guobin Chen, Wongun Choi, Xiang Yu, Tony X. Han, and Manmohan Krishna Chandraker. Learning efficient object detection models with knowledge distillation. In NIPS, 2017.
+
+Mircea Cimpoi, Subhransu Maji, and Andrea Vedaldi. Deep filter banks for texture recognition and segmentation. 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 3828–3836, 2015.
+
+Jia Deng, Alexander C Berg, Kai Li, and Li Fei-Fei. What does classifying more than 10,000 image categories tell us? In European conference on computer vision, pp. 71–84. Springer, 2010.
+
+Jun Deng, Wei Dong, Richard Socher, Li-Jia Li, Kuntai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. 2009 IEEE Conference on Computer Vision and Pattern Recognition, pp. 248–255, 2009.
+
+Tommaso Furlanello, Zachary C. Lipton, Michael Tschannen, Laurent Itti, and Anima Anandkumar. Born again neural networks. In ICML, 2018.
+
+Sangchul Hahn and Heeyoul Choi. Self-knowledge distillation in natural language processing. arXiv preprint arXiv:1908.01851, 2019.
+
+Byeongho Heo, Minsik Lee, Sangdoo Yun, and Jin Young Choi. Knowledge transfer via distillation of activation boundaries formed by hidden neurons. ArXiv, abs/1811.03233, 2018.
+
+Geoffrey E. Hinton, Oriol Vinyals, and Jeffrey Dean. Distilling the knowledge in a neural network. ArXiv, abs/1503.02531, 2015.
+
+Gao Huang, Yixuan Li, Geoff Pleiss, Zhuang Liu, John E. Hopcroft, and Kilian Q. Weinberger. Snapshot ensembles: Train 1, get m for free. ArXiv, abs/1704.00109, 2017.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009.
+
+Xu Lan, Xiatian Zhu, and Shaogang Gong. Knowledge distillation by on-the-fly native ensemble. In NeurIPS, 2018a.
+
+Xu Lan, Xiatian Zhu, and Shaogang Gong. Self-referenced deep learning. ArXiv, abs/1811.07598, 2018b.
+
+Xingjian Li, Haoyi Xiong, Hanchao Wang, Yuxuan Rao, Liping Liu, and Jun Huan. Delta: Deep learning transfer using feature map with attention for convolutional networks. ArXiv, abs/1901.09229, 2019.
+
+Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. In ICLR, 2016.
+
+Subhransu Maji, Esa Rahtu, Juho Kannala, Matthew B. Blaschko, and Andrea Vedaldi. Fine-grained visual classification of aircraft. ArXiv, abs/1306.5151, 2013.
+
+Mitchell P. Marcus, Beatrice Santorini, and Mary Ann Marcinkiewicz. Building a large annotated corpus of english: The penn treebank. Computational Linguistics, 19:313–330, 1993.
+
+Rafael J. Muller, Simon Kornblith, and Geoffrey E. Hinton. When does label smoothing help? ArXiv, abs/1906.02629, 2019.
+
+Maria-Elena Nilsback and Andrew Zisserman. Automated flower classification over a large number of classes. 2008 Sixth Indian Conference on Computer Vision, Graphics & Image Processing, pp. 722–729, 2008.
+
+Gabriel Pereyra, George Tucker, Jan Chorowski, Łukasz Kaiser, and Geoffrey Hinton. Regularizing neural networks by penalizing confident output distributions. arXiv preprint arXiv:1701.06548, 2017.
+
+Adriana Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. Fitnets: Hints for thin deep nets. CoRR, abs/1412.6550, 2014.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2818–2826, 2016.
+
+Nakul Verma, Dhruv Mahajan, Sundararajan Sellamanickam, and Vinod Nair. Learning hierarchical similarity metrics. In 2012 IEEE conference on computer vision and pattern recognition, pp. 2280–2287. IEEE, 2012.
+
+C. Wah, S. Branson, P. Welinder, P. Perona, and S. Belongie. The Caltech-UCSD Birds-200-2011 Dataset. Technical Report CNS-TR-2011-001, California Institute of Technology, 2011.
+
+Tongzhou Wang, Jun-Yan Zhu, Antonio Torralba, and Alexei A. Efros. Dataset distillation. ArXiv, abs/1811.10959, 2019.
+
+Chenglin Yang, Lingxi Xie, Chi Su, and Alan L. Yuille. Snapshot distillation: Teacher-student optimization in one generation. ArXiv, abs/1812.00123, 2018.
+
+Chenglin Yang, Lingxi Xie, Siyuan Qiao, and Alan L. Yuille. Training deep neural networks in generations: A more tolerant teacher educates better students. In AAAI, 2019.
+
+Junho Yim, Donggyu Joo, Jihoon Bae, and Junmo Kim. A gift from knowledge distillation: Fast optimization, network minimization and transfer learning. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), volume 2, 2017.
+
+Ruichi Yu, Ang Li, Vlad I. Morariu, and Larry S. Davis. Visual relationship detection with internal and external linguistic knowledge distillation. 2017 IEEE International Conference on Computer Vision (ICCV), pp. 1068–1076, 2017.
+
+Sergey Zagoruyko and Nikos Komodakis. Paying more attention to attention: Improving the performance of convolutional neural networks via attention transfer. arXiv preprint arXiv:1612.03928, 2016.
+
+Linfeng Zhang, Jiebo Song, Anni Gao, Jingwei Chen, Chenglong Bao, and Kaisheng Ma. Be your own teacher: Improve the performance of convolutional neural networks via self distillation. ArXiv, abs/1905.08094, 2019.

parse/train/HyxfGCVYDr/HyxfGCVYDr_content_list.json

@@ -0,0 +1,1363 @@
+[
+    {
+        "type": "text",
+        "text": "ONE GENERATION KNOWLEDGE DISTILLATION BYUTILIZING PEER SAMPLES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            184,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Knowledge Distillation is a widely used technique in recent deep learning research to obtain small and simple models whose performance is on a par with their large and complex counterparts. Standard Knowledge Distillation tends to be time-consuming because of the training time spent to obtain a teacher model that would then provide guidance for the student model. It might be possible to cut short the time by training a teacher model on the fly, but it is not trivial to have such a high-capacity teacher that gives quality guidance to student models this way. To improve this, we present a novel framework of Knowledge Distillation exploiting dark knowledge from the whole training set. In this framework, we propose a simple and effective implementation named Distillation by Utilizing Peer Samples (DUPS) in one generation. We verify our algorithm on numerous experiments. Compared with standard training on modern architectures, DUPS achieves an average improvement of $1 \\% - 2 \\%$ on various tasks with nearly zero extra cost. Considering some typical Knowledge Distillation methods which are much more time-consuming, we also get comparable or even better performance using DUPS. ",
+        "bbox": [
+            233,
+            266,
+            764,
+            488
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            516,
+            336,
+            532
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent years have witnessed continuous development of deep neural network models. A general trend is that improvements in model performance are usually coupled with more complex architecture designs and higher cost of computation. In order to obtain more compact models with higher quality, the idea of Knowledge Distillation (KD) first emerged in the form of knowledge transfer between models (Bucilua et al., 2006). KD takes advantage of the “dark knowledge” by transfer- ˇ ring it from teacher models to student models so as to facilitate the latter’s training process (Hinton et al., 2015). Student models, with the availability of softened output vectors from teacher models in KD, have access to richer information in comparison to directly learning from hard labels provided by training set. KD significantly improves smaller models’ performance, and thus it further allows model compression. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Although great progress has been made in this area, much more training cost is incurred due to involved time-consuming mid-output (e.g. feature maps) alignment when training student models, on top of extra training of a huge teacher model. It is ad meaningful objective of finding more efficient KD methods. Recent works by (Furlanello et al., 2018) and (Lan et al., 2018b) show that a stronger teacher model is not the necessary condition for improving the student model. Their research shows that it is possible that the student model’s performance can be significantly improved by an identically structured teacher model. Although the techniques remain inefficient due to the cost of multi-generation (at least one extra) training of teacher models, these works give important hints that cheaper teachers with considerable effectiveness may exist. Recently (Yang et al., 2018) extend these works, trying to obtain continuously improved teachers by introducing the cyclic learning rate technique in one-generation training. They propose Snapshot Distillation (SD), which uses models obtained from earlier checkpoints as teachers and skips the process of separately training a teacher model. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            873
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Inspired by recent interesting ideas of dataset distillation (Wang et al., 2019) for objectives on other research areas, we propose a novel approach for KD in this paper. Instead of relying on the assitance of a separate teacher model or checkpoint, we exploit hidden knowledge in the dataset to generate a surrogate teacher. Specifically, we first define a more general framework of knowledge distillation utilizing the whole dataset to generate extra supervision signals, rather than using a single sample alone. Then we propose a very simple yet effective implementation of one-generation KD, called Distillation by Utilizing Peer Samples (DUPS). In DUPS, each sample borrows continuously boosted secondary information from a random subset of peer samples belonging to the same category on the fly. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We perform extensive experiments on CIFAR100 dataset, with various modern architectures such as PreActResNet, WideResNet, and ResNeXt, demonstrating that our proposed DUPS gains significant improvement compared to standard SGD training with nearly zero extra computation cost. DUPS also outperforms recent one-generation KD method SnapShot Distillation (Yang et al., 2018) on most architectures. Moreover, we validate our algorithm on more practical tasks, include ImageNet classification, transfer learning, and language model. Experiments show that DUPS is generally effective across different tasks. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            291
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, our main contributions include: 1) To the best of our knowledge, we are the first to propose an extension framework of Knowledge Distillation utilizing the whole training set other than a single sample. 2) Under this framework we implement a general on-the-fly algorithm DUPS which achieves significant improvement at almost no extra cost. ",
+        "bbox": [
+            174,
+            299,
+            825,
+            354
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The rest of the paper is organized as follows. Section 2 presents prior works related to this paper. Section 3 introduces our methodology of the general knowledge distillation framework. Section 4 demonstrates our experimental results and provides some discussions. Section 5 concludes the paper. ",
+        "bbox": [
+            176,
+            361,
+            823,
+            417
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            457,
+            343,
+            473
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 KNOWLEDGE DISTILLATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            501,
+            411,
+            513
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Methodologies and Applications In a traditional KD approach, a separate and typically timeconsuming phase is unavoidable to first obtain a complex teacher model. The softened outputs of the teacher model are then utilized to train a student model that has a much simpler network structure (Hinton et al., 2015). Other works further develop this idea, such as aligning feature maps, grammian matrix or activation boundaries (Romero et al., 2014; Zagoruyko & Komodakis, 2016; Yim et al., 2017; Heo et al., 2018). KD is typically used to get compact models with high performance or for purely purpose of model quality improvement (Furlanello et al., 2018; Lan et al., 2018b; Yang et al., 2018). In addition to these general works, KD is widely demonstrated to be effective on various modern practical tasks, including transfer learning (Li et al., 2019), object detection (Chen et al., 2017), visual relationship detection (Yu et al., 2017) and so on. Despite its effectiveness, one common limitation is the improved performance of student networks in traditional KD is achieved at the cost of extra training time to obtain the teacher model in the first place. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            700
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Efficiency of Knowledge Distillation Recently researchers have begun paying more attention to the inefficiency problem of KD. In the scenario of large scale training, (Anil et al., 2018) proposed online distillation which trains multiple copies of a model in a distributed system, at the expense of involving more activated devices simultaneously. It becomes challenging to distill knowledge in one generation because the model currently being trained lacks the capacity to be a good teacher model for itself. SnapShot Distillation ameliorates this problem by utilizing cyclic learning rate (Yang et al., 2018). They divide the whole training process into a few mini-generations, using cosine annealing learning rate policy (Loshchilov & Hutter, 2016) in each mini-generation so as to ensure the teacher models’ quality. Other works tackle the problem by implementing architecture-specific knowledge transfer techniques, e.g. adding new branches or connections to the original model structure (Lan et al., 2018a; Zhang et al., 2019; Hahn & Choi, 2019). ",
+        "bbox": [
+            174,
+            734,
+            825,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we mainly focus on architecture-agnostic KD that aims to use inter-class information to improve general supervision. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 LABEL PROPAGATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            366,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Although rarely mentioned, KD is closely related to the area of label propagation. Some early works exploit language knowledge related to image classification objects to help improve the performance of the latter. For example, (Deng et al., 2010; Verma et al., 2012; Akata et al., 2015) draw on external knowledge such as well-constructed language database WordNet, annotated attributes of each instance, or other dataset with hierarchical semantic labels. Recently (Bagherinezhad et al., 2018) utilize the idea of KD to obtain a refined label of a specific crop by a pre-trained teacher model, offering more accurate targets for cropped input images. Another popular idea is to construct propagated labels for effective regularization. (Szegedy et al., 2016) introduce Label Smoothing (LS) which softens the labels in the dataset: instead of being a one-hot encoding vector, the label after LS becomes smoother in distribution over all entries in the vector. It’s a very useful technique in practice till today. Some recent works further analyze the effectiveness of LS or other label-disturb methods (Pereyra et al., 2017; Muller et al., 2019). In this paper We will show that, albeit being similar in appearance, the continuously boosted softened target generated by the whole dataset is more than a data-agnostic regularizer like Label Smoothing. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            324
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHODOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            343,
+            341,
+            359
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 TYPICAL FORM OF KD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            375,
+            375,
+            388
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Without loss of generality, we first define a typical formulation of KD based on past works (Hinton et al., 2015; Furlanello et al., 2018; Yang et al., 2018) in the classical classification setting. Let $\\mathcal { D } \\in \\mathcal { X } { \\times } \\mathcal { Y }$ be the training set which contains $n$ labelled training samples and $C$ classes. Each sample is denoted by $( \\mathbf { x _ { i } } , y _ { i } ) \\in \\mathbf { \\bar { \\mathcal { D } } }$ , where $y _ { i } \\in \\{ 1 , 2 , \\ldots , C \\}$ . We define our objective network $f _ { S } ( { \\bf x } , \\overbar { \\theta } ) :$ $\\mathcal { X } \\mapsto \\mathcal { V }$ parameterized with $\\pmb \\theta$ as the mapping function. Commonly in practice, we use the cross entropy function to metric the distance between ground-truth one-hot labels and outputs generated by $f _ { S }$ . For traditional KD, we need to introduce another optimized solution $\\pmb { \\theta } ^ { \\prime }$ of a particular function $f _ { T }$ into the final loss function. We omit normal regularization terms such as $L ^ { \\dot { 2 } }$ normalization of parameters for the sake of simplicity. Upon some input sample $\\mathcal { D } _ { i } = ( \\mathbf { x _ { i } } , y _ { i } )$ , we get ",
+        "bbox": [
+            173,
+            400,
+            825,
+            526
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/49797f605caa7082d695f382d51b5cde60648bdcbf055c31fdd121abb085c2af.jpg",
+        "text": "$$\n\\mathcal { L } ( \\mathcal { D } _ { i } ; \\pmb { \\theta } ) = \\lambda _ { C E } \\cdot \\mathcal { L } _ { C E } [ y _ { i } , \\pmb { f } _ { S } ( \\mathbf { x _ { i } } ; \\pmb { \\theta } ) ] + \\lambda _ { K D } \\cdot \\mathcal { L } _ { K D } [ \\pmb { f } _ { S } ( \\mathbf { x _ { i } } ; \\pmb { \\theta } ) , \\pmb { f } _ { T } ( \\mathbf { x _ { i } } ; \\pmb { \\theta } ^ { \\prime } ) ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            529,
+            746,
+            546
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": ", where $\\lambda _ { C E }$ and $\\lambda _ { K D }$ are hyperparameters to balance the relative contribution of the cross entropy term and knowledge distillation term. $\\mathcal { L } _ { K D }$ is typically computed by cross entropy (Furlanello et al., 2018; Hahn & Choi, 2019) or Kullback Leibler divergence (Lan et al., 2018a; Yang et al., 2018) between the logits produced by the teacher model and the student model. Note that $f _ { T }$ can be identical in structure as $f _ { S }$ , as demonstrated by the successful implementations of Born-Again Network (Furlanello et al., 2018), Self-Referenced Network (Lan et al., 2018a) and Snapshot Distillation (Yang et al., 2018). For one generation distillation, since there isn’t an external training process of a teacher model, the teacher signal ${ \\pmb f } _ { T } ( { \\bf x } _ { \\bf i } ; { \\pmb \\theta } ^ { \\prime } )$ for sample $\\mathcal { D } _ { i }$ is generated from the internal of training procedure or dataset. For example, Snapshot Distillation uses a sequence of checkpoints at the end of each training cycle ${ \\pmb \\theta } ^ { \\prime } \\in \\{ { \\pmb \\theta } ^ { c _ { 1 } } , { \\pmb \\theta } ^ { c _ { 2 } } , \\dots \\}$ as teacher solutions. ",
+        "bbox": [
+            173,
+            556,
+            825,
+            696
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 EXTENDED FORM OF KD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            712,
+            390,
+            727
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We will extend the formulation of KD, making it more compatible with commonly used neural network architectures and algorithms. In the above typical framework, KD loss term is with respect to some sample $\\mathcal { D } _ { i } = ( \\mathbf { x _ { i } } , y _ { i } )$ . In contrast, our proposed KD framework has its KD term as a function of the whole dataset $\\mathcal { D }$ . Thus with the help of dataset $\\mathcal { D }$ and some internal or external obtained supplementary teacher solution(s) $\\pmb { \\theta } ^ { \\prime }$ , we have ",
+        "bbox": [
+            173,
+            738,
+            825,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f8ce063d7986cee4a2f5e7de15f9efb34886e12dfdb5e4e93b218d37c6ab44d4.jpg",
+        "text": "$$\n\\mathcal { L } ( \\mathcal { D } _ { i } ; \\pmb { \\theta } ) = \\lambda _ { C E } \\cdot \\mathcal { L } _ { C E } [ y _ { i } , \\pmb { f } _ { S } ( \\mathbf { x _ { i } } ; \\pmb { \\theta } ) ] + \\lambda _ { K D } \\cdot \\mathcal { L } _ { K D } [ \\pmb { f } _ { S } ( \\mathbf { x _ { i } } ; \\pmb { \\theta } ) , \\pmb { f } _ { T } ( \\mathcal { D } _ { i } ; \\pmb { \\theta } ^ { \\prime } , \\mathcal { D } ) ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            811,
+            758,
+            829
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": ". The notation for teacher signal changes from ${ \\pmb f } _ { T } ( { \\bf x } _ { \\bf i } ; { \\pmb \\theta } ^ { \\prime } )$ to ${ \\pmb f } _ { T } ( \\mathcal { D } _ { i } ; { \\pmb \\theta } ^ { \\prime } , \\mathcal { D } )$ because the teacher model requires the label $y _ { i }$ and at least part of the dataset to effectively utilize dataset information in our KD. We note that implementations of traditional KD by (Hinton et al., 2015), Born-Again Network (Furlanello et al., 2018) and Snapshot Distillation (Yang et al., 2018) can be seen as special cases of the above general formulation whose distilled information only depends on the input sample while ignoring others. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3 TEACHER SIGNAL UTILIZING PEER SAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            531,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The most straightforward idea of leveraging other samples to help is to utilize similar samples. Given a training sample $\\mathcal { D } _ { i } = ( \\mathbf { x _ { i } } , y _ { i } )$ , we random select $n$ peer samples in the same category of training set, noted by ",
+        "bbox": [
+            173,
+            132,
+            825,
+            176
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/20ebcbf6fb90e2318d1ddbfb3dc7c1d249ee488946f52dfb11a0934b504c17e9.jpg",
+        "text": "$$\nY _ { y _ { i } } = \\{ ( \\mathbf { x _ { k _ { 1 } } } , y _ { i } ) , ( \\mathbf { x _ { k _ { 2 } } } , y _ { i } ) , . . . , ( \\mathbf { x _ { k _ { n } } } , y _ { i } ) \\} \\subset \\mathcal { D }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            184,
+            658,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": ". With the help of these peer samples, we get teaching signal with respect to $D _ { i }$ as below ",
+        "bbox": [
+            174,
+            215,
+            756,
+            232
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/36b33cede92a905d16e92c82137f774c37c029b1e51b51d160edb91d0563f0e9.jpg",
+        "text": "$$\n\\pmb { f } _ { T } ( { \\mathscr { D } _ { i } ; \\pmb { \\theta } ^ { \\prime } } , { \\mathscr { D } } ) = \\pmb { f } _ { T } ( \\mathscr { D } _ { i } ; \\pmb { \\theta } ^ { \\prime } , Y _ { y _ { i } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            244,
+            607,
+            262
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": ". As shown above, we do not focus on how one single instance could provide the student model with secondary information that is not directly available from the dataset labels (Hinton et al., 2015; Yang et al., 2019); rather, we aim to find a general trend that reveals the extent of some statistical characteristics, e.g. inter-class similarity, by utilizing peer samples. There are two benefits. First, since such information is relatively static or stable for a period of training procedure and can be shared among samples of the same category, it is cheap to obtain and store in memory. Second, teaching signals voted by a cluster of samples may offer more reliable secondary information comparing with that produced by a sub-optimized checkpoint found before training completes. ",
+        "bbox": [
+            173,
+            276,
+            825,
+            388
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 DUPS IMPLEMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            412,
+            390,
+            428
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Similar to SnapShot Distillation proposed by (Yang et al., 2018), our method achieves on-the-fly distillation within one generation of training by dividing the training process into $m$ stages, with each stage consisting of $t$ epochs. However, an important difference is that our method do not strongly depend on cyclic learning rate for obtaining reliable teaching signal. Let $M$ be the set of such stages and $T$ be the set of epochs. Then $M = \\{ M _ { 1 } , M _ { 2 } , . . . , M _ { m } \\}$ , and for each $i$ such that $1 \\leq i \\leq m$ , $M _ { i } = \\{ T _ { ( i - 1 ) \\times t + 1 } , T _ { ( i - 1 ) \\times t + 2 } , \\ldots , T _ { ( i - 1 ) \\times t + ( t - 1 ) } , T _ { i \\times t } \\} .$ . We follow the algorithm in Alg. 1 to implement DUPS. For a sample $\\mathcal { D } _ { i } = ( \\mathbf { x _ { i } } , y _ { i } )$ , its peer samples, denoted by $Y _ { y _ { i } }$ , are a random subset of the all samples found in the same category. Hence, ",
+        "bbox": [
+            173,
+            441,
+            826,
+            556
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fce1533d8227a401213d7d3f57889d2387cba31ed98b96adf3f5afd097b75fc2.jpg",
+        "text": "$$\nY _ { y _ { i } } \\subset \\{ ( \\mathbf { x } , y ) \\in \\mathcal { D } \\mid y = y _ { i } \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            570,
+            594,
+            588
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": ". For specific implementation, we share teacher signal among samples of the same category. Thus, Eq. 3 is further simplified to ",
+        "bbox": [
+            173,
+            602,
+            823,
+            631
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/faee4db134974fd82c7e447764f1a986ecb3d995ef197baec6d1ff2ee956852c.jpg",
+        "text": "$$\n\\forall D _ { j } \\in \\{ ( \\mathbf { x } , y ) \\in \\mathcal { D } \\mid y = y _ { i } \\} , f _ { T } ( \\mathcal { D } _ { j } ; \\pmb { \\theta } ^ { \\prime } , \\mathcal { D } ) = f _ { T } ( Y _ { y _ { i } } ; \\pmb { \\theta } ^ { \\prime } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            660,
+            696,
+            679
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": ", which means the teacher signal ${ \\pmb f } _ { T }$ for sample $D _ { j } = ( \\mathbf { x _ { j } } , y _ { j } )$ only depends on the sample’s label $y _ { j }$ but not its data input $\\mathbf { x _ { j } }$ . $\\mathcal { D }$ is omitted in $\\pmb { f } _ { T } ( Y _ { y _ { i } } ; \\pmb { \\theta } ^ { \\prime } )$ as the last parameter because only $Y _ { y _ { j } } \\subset \\mathcal { D }$ is utilized. ",
+        "bbox": [
+            174,
+            699,
+            826,
+            742
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Formally, let the teacher signal for each category with label $y _ { i }$ at stage $M _ { n }$ be $f _ { T } ^ { n } ( Y _ { y _ { i } } ; \\pmb { \\theta } ^ { \\prime } )$ , where $n$ is the index of the current training stage. We denote the checkpoint of student model $f _ { S }$ at the end of $n ^ { t h }$ stage be $\\pmb { \\theta } ^ { n }$ . We define $\\pmb { f } _ { T } ^ { 1 } ( Y _ { y _ { i } } ; \\mathbf { \\bar { \\theta } } ^ { \\prime } )$ to be zero. The rest of teacher signals are computed based on ",
+        "bbox": [
+            173,
+            748,
+            825,
+            806
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9326d7abd246b50579b0c05ceef7887ca90a368a21eb969b77a48be138f9a877.jpg",
+        "text": "$$\n\\pmb { f } _ { T } ^ { n } ( Y _ { y _ { i } } ; \\pmb { \\theta } ^ { \\prime } ) = \\frac { 1 } { \\| Y _ { y _ { i } } \\| } \\sum _ { ( \\mathbf { x } , y ) \\in Y _ { y _ { i } } } \\pmb { f } _ { S } ( \\mathbf { x } ; \\pmb { \\theta } ^ { n - 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            832,
+            643,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": ". The average softened logit of each category obtained at the last epoch of each stage is used as the “teacher model” for training of student model at next stage. In total, there are $m - 1$ iterations of knowledge distillation between “teacher models” and “student models” in the whole training process. ",
+        "bbox": [
+            171,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Input: Current epoch $T _ { c } \\in M _ { n }$ , the set of training samples $\\mathcal { D }$ Output: Improved neural network model parameters $\\pmb \\theta$ ",
+        "bbox": [
+            165,
+            162,
+            580,
+            190
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1 for each batch $\\boldsymbol { B }$ in $\\mathcal { D }$ do ",
+        "bbox": [
+            161,
+            191,
+            341,
+            204
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2 for each sample $( \\mathbf { x _ { j } } , y _ { j } )$ in $\\boldsymbol { B }$ do   \n3 Compute the logits $l$ and prediction ${ \\bf \\nabla } f _ { S } ( { \\bf x _ { j } } )$ produced by the current model;   \n4 Compute cross entropy loss $\\mathcal { L } _ { C E }$ using $f _ { S } ( \\bf { x } _ { j } )$ and ${ \\tt y } _ { j }$   \n5 if $M _ { n }$ is the first stage $M _ { 1 }$ then   \n6 Set knowledge distillation loss $\\mathcal { L } _ { K D }$ to be ${ f _ { T } ^ { 1 } } ( Y _ { y _ { j } } ; \\pmb { \\theta } ^ { \\prime } ) = 0$ ;   \n7 else   \n8 Compute knowledge distillation loss $\\mathcal { L } _ { K D }$ using $l$ and $f _ { T } ^ { n } ( Y _ { y _ { j } } ; \\pmb { \\theta } ^ { \\prime } )$ where   \n$Y _ { y _ { j } } = \\{ ( \\mathbf { x } , y ) \\in \\mathcal { D } \\mid y = y _ { j } \\}$ ;   \n9 Obtain the total loss (Eq 2);   \n10 Calculate the average loss of this batch;   \n11 Update model parameters; ",
+        "bbox": [
+            160,
+            205,
+            728,
+            369
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "12 if $T _ { c }$ is the last epoch in the current stage $M _ { n }$ then ",
+        "bbox": [
+            156,
+            375,
+            511,
+            388
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "13 Update $\\pmb { f } _ { T } ^ { n - 1 } ( Y _ { y _ { p } } ; \\pmb { \\theta } ^ { \\prime } )$ to $f _ { T } ^ { n } ( Y _ { y _ { p } } ; \\pmb { \\theta } ^ { \\prime } )$ using the corresponding set of peer samples $Y _ { y _ { p } }$ for all $y _ { p } \\in \\{ 1 , 2 , \\ldots , C \\}$ (Eq 5); ",
+        "bbox": [
+            156,
+            390,
+            803,
+            421
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            452,
+            326,
+            468
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 TASKS AND DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            483,
+            370,
+            498
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Image Classification We use CIFAR100 (Krizhevsky, 2009) and ImageNet (Deng et al., 2009) to test the performance of DUPS on image classification task. CIFAR 100 contains RGB images categorized into 100 classes, with each class composing 600 images. There are 500 training images and 100 testing images in each class. ImageNet is a tree-structured image database created according to the WordNet hierarchy. It consists of more than 20K categories and a total of 14 million images. We use the popular subset ILSVRC2012 which containing 1.3M images covering 1K categories. We do not conduct experiments on CIFAR10 because it has been empirically observed that, due to the lack of fine-level categorization in CIFAR10, neural networks do not significantly benefit from distillations between teacher and student models (Yang et al., 2018; Furlanello et al., 2018). ",
+        "bbox": [
+            174,
+            510,
+            825,
+            636
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Transfer Learning We use ImageNet as the source dataset and have 4 different datasets as the target dataset in the transfer learning task, covering typical types of plants, animals, objects and texture . The 4 target datasets are (1) Flower102 (Nilsback & Zisserman, 2008) which contains 102 categories of 8189 flower images, (2) Caltech-UCSD Birds-200-2011 (Wah et al., 2011), which has 11,788 images classified into 200 categories, (3) FGVC-Aircraft (Maji et al., 2013) which composes 10,000 images of aircraft across 100 aircraft models, and (4) Describable Textures Dataset (DTD) (Cimpoi et al., 2015) which is a texture database, consisting of 5640 images, organized according to a list of 47 terms (categories). ",
+        "bbox": [
+            174,
+            651,
+            825,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Natural Language Processing We use Penn Tree Bank (PTB) dataset (Marcus et al., 1993) to evaluate the performance of DUPS on language modeling. ",
+        "bbox": [
+            174,
+            780,
+            823,
+            809
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPERIMENT SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            827,
+            382,
+            842
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Image Classification We train all models except DenseNet for image classification in 160 epochs. For DenseNet we train 240 epochs because it converges slower. The initial learning rate is 0.1 for all architectures. Training batch size is 64. We use standard SGD optimizer with momentum 0.9 and weight decay 0.0001. We apply standard data augmentation the same way as the Pytorch official examples on both CIFAR100 and ImageNet classification task. For CIFAR100, we pad the input ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Test accuracy on CIFAR100. SGD refers to models trained with standard Stochastic Gradient Descent optimizer. LS are models improved by using Label Smoothing technique. SD are the models trained with SnapShot Distillation method. Finally, DUPS and ${ \\mathrm { D U P S } } +$ are our methods proposed in this paper. The difference between DUPS and ${ \\mathrm { D U P S } } +$ is that ${ \\mathrm { D U P S } } +$ uses cyclic learning rate while DUPS does not. ",
+        "bbox": [
+            173,
+            101,
+            825,
+            170
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/235f993c6bc0c6d6510b8dd6364bd14eecd09afbb9f6f37ca784b9716e1413e4.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>SGD</td><td>LS</td><td>DUPS</td><td>SD</td><td>DUPS+</td></tr><tr><td>PreActResNet18</td><td>0.7646</td><td>0.7795</td><td>0.7785</td><td>0.7729</td><td>0.7794</td></tr><tr><td>PreActResNet34</td><td>0.7701</td><td>0.7729</td><td>0.7823</td><td>0.7665</td><td>0.7785</td></tr><tr><td>PreActResNet50</td><td>0.7687</td><td>0.7798</td><td>0.7847</td><td>0.7809</td><td>0.7877</td></tr><tr><td>PreActResNet101</td><td>0.7756</td><td>0.7829</td><td>0.7882</td><td>0.7788</td><td>0.7899</td></tr><tr><td>DenseNet40(240)</td><td>0.7003</td><td>0.7034</td><td>0.7101</td><td>0.7115</td><td>0.7174</td></tr><tr><td>DenseNet100(240)</td><td>0.7515</td><td>0.7559</td><td>0.7557</td><td>0.7657</td><td>0.7617</td></tr><tr><td>WideResNet28x10</td><td>0.7968</td><td>0.7996</td><td>0.8028</td><td>0.8013</td><td>0.8062</td></tr><tr><td>ResNeXt29_8x64d</td><td>0.8017</td><td>0.8103</td><td>0.8184</td><td>=</td><td>=</td></tr></table>",
+        "bbox": [
+            191,
+            188,
+            807,
+            319
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "images by 4 pixels, and then randomly crop a sub-region of $3 2 \\times 3 2$ and randomly do a horizontal flip. For ImageNet, we first randomly crop a sub-region of $2 2 4 \\times 2 2 4$ and randomly do a horizontal flip. We normalize the input data as done in common practice. ",
+        "bbox": [
+            174,
+            347,
+            823,
+            388
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Transfer Learning We use ResNet-101 as the base model to apply DUPS. We train the model with 40 epochs and the batch size for training is 64. SGD optimizer is used with a momentum of 0.9. The initial learning rate is set to 0.01 and the weight decay is set to 0.0001. We use exactly the same data augmentation methods as in ImageNet classification task. ",
+        "bbox": [
+            174,
+            404,
+            825,
+            460
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Natural Language Processing We validate the performance of DUPS on three regularized LSTM models with varying depth. For the large model, we use 1500 hidden units and train 55 epochs. The learning rate decays by $1 / 1 . 5$ after 15 epochs. Its dropout rate is set to be 0.65 and dropout is applied to all non-recurrent connections. The medium model consists of 650 hidden units. We train it with 40 epochs. The learning rate decays by 0.8 after 5 epochs. Its dropout rate is 0.5. The small model has 200 hidden units. It is trained in 15 epochs. The learning rate remains as the initial value for 4 epochs and then starts to decay at the rate of 0.5. No dropout is used in the small model. For all three models, the initial learning rate is 20. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            587
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While training DUPS to compare with models trained with SGD optimizer or label smoothing technique in the three tasks, we use cosine annealing policy to update learning rates for all these models. In order to make fair comparisons with Snapshot Distillation, we upgrade our DUPS with cyclic learning rate policy, which is named ${ \\mathrm { D U P S } } +$ . Within each cycle , ${ \\mathrm { D U P S } } +$ uses cosine annealing learning rate. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            664
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For hyper-parameters specific to DUPS, we also use a common setting for all tasks following instructions from some empirical studies. We set $\\lambda _ { C E }$ to 0.8 and $\\lambda _ { K D }$ to 0.2. The Kullback Leibler divergence is used to calculate knowledge distillation term. We use temperature of 6 to soften the logits. We divide the training process into 10 stages for image classification tasks and 5 stages for transfer learning and language model tasks. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            741
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 EXPERIMENT RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            757,
+            375,
+            771
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We present our experiment results and give insights into the advantages as well as disadvantages using DUPS. We achieve this by comparing DUPS with models trained with SGD, and sometimes with closely related algorithms, namely Label Smoothing and Snapshot Distillation. Although SnapShot Ensembles (Huang et al., 2017) also offers ideas on which we further develop, we do not carry out duplicate experiments to compare with it because (Yang et al., 2018) have already made comparisons between Snapshot Distillation and SnapShot Ensembles. Therefore, we directly compare our proposed DUPS with SnapShot Distillation. ",
+        "bbox": [
+            174,
+            782,
+            825,
+            880
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Image Classification Table. 1 shows that our DUPS implementation consistently and significantly improve baseline models in accuracy for the vast majority of neural network architectures we tested. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9a160f141a37c91706410339e5366105a039d4c777f586fea20914cfd9692f47.jpg",
+        "table_caption": [
+            "Table 2: Training Time of Different Algorithms on PreActResNet50 and WideResNet28x10. All abbreviations follow the same rule as in Table. 1. We run experiments on Tesla V100 GPUs and normalize the training time of SGD to 1 for simplified comparison. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>SGD</td><td>LS</td><td>SD</td><td>DUPS</td></tr><tr><td>PreActResNet50</td><td>1</td><td>~1</td><td>1.32</td><td>1.04</td></tr><tr><td>WideResNet28x10</td><td>1</td><td>~1</td><td>1.27</td><td>1.01</td></tr></table>",
+        "bbox": [
+            240,
+            160,
+            759,
+            207
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/3c4c764e25c9ff1728aa21e2e573484f2cc7b45ff44f239646090d6c9cbd1a16.jpg",
+        "table_caption": [
+            "Table 3: Top-1 Test accuracy on ImageNet. All abbreviations follow the same rule as in Table. 1. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>SGD</td><td>LS</td><td>DUPS</td></tr><tr><td>ResNet50</td><td>76.58</td><td>76.69</td><td>77.58</td></tr><tr><td>ResNet101</td><td>77.86</td><td>78.41</td><td>78.74</td></tr><tr><td>ResNet152</td><td>78.17</td><td>78.63</td><td>79.06</td></tr></table>",
+        "bbox": [
+            281,
+            256,
+            715,
+            318
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The improvement is generally within $1 \\% - 2 \\%$ in comparison to models trained with the standard SGD optimizer. We notice that more complex architectures do not always perform better than simpler ones, while DUPS achieves stable improvement. We can observe a similar trend in Table. 3 when we apply DUPS to different models on ImageNet. ",
+        "bbox": [
+            174,
+            348,
+            825,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the majority of the models we tested, DUPS also outperforms Label Smoothing (LS) in image classification. Although DUPS does not beat LS on PreActResNet18 and DenseNet100, the difference is relatively marginal. When compared with a recently proposed KD method SnapShot Distillation, DUPS shows comparable performance even though the SD uses a more complicated learning rate policy. We also demonstrate that ${ \\mathrm { D U P S } } +$ which combines cyclic learning rate outperforms SD in most cases. However we noticed that leveraging cyclic learning rate doesn’t always bring benefit. In addition, DUPS obtains the improved results with significantly less training time than that SD needs as showed in Table. 2. ",
+        "bbox": [
+            174,
+            410,
+            825,
+            521
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Transfer Learning We fixed our test model to be ResNet101 and perform experiments on the chosen datasets. Results in Table. 4 indicate that, compared with models trained using SGD, DUPS improves the transfer learning outcomes on all four datasets, and the improvements range from $0 . 4 6 \\%$ to $1 . 7 8 \\%$ . These results testify that DUPS can enhance model performance on varying datasets. ",
+        "bbox": [
+            176,
+            537,
+            823,
+            593
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In contrast, LS does not always yield positively improved results. Furthermore, the extent of improvement LS brings is considerably less than that of DUPS, as shown by the statistics. ",
+        "bbox": [
+            174,
+            601,
+            821,
+            628
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Natural Language Processing Last but not least, we investigate the effectiveness of DUPS on language modeling. As shown in Table 5, the use of DUPS reduces the perplexity value by a proportion of $1 . 5 \\% { \\sim } 4 . 1 \\%$ on all three models. Note that the model displays better performance when the perplexity value is low in language modeling. Since DUPS significantly lowers the perplexity values to both small and large size of the LSTM models, its effectiveness is not hindered by scaling the size of the model in this task. This flexibility is another advantage of DUPS. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            727
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 DISCUSSIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            744,
+            310,
+            758
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here we give a short discussion about how and why DUPS brings benefits. We first demonstrate some empirical characteristics of DUPS observed in our experiments. We plot the learning curve of the whole training procedure of PreActResNet18 as Fig. 1. For better demonstration purpose, we divide the training process into only 4 stages for DUPS training, with each stage consisting of 40 epochs. We observe that SGD and DUPS display almost the same standard of performance in the first stage as expected. While at the 41th epoch, both training and test accuracy of DUPS get a sharp rise due to involving teacher signal generated in the 40th epoch. Then both training and test accuracy drop slightly for a few epochs, and then return to the trend of slowly rising for the remaining epochs until next stage. A similar phenomenon also appears at the beginning of next stage, although the magnitude of accuracy improvement becomes much more smaller. As the model reaches the beginning of final stage, we no longer see increases in accuracy since training is nearly saturated. We notice that since the first sharp rising, DUPS continuously outperforms SGD by a stable gap for the following training epochs until convergence. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/418a0278374b2213701af9771e47b9570f6fcfd47255df59db051e2b07996fb5.jpg",
+        "table_caption": [
+            "Table 4: Test accuracy using ResNet101 on various datasets. All abbreviations follow the same rule as in Table. 1 or explained in Section 4.1. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>SGD</td><td>LS</td><td>DUPS</td></tr><tr><td>Flower102</td><td>0.9179</td><td>0.9279</td><td>0.9294</td></tr><tr><td>FGVC_Aircraft</td><td>0.7741</td><td>0.7675</td><td>0.7787</td></tr><tr><td>DTD</td><td>0.6646</td><td>0.6705</td><td>0.6824</td></tr><tr><td>CUB_200_2011</td><td>0.8172</td><td>0.8152</td><td>0.8246</td></tr></table>",
+        "bbox": [
+            282,
+            145,
+            715,
+            219
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e1530bf2b3f90d08ed8ec25661811fcdc3dc23efcad15c681600e35248060f22.jpg",
+        "table_caption": [
+            "Table 5: Perplexity value of the model using LSTM on Penn Treebank. Lower is better. All abbreviations follow the same rule as in Table. 1 or explained in Section 4.1. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model Size</td><td>SGD</td><td>LS</td><td>DUPS</td></tr><tr><td>Small</td><td>129.7</td><td>129.1</td><td>125.4</td></tr><tr><td>Medium</td><td>95.3</td><td>96.7</td><td>93.9</td></tr><tr><td>Large</td><td>89.2</td><td>88.7</td><td>85.7</td></tr></table>",
+        "bbox": [
+            282,
+            282,
+            715,
+            343
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            372,
+            823,
+            401
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also investigate the influence of different choices of hyper-parameters specific to DUPS. The most important two are the number of stages and number of random peer samples. We run a grid search method to validate different combinations of these two variables. We use update intervals, or equivalently number of epochs per stage, instead of number of stages for clarity in this experiments. In Fig. 2 we see that performance of DUPS does not seem to be very sensitive to most combinations of the hyperparameters. When the number of peer samples increases to 5 or more, model accuracy tends to be over $7 7 . 3 \\%$ . Even when the number of peer samples is low, a good choice of the value of update interval can boost the model performance significantly. For example, when number of peer samples is 1 and update interval is set to be between 20 to 40, DUPS still delivers satisfying results which is comparable to its best performance. Low accuracy of the model only happens consistently when the value of update interval is large. If update interval is set to 80, the model, teacher-student knowledge transfer only takes place once during the whole training process. Consequently, the opportunity to distill the knowledge obtained from the dataset is too rare for the model to benefit from DUPS. ",
+        "bbox": [
+            174,
+            407,
+            825,
+            602
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            621,
+            318,
+            638
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have introduced a general framework for one-generation KD: We incorporate the information contained within the dataset into teacher-student optimization. We have also proposed an effective implementation of this general framework named DUPS. With extensive experiments, this simple yet effective algorithm is verified to be effective in improving model performance in tasks like image classification, transfer learning and language modeling with almost no additional cost in training resources. The demonstrated success of DUPS imply that utilizing dataset information during training potentially allow us to gain even more benefits. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            751
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            772,
+            285,
+            786
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Zeynep Akata, Florent Perronnin, Zaid Harchaoui, and Cordelia Schmid. Label-embedding for image classification. IEEE transactions on pattern analysis and machine intelligence, 38(7): 1425–1438, 2015. ",
+        "bbox": [
+            173,
+            794,
+            825,
+            835
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Rohan Anil, Gabriel Pereyra, Alexandre Passos, Robert Orm ´ andi, George E. Dahl, and Geof- ´ frey E. Hinton. Large scale distributed neural network training through online distillation. ArXiv, abs/1804.03235, 2018. ",
+        "bbox": [
+            173,
+            844,
+            821,
+            886
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Hessam Bagherinezhad, Maxwell Horton, Mohammad Rastegari, and Ali Farhadi. Label refinery: Improving imagenet classification through label progression. ArXiv, abs/1805.02641, 2018. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/218ae22caf35ae5d9c1bdbd085e38820c13df95244eadc4c925bd92077db863d.jpg",
+        "image_caption": [
+            "Figure 1: SGD and DUPS Learning Curves on PreActResNet18 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            117,
+            496,
+            301
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/c993c9b619198602681a11af305f6f44f51861d85183ad63060e3f262cd83d73.jpg",
+        "image_caption": [
+            "Figure 2: DUPS hyperparameter experiment on PreActResNet18 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            565,
+            113,
+            821,
+            294
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Cristian Bucilua, Rich Caruana, and Alexandru Niculescu-Mizil. Model compression. In ˇ Proceedings of the 12th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’06, pp. 535–541, New York, NY, USA, 2006. ACM. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            414
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Guobin Chen, Wongun Choi, Xiang Yu, Tony X. Han, and Manmohan Krishna Chandraker. Learning efficient object detection models with knowledge distillation. In NIPS, 2017. ",
+        "bbox": [
+            173,
+            422,
+            820,
+            452
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mircea Cimpoi, Subhransu Maji, and Andrea Vedaldi. Deep filter banks for texture recognition and segmentation. 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 3828–3836, 2015. ",
+        "bbox": [
+            173,
+            459,
+            825,
+            501
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Alexander C Berg, Kai Li, and Li Fei-Fei. What does classifying more than 10,000 image categories tell us? In European conference on computer vision, pp. 71–84. Springer, 2010. ",
+        "bbox": [
+            173,
+            511,
+            823,
+            540
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jun Deng, Wei Dong, Richard Socher, Li-Jia Li, Kuntai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. 2009 IEEE Conference on Computer Vision and Pattern Recognition, pp. 248–255, 2009. ",
+        "bbox": [
+            173,
+            547,
+            825,
+            589
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tommaso Furlanello, Zachary C. Lipton, Michael Tschannen, Laurent Itti, and Anima Anandkumar. Born again neural networks. In ICML, 2018. ",
+        "bbox": [
+            173,
+            598,
+            821,
+            627
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sangchul Hahn and Heeyoul Choi. Self-knowledge distillation in natural language processing. arXiv preprint arXiv:1908.01851, 2019. ",
+        "bbox": [
+            174,
+            636,
+            823,
+            664
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Byeongho Heo, Minsik Lee, Sangdoo Yun, and Jin Young Choi. Knowledge transfer via distillation of activation boundaries formed by hidden neurons. ArXiv, abs/1811.03233, 2018. ",
+        "bbox": [
+            174,
+            672,
+            823,
+            702
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E. Hinton, Oriol Vinyals, and Jeffrey Dean. Distilling the knowledge in a neural network. ArXiv, abs/1503.02531, 2015. ",
+        "bbox": [
+            174,
+            709,
+            823,
+            738
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Yixuan Li, Geoff Pleiss, Zhuang Liu, John E. Hopcroft, and Kilian Q. Weinberger. Snapshot ensembles: Train 1, get m for free. ArXiv, abs/1704.00109, 2017. ",
+        "bbox": [
+            173,
+            747,
+            823,
+            776
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            173,
+            784,
+            692,
+            799
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xu Lan, Xiatian Zhu, and Shaogang Gong. Knowledge distillation by on-the-fly native ensemble. In NeurIPS, 2018a. ",
+        "bbox": [
+            173,
+            806,
+            818,
+            835
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xu Lan, Xiatian Zhu, and Shaogang Gong. Self-referenced deep learning. ArXiv, abs/1811.07598, 2018b. ",
+        "bbox": [
+            173,
+            844,
+            821,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xingjian Li, Haoyi Xiong, Hanchao Wang, Yuxuan Rao, Liping Liu, and Jun Huan. Delta: Deep learning transfer using feature map with attention for convolutional networks. ArXiv, abs/1901.09229, 2019. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. In ICLR, 2016. ",
+        "bbox": [
+            169,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Subhransu Maji, Esa Rahtu, Juho Kannala, Matthew B. Blaschko, and Andrea Vedaldi. Fine-grained visual classification of aircraft. ArXiv, abs/1306.5151, 2013. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mitchell P. Marcus, Beatrice Santorini, and Mary Ann Marcinkiewicz. Building a large annotated corpus of english: The penn treebank. Computational Linguistics, 19:313–330, 1993. ",
+        "bbox": [
+            171,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rafael J. Muller, Simon Kornblith, and Geoffrey E. Hinton. When does label smoothing help? ArXiv, abs/1906.02629, 2019. ",
+        "bbox": [
+            171,
+            215,
+            823,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Maria-Elena Nilsback and Andrew Zisserman. Automated flower classification over a large number of classes. 2008 Sixth Indian Conference on Computer Vision, Graphics & Image Processing, pp. 722–729, 2008. ",
+        "bbox": [
+            174,
+            253,
+            823,
+            296
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Pereyra, George Tucker, Jan Chorowski, Łukasz Kaiser, and Geoffrey Hinton. Regularizing neural networks by penalizing confident output distributions. arXiv preprint arXiv:1701.06548, 2017. ",
+        "bbox": [
+            174,
+            306,
+            825,
+            348
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adriana Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. Fitnets: Hints for thin deep nets. CoRR, abs/1412.6550, 2014. ",
+        "bbox": [
+            178,
+            357,
+            820,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2818–2826, 2016. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            438
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nakul Verma, Dhruv Mahajan, Sundararajan Sellamanickam, and Vinod Nair. Learning hierarchical similarity metrics. In 2012 IEEE conference on computer vision and pattern recognition, pp. 2280–2287. IEEE, 2012. ",
+        "bbox": [
+            173,
+            446,
+            825,
+            489
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "C. Wah, S. Branson, P. Welinder, P. Perona, and S. Belongie. The Caltech-UCSD Birds-200-2011 Dataset. Technical Report CNS-TR-2011-001, California Institute of Technology, 2011. ",
+        "bbox": [
+            174,
+            497,
+            823,
+            527
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tongzhou Wang, Jun-Yan Zhu, Antonio Torralba, and Alexei A. Efros. Dataset distillation. ArXiv, abs/1811.10959, 2019. ",
+        "bbox": [
+            174,
+            535,
+            823,
+            564
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chenglin Yang, Lingxi Xie, Chi Su, and Alan L. Yuille. Snapshot distillation: Teacher-student optimization in one generation. ArXiv, abs/1812.00123, 2018. ",
+        "bbox": [
+            173,
+            573,
+            823,
+            603
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chenglin Yang, Lingxi Xie, Siyuan Qiao, and Alan L. Yuille. Training deep neural networks in generations: A more tolerant teacher educates better students. In AAAI, 2019. ",
+        "bbox": [
+            173,
+            611,
+            823,
+            641
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Junho Yim, Donggyu Joo, Jihoon Bae, and Junmo Kim. A gift from knowledge distillation: Fast optimization, network minimization and transfer learning. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), volume 2, 2017. ",
+        "bbox": [
+            173,
+            648,
+            826,
+            693
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ruichi Yu, Ang Li, Vlad I. Morariu, and Larry S. Davis. Visual relationship detection with internal and external linguistic knowledge distillation. 2017 IEEE International Conference on Computer Vision (ICCV), pp. 1068–1076, 2017. ",
+        "bbox": [
+            174,
+            700,
+            821,
+            743
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Paying more attention to attention: Improving the performance of convolutional neural networks via attention transfer. arXiv preprint arXiv:1612.03928, 2016. ",
+        "bbox": [
+            176,
+            752,
+            821,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Linfeng Zhang, Jiebo Song, Anni Gao, Jingwei Chen, Chenglong Bao, and Kaisheng Ma. Be your own teacher: Improve the performance of convolutional neural networks via self distillation. ArXiv, abs/1905.08094, 2019. ",
+        "bbox": [
+            173,
+            804,
+            825,
+            847
+        ],
+        "page_idx": 9
+    }
+]

parse/train/S1Bb3D5gg/S1Bb3D5gg.md

@@ -0,0 +1,258 @@
+# LEARNING END-TO-END GOAL-ORIENTED DIALOG
+
+Antoine Bordes, Y-Lan Boureau & Jason Weston   
+Facebook AI Research   
+New York, USA   
+{abordes, ylan, jase}@fb.com
+
+# ABSTRACT
+
+Traditional dialog systems used in goal-oriented applications require a lot of domain-specific handcrafting, which hinders scaling up to new domains. Endto-end dialog systems, in which all components are trained from the dialogs themselves, escape this limitation. But the encouraging success recently obtained in chit-chat dialog may not carry over to goal-oriented settings. This paper proposes a testbed to break down the strengths and shortcomings of end-to-end dialog systems in goal-oriented applications. Set in the context of restaurant reservation, our tasks require manipulating sentences and symbols in order to properly conduct conversations, issue API calls and use the outputs of such calls. We show that an end-to-end dialog system based on Memory Networks can reach promising, yet imperfect, performance and learn to perform non-trivial operations. We confirm those results by comparing our system to a hand-crafted slot-filling baseline on data from the second Dialog State Tracking Challenge (Henderson et al., 2014a). We show similar result patterns on data extracted from an online concierge service.
+
+# 1 INTRODUCTION
+
+The most useful applications of dialog systems such as digital personal assistants or bots are currently goal-oriented and transactional: the system needs to understand a user request and complete a related task with a clear goal within a limited number of dialog turns. The workhorse of traditional dialog systems is slot-filling (Lemon et al., 2006; Wang and Lemon, 2013; Young et al., 2013) which predefines the structure of a dialog state as a set of slots to be filled during the dialog. For a restaurant reservation system, such slots can be the location, price range or type of cuisine of a restaurant. Slot-filling has proven reliable but is inherently hard to scale to new domains: it is impossible to manually encode all features and slots that users might refer to in a conversation.
+
+End-to-end dialog systems, usually based on neural networks (Shang et al., 2015; Vinyals and Le, 2015; Sordoni et al., 2015; Serban et al., 2015a; Dodge et al., 2016), escape such limitations: all their components are directly trained on past dialogs, with no assumption on the domain or dialog state structure, thus making it easy to automatically scale up to new domains. They have shown promising performance in non goal-oriented chit-chat settings, where they were trained to predict the next utterance in social media and forum threads (Ritter et al., 2011; Wang et al., 2013; Lowe et al., 2015) or movie conversations (Banchs, 2012). But the performance achieved on chit-chat may not necessarily carry over to goal-oriented conversations. As illustrated in Figure 1 in a restaurant reservation scenario, conducting goal-oriented dialog requires skills that go beyond language modeling, e.g., asking questions to clearly define a user request, querying Knowledge Bases (KBs), interpreting results from queries to display options to users or completing a transaction. This makes it hard to ascertain how well end-to-end dialog models would do, especially since evaluating chit-chat performance in itself is not straightforward (Liu et al., 2016). In particular, it is unclear if end-to-end models are in a position to replace traditional dialog methods in a goal-directed setting: can end-to-end dialog models be competitive with traditional methods even in the well-defined narrow-domain tasks where they excel? If not, where do they fall short?
+
+This paper aims to make it easier to address these questions by proposing an open resource to test endto-end dialog systems in a way that 1) favors reproducibility and comparisons, and 2) is lightweight and easy to use. We aim to break down a goal-directed objective into several subtasks to test some crucial capabilities that dialog systems should have (and hence provide error analysis by design).
+
+![](images/93a7270b6412ec58156b4a762642cfa63137c3579e6070b83baeb398f09dc8b1.jpg)  
+Figure 1: Goal-oriented dialog tasks. A user (in green) chats with a bot (in blue) to book a table at a restaurant. Models must predict bot utterances and API calls (in dark red). Task 1 tests the capacity of interpreting a request and asking the right questions to issue an API call. Task 2 checks the ability to modify an API call. Task 3 and 4 test the capacity of using outputs from an API call (in light red) to propose options (sorted by rating) and to provide extra-information. Task 5 combines everything.
+
+In the spirit of the bAbI tasks conceived as question answering testbeds (Weston et al., 2015b), we designed a set of five tasks within the goal-oriented context of restaurant reservation. Grounded with an underlying KB of restaurants and their properties (location, type of cuisine, etc.), these tasks cover several dialog stages and test if models can learn various abilities such as performing dialog management, querying KBs, interpreting the output of such queries to continue the conversation or dealing with new entities not appearing in dialogs from the training set. In addition to showing how the set of tasks we propose can be used to test the goal-directed capabilities of an end-to-end dialog system, we also propose results on two additional datasets extracted from real interactions with users, to confirm that the pattern of results observed in our tasks is indeed a good proxy for what would be observed on real data, with the added benefit of better reproducibility and interpretability.
+
+The goal here is explicitly not to improve the state of the art in the narrow domain of restaurant booking, but to take a narrow domain where traditional handcrafted dialog systems are known to perform well, and use that to gauge the strengths and weaknesses of current end-to-end systems with no domain knowledge. Solving our tasks requires manipulating both natural language and symbols from a KB. Evaluation uses two metrics, per-response and per-dialog accuracies, the latter tracking completion of the actual goal. Figure 1 depicts the tasks and Section 3 details them. Section 4 compares multiple methods on these tasks. As an end-to-end neural model, we tested Memory Networks (Weston et al., 2015a), an attention-based architecture that has proven competitive for non goal-oriented dialog (Dodge et al., 2016). Our experiments in Section 5 show that Memory Networks can be trained to perform non-trivial operations such as issuing API calls to KBs and manipulating entities unseen in training. We confirm our findings on real human-machine dialogs from the restaurant reservation dataset of the $2 ^ { n d }$ Dialog State Tracking Challenge, or DSTC2 (Henderson et al., 2014a), which we converted into our task format, showing that Memory Networks can outperform a dedicated slot-filling rule-based baseline. We also evaluate on a dataset of humanhuman dialogs extracted from an online concierge service that books restaurants for users. Overall, the per-response performance is encouraging, but the per-dialog one remains low, indicating that end-to-end models still need to improve before being able to reliably handle goal-oriented dialog.
+
+Table 1: Data used in this paper. Tasks 1-5 were generated using our simulator and share the same KB. Task 6 was converted from the $2 ^ { n d }$ Dialog State Tracking Challenge (Henderson et al., 2014a). Concierge is made of chats extracted from a real online concierge service. (∗) Tasks 1-5 have two test sets, one using the vocabulary of the training set and the other using out-of-vocabulary words.   
+
+<table><tr><td></td><td>Tasks</td><td>T1</td><td>T2</td><td>T3</td><td>T4</td><td>T5</td><td>T6</td><td>Concierge</td></tr><tr><td rowspan="4">DIALOGS Average statistics</td><td>Number of utterances:</td><td>12</td><td>17</td><td>43</td><td>15</td><td>55</td><td>54</td><td>8</td></tr><tr><td>- user utterances</td><td>5</td><td>7</td><td>7</td><td>4</td><td>13</td><td>6</td><td>4</td></tr><tr><td>- bot utterances</td><td>7</td><td>10</td><td>10</td><td>4</td><td>18</td><td>8</td><td>4</td></tr><tr><td>- outputs from API calls</td><td>0</td><td>0</td><td>23</td><td>7</td><td>24</td><td>40</td><td>0</td></tr><tr><td rowspan="4">DATASETS</td><td>Vocabulary size</td><td></td><td></td><td>3,747</td><td></td><td></td><td>1,229</td><td>8.629</td></tr><tr><td>Candidate set size</td><td></td><td></td><td>4,212</td><td></td><td></td><td>2,406</td><td>11,482</td></tr><tr><td>Training dialogs</td><td></td><td></td><td>1,000</td><td></td><td></td><td>1,618</td><td>3,249</td></tr><tr><td>Validation dialogs</td><td></td><td></td><td>1,000</td><td></td><td></td><td>500</td><td>403</td></tr><tr><td>Tasks1-5 share the same data source</td><td>Test dialogs</td><td></td><td></td><td>1,000(*)</td><td></td><td></td><td>1,117</td><td>402</td></tr></table>
+
+# 2 RELATED WORK
+
+The most successful goal-oriented dialog systems model conversation as partially observable Markov decision processes (POMDP) (Young et al., 2013). However, despite recent efforts to learn modules (Henderson et al., 2014b), they still require many hand-crafted features for the state and action space representations, which restrict their usage to narrow domains. Our simulation, used to generate goal-oriented datasets, can be seen as an equivalent of the user simulators used to train POMDP (Young et al., 2013; Pietquin and Hastie, 2013), but for training end-to-end systems.
+
+Serban et al. (2015b) list available corpora for training dialog systems. Unfortunately, no good resources exist to train and test end-to-end models in goal-oriented scenarios. Goal-oriented datasets are usually designed to train or test dialog state tracker components (Henderson et al., 2014a) and are hence of limited scale and not suitable for end-to-end learning (annotated at the state level and noisy). However, we do convert the Dialog State Tracking Challenge data into our framework. Some datasets are not open source, and require a particular license agreement or the participation to a challenge (e.g., the end-to-end task of DSTC4 (Kim et al., 2016)) or are proprietary (e.g., Chen et al. (2016)). Datasets are often based on interactions between users and existing systems (or ensemble of systems) like DSTC datasets, SFCore (Gašic et al., 2014) or ATIS (Dahl et al., 1994). This creates noise and makes it harder to interpret the errors of a model. Lastly, resources designed to connect dialog systems to users, in particular in the context of reinforcement learning, are usually built around a crowdsourcing setting such as Amazon Mechanical Turk, e.g., (Hixon et al., 2015; Wen et al., 2015; Su et al., 2015a;b). While this has clear advantages, it prevents reproducibility and consistent comparisons of methods in the exact same setting.
+
+The closest resource to ours might be the set of tasks described in (Dodge et al., 2016), since some of them can be seen as goal-oriented. However, those are question answering tasks rather than dialog, i.e. the bot only responds with answers, never questions, which does not reflect full conversation.
+
+# 3 GOAL-ORIENTED DIALOG TASKS
+
+All our tasks involve a restaurant reservation system, where the goal is to book a table at a restaurant. The first five tasks are generated by a simulation, the last one uses real human-bot dialogs. The data for all tasks is available at http://fb.ai/babi. We also give results on a proprietary dataset extracted from an online restaurant reservation concierge service with anonymized users.
+
+# 3.1 RESTAURANT RESERVATION SIMULATION
+
+The simulation is based on an underlying KB, whose facts contain the restaurants that can be booked and their properties. Each restaurant is defined by a type of cuisine (10 choices, e.g., French, Thai), a location (10 choices, e.g., London, Tokyo), a price range (cheap, moderate or expensive) and a rating (from 1 to 8). For simplicity, we assume that each restaurant only has availability for a single party size (2, 4, 6 or 8 people). Each restaurant also has an address and a phone number listed in the KB.
+
+The KB can be queried using API calls, which return the list of facts related to the corresponding restaurants. Each query must contain four fields: a location, a type of cuisine, a price range and a party size. It can return facts concerning one, several or no restaurant (depending on the party size).
+
+Using the KB, conversations are generated in the format shown in Figure 1. Each example is a dialog comprising utterances from a user and a bot, as well as API calls and the resulting facts. Dialogs are generated after creating a user request by sampling an entry for each of the four required fields: e.g. the request in Figure 1 is [cuisine: British, location: London, party size: six, price range: expensive]. We use natural language patterns to create user and bot utterances. There are 43 patterns for the user and 20 for the bot (the user can use up to 4 ways to say something, while the bot always uses the same). Those patterns are combined with the KB entities to form thousands of different utterances.
+
+# 3.1.1 TASK DEFINITIONS
+
+We now detail each task. Tasks 1 and 2 test dialog management to see if end-to-end systems can learn to implicitly track dialog state (never given explicitly), whereas Task 3 and 4 check if they can learn to use KB facts in a dialog setting. Task 3 also requires to learn to sort. Task 5 combines all tasks.
+
+Task 1: Issuing API calls A user request implicitly defines a query that can contain from 0 to 4 of the required fields (sampled uniformly; in Figure 1, it contains 3). The bot must ask questions for filling the missing fields and eventually generate the correct corresponding API call. The bot asks for information in a deterministic order, making prediction possible.
+
+Task 2: Updating API calls Starting by issuing an API call as in Task 1, users then ask to update their requests between 1 and 4 times (sampled uniformly). The order in which fields are updated is random. The bot must ask users if they are done with their updates and issue the updated API call.
+
+Task 3: Displaying options Given a user request, we query the KB using the corresponding API call and add the facts resulting from the call to the dialog history. The bot must propose options to users by listing the restaurant names sorted by their corresponding rating (from higher to lower) until users accept. For each option, users have a $2 5 \%$ chance of accepting. If they do, the bot must stop displaying options, otherwise propose the next one. Users always accept the option if this is the last remaining one. We only keep examples with API calls retrieving at least 3 options.
+
+Task 4: Providing extra information Given a user request, we sample a restaurant and start the dialog as if users had agreed to book a table there. We add all KB facts corresponding to it to the dialog. Users then ask for the phone number of the restaurant, its address or both, with proportions $2 5 \%$ , $2 5 \%$ and $50 \%$ respectively. The bot must learn to use the KB facts correctly to answer.
+
+Task 5: Conducting full dialogs We combine Tasks 1-4 to generate full dialogs just as in Figure 1.   
+Unlike in Task 3, we keep examples if API calls return at least 1 option instead of 3.
+
+# 3.1.2 DATASETS
+
+We want to test how well models handle entities appearing in the KB but not in the dialog training sets. We split types of cuisine and locations in half, and create two KBs, one with all facts about restaurants within the first halves and one with the rest. This yields two KBs of 4,200 facts and 600 restaurants each (5 types of cuisine $\times 5$ locations $\times 3$ price ranges $\times 8$ ratings) that only share price ranges, ratings and party sizes, but have disjoint sets of restaurants, locations, types of cuisine, phones and addresses. We use one of the KBs to generate the standard training, validation and test dialogs, and use the other KB only to generate test dialogs, termed Out-Of-Vocabulary (OOV) test sets.
+
+For training, systems have access to the training examples and both KBs. We then evaluate on both test sets, plain and OOV. Beyond the intrinsic difficulty of each task, the challenge on the OOV test sets is for models to generalize to new entities (restaurants, locations and cuisine types) unseen in any training dialog – something natively impossible for embedding methods. Ideally, models could, for instance, leverage information coming from the entities of the same type seen during training.
+
+We generate five datasets, one per task defined in 3.1.1. Table 1 gives their statistics. Training sets are relatively small (1,000 examples) to create realistic learning conditions. The dialogs from the training and test sets are different, never being based on the same user requests. Thus, we test if models can generalize to new combinations of fields. Dialog systems are evaluated in a ranking, not a generation, setting: at each turn of the dialog, we test whether they can predict bot utterances and API calls by selecting a candidate, not by generating it.1 Candidates are ranked from a set of all bot utterances and API calls appearing in training, validation and test sets (plain and OOV) for all tasks combined.
+
+# 3.2 DIALOG STATE TRACKING CHALLENGE
+
+Since our tasks rely on synthetically generated language for the user, we supplement our dataset with real human-bot dialogs. We use data from DSTC2 (Henderson et al., 2014a), that is also in the restaurant booking domain. Unlike our tasks, its user requests only require 3 fields: type of cuisine (91 choices), location (5 choices) and price range (3 choices). The dataset was originally designed for dialog state tracking hence every dialog turn is labeled with a state (a user intent $^ +$ slots) to be predicted. As our goal is to evaluate end-to-end training, we did not use that, but instead converted the data into the format of our 5 tasks and included it in the dataset as Task 6.
+
+We used the provided speech transcriptions to create the user and bot utterances, and given the dialog states we created the API calls to the KB and their outputs which we added to the dialogs. We also added ratings to the restaurants returned by the API calls, so that the options proposed by the bots can be consistently predicted (by using the highest rating). We did use the original test set but use a slightly different training/validation split. Our evaluation differs from the challenge (we do not predict the dialog state), so we cannot compare with the results from (Henderson et al., 2014a).
+
+This dataset has similar statistics to our Task 5 (see Table 1) but is harder. The dialogs are noisier and the bots made mistakes due to speech recognition errors or misinterpretations and also do not always have a deterministic behavior (the order in which they can ask for information varies).
+
+# 3.3 ONLINE CONCIERGE SERVICE
+
+Tasks 1-6 are, at least partially, artificial. This provides perfect control over their design (at least for Tasks 1-5), but no guarantee that good performance would carry over from such synthetic to more realistic conditions. To quantify this, we also evaluate the models from Section 4 on data extracted from a real online concierge service performing restaurant booking: users make requests through a text-based chat interface that are handled by human operators who can make API calls. All conversations are between native English speakers.
+
+We collected around 4k chats to create this extra dataset, denoted Concierge. All conversations have been anonymized by (1) removing all user identifiers, (2) using the Stanford NER tagger to remove named entities (locations, timestamps, etc.), (3) running some manually defined regex to filter out any remaining salient information (phone numbers, etc.). The dataset does not contain results from API calls, but still records when operators made use of an external service (Yelp or OpenTable) to gather information. Hence, these have to be predicted, but without any argument (unlike in Task 2).
+
+The statistics of Concierge are given in Table 1. The dialogs are shorter than in Tasks 1-6, especially since they do not include results of API calls, but the vocabulary is more diverse and so is the candidate set; the candidate set is made of all utterances of the operator appearing in the training, validation and test sets. Beyond the higher variability of the language used by human operators compared to bots, the dataset offers additional challenges. The set of user requests is much wider, ranging from managing restaurant reservations to asking for recommendations or specific information. Users do not always stay focused on the request. API calls are not always used (e.g., the operator might use neither Yelp nor OpenTable to find a restaurant), and facts about restaurants are not structured nor constrained as in a KB. The structure of dialogs is thus much more variable. Users and operators also make typos, spelling and grammar mistakes.
+
+# 4 MODELS
+
+To demonstrate how to use the dataset and provide baselines, we evaluate several learning methods on our goal-oriented dialog tasks: rule-based systems, classical information retrieval methods, supervised embeddings, and end-to-end Memory networks.
+
+# 4.1 RULE-BASED SYSTEMS
+
+Our tasks T1-T5 are built with a simulator so as to be completely predictable. Thus it is possible to hand-code a rule based system that achieves $100 \%$ on them, similar to the bAbI tasks of Weston et al. (2015b). Indeed, the point of these tasks is not to check whether a human is smart enough to be able to build a rule-based system to solve them, but to help analyze in which circumstances machine learning algorithms are smart enough to work, and where they fail.
+
+However, the Dialog State Tracking Challenge task (T6) contains some real interactions with users. This makes rule-based systems less straightforward and not so accurate (which is where we expect machine learning to be useful). We implemented a rule-based system for this task in the following way. We initialized a dialog state using the 3 relevant slots for this task: cuisine type, location and price range. Then we analyzed the training data and wrote a series of rules that fire for triggers like word matches, positions in the dialog, entity detections or dialog state, to output particular responses, API calls and/or update a dialog state. Responses are created by combining patterns extracted from the training set with entities detected in the previous turns or stored in the dialog state. Overall we built 28 rules and extracted 21 patterns. We optimized the choice of rules and their application priority (when needed) using the validation set, reaching a validation per-response accuracy of $4 0 . 7 \%$ . We did not build a rule-based system for Concierge data as it is even less constrained.
+
+# 4.2 CLASSICAL INFORMATION RETRIEVAL MODELS
+
+Classical information retrieval (IR) models with no machine learning are standard baselines that often perform surprisingly well on dialog tasks (Isbell et al., 2000; Jafarpour et al., 2010; Ritter et al., 2011; Sordoni et al., 2015). We tried two standard variants:
+
+TF-IDF Match For each possible candidate response, we compute a matching score between the input and the response, and rank the responses by score. The score is the TF–IDF weighted cosine similarity between the bag-of-words of the input and bag-of-words of the candidate response. We consider the case of the input being either only the last utterance or the entire conversation history, and choose the variant that works best on the validation set (typically the latter).
+
+Nearest Neighbor Using the input, we find the most similar conversation in the training set, and output the response from that example. In this case we consider the input to only be the last utterance, and consider the training set as (utterance, response) pairs that we select from. We use word overlap as the scoring method. When several responses are associated with the same utterance in training, we sort them by decreasing co-occurence frequency.
+
+# 4.3 SUPERVISED EMBEDDING MODELS
+
+A standard, often strong, baseline is to use supervised word embedding models for scoring (conversation history, response) pairs. The embedding vectors are trained directly for this goal. In contrast, word embeddings are most well-known in the context of unsupervised training on raw text as in word2vec (Mikolov et al., 2013). Such models are trained by learning to predict the middle word given the surrounding window of words, or vice-versa. However, given training data consisting of dialogs, a much more direct and strongly performing training procedure can be used: predict the next response given the previous conversation. In this setting a candidate reponse $y$ is scored against the input $x$ : $\bar { f } ( x , y ) = \bar { ( } A x ) ^ { \top } B y$ , where $A$ and $B$ are $d \times V$ word embedding matrices, i.e. input and response are treated as summed bags-of-embeddings. We also consider the case of enforcing $A = B$ , which sometimes works better, and optimize the choice on the validation set.
+
+The embeddings are trained with a margin ranking loss: $f ( x , y ) > m + f ( x , { \bar { y } } )$ , with $m$ the size of the margin, and we sample $N$ negative candidate responses $\bar { y }$ per example, and train with SGD. This approach has been previously shown to be very effective in a range of contexts (Bai et al., 2009;
+
+Dodge et al., 2016). This method can be thought of as a classical information retrieval model, but where the matching function is learnt.
+
+# 4.4 MEMORY NETWORKS
+
+Memory Networks (Weston et al., 2015a; Sukhbaatar et al., 2015) are a recent class of models that have been applied to a range of natural language processing tasks, including question answering (Weston et al., 2015b), language modeling (Sukhbaatar et al., 2015), and non-goal-oriented dialog (Dodge et al., 2016). By first writing and then iteratively reading from a memory component (using hops) that can store historical dialogs and short-term context to reason about the required response, they have been shown to perform well on those tasks and to outperform some other end-to-end architectures based on Recurrent Neural Networks. Hence, we chose them as end-to-end model baseline.
+
+We use the MemN2N architecture of Sukhbaatar et al. (2015), with an additional modification to leverage exact matches and types, described shortly. Apart from that addition, the main components of the model are (i) how it stores the conversation in memory, (ii) how it reads from the memory to reason about the response; and (iii) how it outputs the response. The details are given in Appendix A.
+
+# 4.5 MATCH TYPE FEATURES TO DEAL WITH ENTITIES
+
+Words denoting entities have two important traits: 1) exact matches are usually more appropriate to deal with them than approximate matches, and 2) they frequently appear as OOV words (e.g., the name of a new restaurant). Both are a challenge for embedding-based methods. Firstly, embedding into a low dimensional space makes it hard to differentiate between exact word matches, and matches between words with similar meaning (Bai et al., 2009). While this can be a virtue (e.g. when using synonyms), it is often a flaw when dealing with entities (e.g. failure to differentiate between phone numbers since they have similar embeddings). Secondly, when a new word is used (e.g. the name of a new restaurant) not seen before in training, no word embedding is available, typically resulting in failure (Weston et al., 2015a).
+
+Both problems can be alleviated with match type features. Specifically, we augment the vocabulary with 7 special words, one for each of the KB entity types (cuisine type, location, price range, party size, rating, phone number and address). For each type, the corresponding type word is added to the candidate representation if a word is found that appears 1) as a KB entity of that type, 2) in the candidate, and 3) in the input or memory. Any word that matches as a KB entity can be typed even if it has never been seen before in training dialogs. These features allow the model to learn to rely on type information using exact matching words cues when OOV entity embeddings are not known, as long as it has access to a KB with the OOV entities. We assess the impact of such features for TF-IDF Match, Supervised Embeddings and Memory Networks.
+
+# 5 EXPERIMENTS
+
+Our main results across all the models and tasks are given in Table 2 (extra results are also given in Table 10 of Appendix D). The first 5 rows show tasks T1-T5, and rows 6-10 show the same tasks in the out-of-vocabulary setting. Rows 11 and 12 give results for the Dialog State Tracking Challenge task (T6) and Concierge respectively. Columns 2-7 give the results of each method tried in terms of per-response accuracy and per-dialog accuracy, the latter given in parenthesis. Per-response accuracy counts the percentage of responses that are correct (i.e., the correct candidate is chosen out of all possible candidates). Per-dialog accuracy counts the percentage of dialogs where every response is correct. Ultimately, if only one response is incorrect this could result in a failed dialog, i.e. failure to achieve the goal (in this case, of achieving a restaurant booking). Note that we test Memory Networks (MemNNs) with and without match type features, the results are shown in the last two columns. The hyperparameters for all models were optimized on the validation sets; values for best performing models are given in Appendix C.
+
+The classical IR method TF-IDF Match performs the worst of all methods, and much worse than the Nearest Neighbor IR method, which is true on both the simulated tasks T1-T5 and on the real data of T6 and Concierge. Supplementing TF-IDF Match with match type features noticeably improves performance, which however still remains far behind Nearest Neighbor IR (adding bigrams to the
+
+Table 2: Test results across all tasks and methods. For tasks T1-T5 results are given in the standard setup and the out-of-vocabulary (OOV) setup, where words (e.g. restaurant names) may not have been seen during training. Task T6 is the Dialog state tracking 2 task with real dialogs, and only has one setup. Best performing methods (or methods within $0 . 1 \%$ of best performing) are given in bold for the per-response accuracy metric, with the per-dialog accuracy given in parenthesis. (∗) For Concierge, an example is considered correctly answered if the correct response is ranked among the top 10 candidates by the bot, to accommodate the much larger range of semantically equivalent responses among candidates (see ex. in Tab. 7) . (†) We did not implement MemNNs+match type on Concierge, because this method requires a KB and there is none associated with it.
+
+<table><tr><td rowspan="2"></td><td rowspan="2">Rule-based Systems</td><td colspan="2">TF-IDF Match</td><td rowspan="2">Nearest</td><td colspan="2">Supervised</td><td rowspan="2"></td><td colspan="3">Memory Networks</td></tr><tr><td>no type</td><td>+type</td><td>Neighbor</td><td>Embeddings</td><td>no match type</td><td></td><td>+ match type</td></tr><tr><td>T1: Issuing API calls</td><td>100 (100)</td><td>5.6 (0)</td><td>22.4(0)</td><td>55.1 (0)</td><td>100</td><td>(100)</td><td></td><td>99.9 (99.6)</td><td>100</td><td>(100)</td></tr><tr><td>T2: Updating API calls</td><td>100 (100)</td><td>3.4(0)</td><td>16.4(0)</td><td>68.3(0)</td><td>68.4</td><td>(0）)</td><td>100</td><td>(100)</td><td>98.3</td><td>(83.9)</td></tr><tr><td>T3:Displaying options</td><td>100 (100)</td><td>8.0 (0)</td><td>8.0 (0)</td><td>58.8 (0)</td><td>64.9</td><td>(0)</td><td>74.9</td><td>(2.0)</td><td>74.9</td><td>(0)</td></tr><tr><td>T4:Providing information</td><td>100 (100)</td><td>9.5 (0)</td><td>17.8(0)</td><td>28.6 (0)</td><td>57.2</td><td>(0)</td><td>59.5</td><td>(3.0)</td><td>100</td><td>(100)</td></tr><tr><td>T5: Full dialogs</td><td>100 (100)</td><td>4.6 (0)</td><td>8.1(0)</td><td>57.1 (0)</td><td>75.4</td><td>(0)</td><td>96.1</td><td>(49.4)</td><td>93.4</td><td>(19.7)</td></tr><tr><td>T1(OOV): Issuing API calls</td><td>100 (100)</td><td>5.8 (0）</td><td>22.4(0)</td><td>44.1 (0)</td><td>60.0</td><td>(0)</td><td>72.3</td><td>(0)</td><td>96.5</td><td>(82.7)</td></tr><tr><td>T2(OOV): Updating API calls</td><td>100 (100)</td><td>3.5 (0)</td><td>16.8(0)</td><td>68.3 (0)</td><td>68.3</td><td>(0)</td><td>78.9</td><td>(0)</td><td>94.5</td><td>(48.4)</td></tr><tr><td>T3(OOV): Displaying options</td><td>100 (100)</td><td>8.3 (0）</td><td>8.3 (0)</td><td>58.8 (0)</td><td>65.0</td><td>(0）</td><td>74.4</td><td>(0)</td><td>75.2</td><td>(0)</td></tr><tr><td>T4(OOV): Providing inform.</td><td>100 (100)</td><td>9.8 (0)</td><td>17.2(0)</td><td>28.6 (0)</td><td>57.0</td><td>(0)</td><td>57.6</td><td>(0)</td><td>100</td><td>(100)</td></tr><tr><td>T5(OOV): Full dialogs</td><td>100 (100)</td><td>4.6(0)</td><td>9.0 (0)</td><td>48.4 (0)</td><td>58.2</td><td>(0)</td><td>65.5</td><td>（0）</td><td>77.7</td><td>(0)</td></tr><tr><td>T6: Dialog state tracking 2</td><td>33.3 0</td><td>1.6(0)</td><td>1.6 (0)</td><td>21.9 （0）</td><td>22.6</td><td>0</td><td>41.1</td><td>（0)</td><td>41.0</td><td>（0</td></tr><tr><td>Concierge(*）</td><td>n/a</td><td>1.1(0.2)</td><td>n/a</td><td>13.4(0.5)</td><td>14.6</td><td>(0.5)</td><td>16.7</td><td>(1.2)</td><td>n/a(）</td><td></td></tr></table>
+
+dictionary has no effect on performance). This is in sharp contrast to other recent results on datadriven non-goal directed conversations, e.g. over dialogs on Twitter (Ritter et al., 2011) or Reddit (Dodge et al., 2016), where it was found that TF-IDF Match outperforms Nearest Neighbor, as general conversations on a given subject typically share many words. We conjecture that the goal-oriented nature of the conversation means that the conversation moves forward more quickly, sharing fewer words per (input, response) pair, e.g. consider the example in Figure 1.
+
+Supervised embeddings outperform classical IR methods in general, indicating that learning mappings between words (via word embeddings) is important. However, only one task (T1, Issuing API calls) is completely successful. In the other tasks, some responses are correct, as shown by the per-response accuracy, however there is no dialog where the goal is actually achieved (i.e., the mean dialogaccuracy is 0). Typically the model can provide correct responses for greeting messages, asking to wait, making API calls and asking if there are any other options necessary. However, it fails to interpret the results of API calls to display options, provide information or update the calls with new information, resulting in most of its errors, even when match type features are provided.
+
+Memory Networks (without match type features) outperform classical IR and supervised embeddings across all of the tasks. They can solve the first two tasks (issuing and updating API calls) adequately. On the other tasks, they give improved results, but do not solve them. While the per-response accuracy is improved, the per-dialog accuracy is still close to 0 on T3 and T4. Some examples of predictions of the MemNN for T1-4 are given in Appendix B. On the OOV tasks again performance is improved, but this is all due to better performance on known words, as unknown words are simply not used without the match type features. As stated in Appendix C, optimal hyperparameters on several of the tasks involve 3 or 4 hops, indicating that iterative accessing and reasoning over the conversation helps, e.g. on T3 using 1 hop gives $6 4 . 8 \%$ while 2 hops yields $7 4 . 7 \%$ . Appendix B displays illustrative examples of Memory Networks predictions on T 1-4 and Concierge.
+
+Memory Networks with match type features give two performance gains over the same models without match type features: (i) T4 (providing information) becomes solvable because matches can be made to the results of the API call; and (ii) out-of-vocabulary results are significantly improved as well. Still, tasks T3 and T5 are still fail cases, performance drops slightly on T2 compared to not using match type features, and no relative improvement is observed on T6. Finally, note that matching words on its own is not enough, as evidenced by the poor performance of TF-IDF matching; this idea must be combined with types and the other properties of the MemNN model.
+
+Unsurprisingly, perfectly coded rule-based systems can solve the simulated tasks T1-T5 perfectly, whereas our machine learning methods cannot. However, it is not easy to build an effective rule-based system when dealing with real language on real problems, and our rule based system is outperformed by MemNNs on the more realistic task T6.
+
+Overall, while the methods we tried made some inroads into these tasks, there are still many challenges left unsolved. Our best models can learn to track implicit dialog states and manipulate OOV words and symbols (T1-T2) to issue API calls and progress in conversations, but they are still unable to perfectly handle interpreting knowledge about entities (from returned API calls) to present results to the user, e.g. displaying options in T3. The improvement observed on the simulated tasks e.g. where MemNNs outperform supervised embeddings which in turn outperform IR methods, is also seen on the realistic data of T6 with similar relative gains. This is encouraging as it indicates that future work on breaking down, analysing and developing models over the simulated tasks should help in the real tasks as well. Results on Concierge confirm this observation: the pattern of relative performances of methods is the same on Concierge and on our series of tasks. This suggests that our synthetic data can indeed be used as an effective evaluation proxy.
+
+# 6 CONCLUSION
+
+We have introduced an open dataset and task set for evaluating end-to-end goal-oriented dialog learning methods in a systematic and controlled way. We hope this will help foster progress of end-toend conversational agents because (i) existing measures of performance either prevent reproducibility (different Mechanical Turk jobs) or do not correlate well with human judgements (Liu et al., 2016); (ii) the breakdown in tasks will help focus research and development to improve the learning methods; and (iii) goal-oriented dialog has clear utility in real applications. We illustrated how to use the testbed using a variant of end-to-end Memory Networks, which prove an effective model on these tasks relative to other baselines, but are still lacking in some key areas.
+
+# ACKNOWLEDGMENTS
+
+The authors would like to thank Martin Raison, Alex Lebrun and Laurent Landowski for their help with the Concierge data.
+
+# REFERENCES
+
+Bai, B., Weston, J., Grangier, D., Collobert, R., Sadamasa, K., Qi, Y., Chapelle, O., and Weinberger, K. (2009). Supervised semantic indexing. In Proceedings of ACM CIKM, pages 187–196. ACM.   
+Banchs, R. E. (2012). Movie-dic: a movie dialogue corpus for research and development. In Proceedings of the 50th Annual Meeting of the ACL.   
+Chen, Y.-N., Hakkani-Tür, D., Tur, G., Gao, J., and Deng, L. (2016). End-to-end memory networks with knowledge carryover for multi-turn spoken language understanding. In Proceedings of Interspeech.   
+Dahl, D. A., Bates, M., Brown, M., Fisher, W., Hunicke-Smith, K., Pallett, D., Pao, C., Rudnicky, A., and Shriberg, E. (1994). Expanding the scope of the atis task: The atis-3 corpus. In Proceedings of the workshop on Human Language Technology, pages 43–48. Association for Computational Linguistics.   
+Dodge, J., Gane, A., Zhang, X., Bordes, A., Chopra, S., Miller, A., Szlam, A., and Weston, J. (2016). Evaluating prerequisite qualities for learning end-to-end dialog systems. In Proc. of ICLR.   
+Gašic, M., Kim, D., Tsiakoulis, P., Breslin, C., Henderson, M., Szummer, M., Thomson, B., and Young, S. (2014). Incremental on-line adaptation of pomdp-based dialogue managers to extended domains. In Proceedings on InterSpeech.   
+Henderson, M., Thomson, B., and Williams, J. (2014a). The second dialog state tracking challenge. In 15th Annual Meeting of the Special Interest Group on Discourse and Dialogue, page 263.   
+Henderson, M., Thomson, B., and Young, S. (2014b). Word-based dialog state tracking with recurrent neural networks. In Proceedings of the 15th Annual Meeting of the Special Interest Group on Discourse and Dialogue (SIGDIAL), pages 292–299.   
+Hixon, B., Clark, P., and Hajishirzi, H. (2015). Learning knowledge graphs for question answering through conversational dialog. In Proceedings of the the 2015 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Denver, Colorado, USA.   
+Isbell, C. L., Kearns, M., Kormann, D., Singh, S., and Stone, P. (2000). Cobot in lambdamoo: A social statistics agent. In AAAI/IAAI, pages 36–41.   
+Jafarpour, S., Burges, C. J., and Ritter, A. (2010). Filter, rank, and transfer the knowledge: Learning to chat. Advances in Ranking, 10.   
+Kim, S., D’Haro, L. F., Banchs, R. E., Williams, J. D., and Henderson, M. (2016). The fourth dialog state tracking challenge. In Proceedings of the 7th International Workshop on Spoken Dialogue Systems (IWSDS).   
+Lemon, O., Georgila, K., Henderson, J., and Stuttle, M. (2006). An isu dialogue system exhibiting reinforcement learning of dialogue policies: generic slot-filling in the talk in-car system. In Proceedings of the 11th Conference of the European Chapter of the ACL: Posters & Demonstrations, pages 119–122.   
+Liu, C.-W., Lowe, R., Serban, I. V., Noseworthy, M., Charlin, L., and Pineau, J. (2016). How not to evaluate your dialogue system: An empirical study of unsupervised evaluation metrics for dialogue response generation. arXiv preprint arXiv:1603.08023.   
+Lowe, R., Pow, N., Serban, I., and Pineau, J. (2015). The ubuntu dialogue corpus: A large dataset for research in unstructured multi-turn dialogue systems. arXiv preprint arXiv:1506.08909.   
+Lowe, R., Serban, I. V., Noseworthy, M., Charlin, L., and Pineau, J. (2016). On the evaluation of dialogue systems with next utterance classification. arXiv preprint arXiv:1605.05414.   
+Mikolov, T., Chen, K., Corrado, G., and Dean, J. (2013). Efficient estimation of word representations in vector space. arXiv:1301.3781.   
+Pietquin, O. and Hastie, H. (2013). A survey on metrics for the evaluation of user simulations. The knowledge engineering review, 28(01), 59–73.   
+Ritter, A., Cherry, C., and Dolan, W. B. (2011). Data-driven response generation in social media. In Proceedings of the Conference on Empirical Methods in Natural Language Processing.   
+Serban, I. V., Sordoni, A., Bengio, Y., Courville, A., and Pineau, J. (2015a). Building end-to-end dialogue systems using generative hierarchical neural network models. In Proc. of the AAAI Conference on Artificial Intelligence.   
+Serban, I. V., Lowe, R., Charlin, L., and Pineau, J. (2015b). A survey of available corpora for building data-driven dialogue systems. arXiv preprint arXiv:1512.05742.   
+Shang, L., Lu, Z., and Li, H. (2015). Neural responding machine for short-text conversation. arXiv preprint arXiv:1503.02364.   
+Sordoni, A., Galley, M., Auli, M., Brockett, C., Ji, Y., Mitchell, M., Nie, J.-Y., Gao, J., and Dolan, B. (2015). A neural network approach to context-sensitive generation of conversational responses. Proceedings of NAACL.   
+Su, P.-H., Vandyke, D., Gasic, M., Kim, D., Mrksic, N., Wen, T.-H., and Young, S. (2015a). Learning from real users: Rating dialogue success with neural networks for reinforcement learning in spoken dialogue systems. arXiv preprint arXiv:1508.03386.   
+Su, P.-H., Vandyke, D., Gasic, M., Mrksic, N., Wen, T.-H., and Young, S. (2015b). Reward shaping with recurrent neural networks for speeding up on-line policy learning in spoken dialogue systems. arXiv preprint arXiv:1508.03391.   
+Sukhbaatar, S., Szlam, A., Weston, J., and Fergus, R. (2015). End-to-end memory networks. Proceedings of NIPS.   
+Vinyals, O. and Le, Q. (2015). A neural conversational model. arXiv preprint arXiv:1506.05869.   
+Wang, H., Lu, Z., Li, H., and Chen, E. (2013). A dataset for research on short-text conversations. In EMNLP.   
+Wang, Z. and Lemon, O. (2013). A simple and generic belief tracking mechanism for the dialog state tracking challenge: On the believability of observed information. In Proceedings of the SIGDIAL 2013 Conference.   
+Wen, T.-H., Gasic, M., Mrksic, N., Su, P.-H., Vandyke, D., and Young, S. (2015). Semantically conditioned lstm-based natural language generation for spoken dialogue systems. arXiv preprint arXiv:1508.01745.   
+Weston, J., Chopra, S., and Bordes, A. (2015a). Memory networks. Proceedings of ICLR.   
+Weston, J., Bordes, A., Chopra, S., and Mikolov, T. (2015b). Towards ai-complete question answering: a set of prerequisite toy tasks. arXiv preprint arXiv:1502.05698.   
+Young, S., Gasic, M., Thomson, B., and Williams, J. D. (2013). Pomdp-based statistical spoken dialog systems: A review. Proceedings of the IEEE, 101(5), 1160–1179.
+
+# A MEMORY NETWORKS IMPLEMENTATION
+
+Storing and representing the conversation history As the model conducts a conversation with the user, at each time step $t$ the previous utterance (from the user) and response (from the model) are appended to the memory. Hence, at any given time there are $c _ { 1 } ^ { u } , \ldots c _ { t } ^ { u }$ user utterances and $c _ { 1 } ^ { r } , \ldots . c _ { t - 1 } ^ { r }$ model responses stored (i.e. the entire conversation).2 The aim at time $t$ is to thus choose the next response $c _ { t } ^ { r }$ . We train on existing full dialog transcripts, so at training time we know the upcoming utterance $\boldsymbol { c } _ { t } ^ { r }$ and can use it as a training target. Following Dodge et al. (2016), we represent each utterance as a bag-of-words and in memory it is represented as a vector using the embedding matrix $A$ , i.e. the memory is an array with entries:
+
+$$
+m = ( A \Phi ( c _ { 1 } ^ { u } ) , A \Phi ( c _ { 1 } ^ { r } ) \dots , A \Phi ( c _ { t - 1 } ^ { u } ) , A \Phi ( c _ { t - 1 } ^ { r } ) )
+$$
+
+where $\Phi ( \cdot )$ maps the utterance to a bag of dimension $V$ (the vocabulary), and $A$ is a $d \times V$ matrix, where $d$ is the embedding dimension. We retain the last user utterance $c _ { t } ^ { u }$ as the “input” to be used directly in the controller. The contents of each memory slot $m _ { i }$ so far does not contain any information of which speaker spoke an utterance, and at what time during the conversation. We therefore encode both of those pieces of information in the mapping $\Phi$ by extending the vocabulary to contain $T = 1 0 0 0$ extra “time features” which encode the index $_ { i }$ into the bag-of-words, and two more features that encode whether the utterance was spoken by the user or the model.
+
+Attention over the memory The last user utterance $c _ { t } ^ { u }$ is embedded using the same matrix $A$ giving $q = A \Phi ( c _ { t } ^ { u } )$ , which can also be seen as the initial state of the controller. At this point the controller reads from the memory to find salient parts of the previous conversation that are relevant to producing a response. The match between $q$ and the memories is computed by taking the inner product followed by a softmax: $p _ { i } = \mathrm { S o f t m a x } ( u ^ { \top } m _ { i } )$ , giving a probability vector over the memories. The vector that is returned back to the controller is then computed by $\begin{array} { r } { o = R \sum _ { i } ^ { } p _ { i } m _ { i } } \end{array}$ where $R$ is a $d \times d$ square matrix. The controller state is then updated with $q _ { 2 } = o + q$ . The memory can be iteratively reread to look for additional pertinent information using the updated state of the controller $q _ { 2 }$ instead of $q$ , and in general using $q _ { h }$ on iteration $h$ , with a fixed number of iterations $N$ (termed $N$ hops). Empirically we find improved performance on our tasks with up to 3 or 4 hops.
+
+Choosing the response The final prediction is then defined as:
+
+$$
+\hat { a } = \operatorname { S o f t m a x } \bigl ( { q _ { N + 1 } } ^ { \top } W \Phi ( y _ { 1 } ) , \ldots , { q _ { N + 1 } } ^ { \top } W \Phi ( y _ { C } ) \bigr )
+$$
+
+where there are $C$ candidate responses in $y$ , and $W$ is of dimension $d \times V$ . In our tasks the set $_ y$ is a (large) set of candidate responses which includes all possible bot utterances and API calls.
+
+The entire model is trained using stochastic gradient descent (SGD), minimizing a standard cross-entropy loss between $\hat { a }$ and the true label $a$ .
+
+# B EXAMPLES OF PREDICTIONS OF A MEMORY NETWORK
+
+Tables 3, 4, 5 and 6 display examples of predictions of the best performing Memory Network on full dialogs, Task 5, (with 3 hops) on test examples of Tasks 1-4 along with the values of the attention over each memory for each hop ${ p } _ { i }$ as defined in Sec. A). This model does not use match type features. Then, Table 7 displays an example of prediction of the best performing Memory Network on Concierge (with 2 hops) on a test example along with the values of the attention over each memory for each hop.
+
+# C HYPERPARAMETERS
+
+Tables 8 and 9 respectively display the values of the hyperparameters of the best Supervised Embeddings and Memory Networks selected for each task. These models were selected using the best validation validation sets.
+
+# D ADDITIONAL RESULTS
+
+Table 10 provides results for additional variants of supervised embeddings, using either a dictionary that includes all bigrams to leverage some word order information, or match type features. On some tasks, supervised embeddings perform better when the last user utterance is used as sole input, without the full dialog history (see Table 8). When no history is used, we slightly adapt match type features to only record type: a special word corresponding to type $T$ (e.g., phone, address, etc) is appended to the representation of a candidate if the candidate contains a word that appears in the knowledge base as an entity of type $T$ , regardless of whether the same word appeared earlier in the conversation. As seen on Table 10, match type features improve performance on out-of-vocabulary tasks 1 and 5, bringing it closer to that of Memory Networks without match type features, but still quite lagging Memory Networks with match type features. Bigrams slightly hurt rather than help performance, except in Task 5 in the standard in-vocabulary setup (performance is lower in the OOV setup).
+
+Table 3: Task 1 (Issue API call) The model learns to direct its attention towards the 4 memories containing the information key to issue the API call. More hops help to strengthen this signal. <silence> is a special token used to indicate that the user did not speak at this turn – the model has to carry out the conversation with no additional input.   
+
+<table><tr><td>Time</td><td>Locutor</td><td colspan="3">Dialog History</td><td>Hop #1</td><td>Hop #2</td><td>Hop #3</td></tr><tr><td>1</td><td>User</td><td colspan="3">hi</td><td>.054</td><td>.016</td><td>.020</td></tr><tr><td>2</td><td>Bot</td><td colspan="3">hello what can i help you with today</td><td>.040</td><td>.024</td><td>.008</td></tr><tr><td>3</td><td>User</td><td colspan="3">may i have a table in paris</td><td>.099</td><td>.137</td><td>.141</td></tr><tr><td>4</td><td>Bot</td><td colspan="3">i&#x27;m on it</td><td>.048</td><td>.028</td><td>.004</td></tr><tr><td>5</td><td>User</td><td colspan="3">&lt;silence&gt;</td><td>.181</td><td>.099</td><td>.037</td></tr><tr><td>6</td><td>Bot</td><td colspan="3">any preference on a type of cuisine</td><td>.056</td><td>.090</td><td>.014</td></tr><tr><td>7</td><td>User</td><td colspan="3">i love indian food</td><td>.159</td><td>.188</td><td>.238</td></tr><tr><td>8</td><td>Bot</td><td colspan="3">how many people would be in your party</td><td>.051</td><td>.022</td><td>.010</td></tr><tr><td>9</td><td>User</td><td colspan="3">we will be six</td><td>.129</td><td>.144</td><td>.114</td></tr><tr><td>10</td><td>Bot</td><td colspan="3">which price range are looking for</td><td>.039</td><td>.028</td><td>.006</td></tr><tr><td>11</td><td>User</td><td colspan="3">in a moderate price range please</td><td>.128</td><td>.213</td><td>.405</td></tr><tr><td>12</td><td>Bot</td><td colspan="3">ok let me look into some options for you</td><td>.016</td><td>.011</td><td>.003</td></tr><tr><td colspan="2">User input</td><td colspan="6">&lt;silence&gt;</td></tr><tr><td colspan="2">Correct answer</td><td>api_call indian</td><td>paris</td><td>six moderate</td><td></td><td></td><td></td></tr><tr><td colspan="2">Predicted answer</td><td>api_call</td><td>indian paris six moderate</td><td></td><td>[Correct]</td><td></td><td></td></tr></table>
+
+Table 4: Task 2 (Update API call) Out of the multiple memories from the current dialog, the model correctly focuses on the 2 important pieces: the original API call and the utterance giving the update.   
+
+<table><tr><td rowspan=1 colspan=1>Time</td><td rowspan=1 colspan=1>Locutor</td><td rowspan=1 colspan=3>Dialog history</td><td rowspan=1 colspan=1>Hop #1</td><td rowspan=1 colspan=1>Hop #2</td><td rowspan=1 colspan=1>Hop #3</td></tr><tr><td rowspan=2 colspan=1>34</td><td rowspan=2 colspan=1>UserBot</td><td rowspan=2 colspan=3>mayihavea table in parisi&#x27;m on it</td><td rowspan=1 colspan=1>.061</td><td rowspan=1 colspan=1>.072</td><td rowspan=1 colspan=1>.040</td></tr><tr><td rowspan=1 colspan=1>.026</td><td rowspan=1 colspan=1>.012</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=2 colspan=1>56</td><td rowspan=2 colspan=1>UserBot</td><td rowspan=5 colspan=3>&lt;silence&gt;any preference on a type of cuisinei love indian foodhow many people would be in your partywe will be six</td><td rowspan=1 colspan=1>.087</td><td rowspan=1 colspan=1>.042</td><td rowspan=1 colspan=1>.012</td></tr><tr><td rowspan=1 colspan=1>.026</td><td rowspan=1 colspan=1>.023</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=6 colspan=1>789101112</td><td rowspan=6 colspan=1>UserBotUserBotUserBot</td><td rowspan=1 colspan=1>i</td><td rowspan=1 colspan=1>.081</td><td rowspan=1 colspan=1>.070</td><td rowspan=1 colspan=1>.055</td></tr><tr><td rowspan=1 colspan=2>how</td><td rowspan=1 colspan=1>.025</td><td rowspan=1 colspan=1>.006</td><td rowspan=2 colspan=1>.001.018</td></tr><tr><td rowspan=4 colspan=3>we will be sixwhich price range are looking forin a moderate price range pleaseok let me look into some options for you</td><td rowspan=1 colspan=1>.059</td><td rowspan=2 colspan=1>.051.043</td><td rowspan=2 colspan=1>.018.004</td></tr><tr><td rowspan=1 colspan=1>.038</td></tr><tr><td rowspan=1 colspan=1>.080</td><td rowspan=1 colspan=1>.095</td><td rowspan=1 colspan=1>.096</td></tr><tr><td rowspan=1 colspan=1>.025</td><td rowspan=1 colspan=1>.042</td><td rowspan=1 colspan=1>.003</td></tr><tr><td rowspan=1 colspan=1>13</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=3>&lt;silence&gt;</td><td rowspan=1 colspan=1>.127</td><td rowspan=1 colspan=1>.069</td><td rowspan=1 colspan=1>.032</td></tr><tr><td rowspan=1 colspan=1>14</td><td rowspan=1 colspan=1>Bot</td><td rowspan=2 colspan=3>api_call indian paris six moderateinstead could it be with french food</td><td rowspan=1 colspan=1>.062</td><td rowspan=1 colspan=1>.113</td><td rowspan=1 colspan=1>.043</td></tr><tr><td rowspan=4 colspan=1>15161718</td><td rowspan=4 colspan=1>UserBotUserBot</td><td rowspan=4 colspan=3>instead could it be with french foodsure is there anything else to updatenook let me look into some options for you</td><td rowspan=1 colspan=1>.188</td><td rowspan=1 colspan=1>.311</td><td rowspan=1 colspan=1>.683</td></tr><tr><td rowspan=1 colspan=1>.016</td><td rowspan=1 colspan=1>.007</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=2 colspan=1>.028.011</td><td rowspan=1 colspan=1>.013</td><td rowspan=1 colspan=1>.007</td></tr><tr><td rowspan=1 colspan=1>.006</td><td rowspan=1 colspan=1>.000</td></tr><tr><td rowspan=1 colspan=2>User input</td><td rowspan=1 colspan=6>&lt;silence&gt;</td></tr><tr><td rowspan=1 colspan=2>Correct answer</td><td rowspan=1 colspan=6>api__callfrenchparissix moderate</td></tr><tr><td rowspan=1 colspan=2>Predictedanswer</td><td rowspan=1 colspan=4>api_callfrench paris six moderate  [Correct]</td><td rowspan=1 colspan=2></td></tr></table>
+
+Table 5: Task 3 (Displaying options) The model knows it has to display options but the attention is wrong: it should attend on the ratings to select the best option (with highest rating). It cannot learn that properly and match type features do not help. It is correct here by luck, the task is not solved overall (see Tab. 2). We do not show all memories in the table, only those with meaningful attention.   
+
+<table><tr><td>Time</td><td>Locutor</td><td>Dialog history</td><td></td><td>Hop #1</td><td>Hop #2</td><td>Hop #3</td></tr><tr><td>14</td><td>Bot</td><td></td><td>api_call indian paris six moderate</td><td>.012</td><td>.000</td><td>.000</td></tr><tr><td>15</td><td>User</td><td></td><td>instead could it be with french food</td><td>.067</td><td>.103</td><td>.147</td></tr><tr><td>20</td><td>Bot</td><td></td><td>api_call french paris six moderate</td><td>.012</td><td>.000</td><td>.000</td></tr><tr><td>21</td><td>User</td><td>resto_1</td><td>r_phone rest_1_phone</td><td>.018</td><td>.004</td><td>.000</td></tr><tr><td>23</td><td>User</td><td>resto_1</td><td>1 r_cuisine french</td><td>.029</td><td>.005</td><td>.000</td></tr><tr><td>24</td><td>User</td><td>resto_1</td><td>r_location paris</td><td>.060</td><td>.292</td><td>.094</td></tr><tr><td>25</td><td>User</td><td>resto_1</td><td>r_number six</td><td>.050</td><td>.298</td><td>.745</td></tr><tr><td>26</td><td>User</td><td>resto_1</td><td>r_price moderate</td><td>.060</td><td>.090</td><td>.002</td></tr><tr><td>27</td><td>User</td><td>resto_1</td><td>r_rating 6</td><td>.016</td><td>.002</td><td>.000</td></tr><tr><td>30</td><td>User</td><td>resto_2</td><td>r_cuisine french</td><td>.031</td><td>.007</td><td>.000</td></tr><tr><td>31</td><td>User</td><td>resto_2</td><td>r_location paris</td><td>.040</td><td>.081</td><td>.004</td></tr><tr><td>32</td><td>User</td><td>resto_2</td><td>r_number six</td><td>.020</td><td>.012</td><td>.000</td></tr><tr><td>33</td><td>User</td><td>resto_2</td><td>r_price moderate</td><td>.029</td><td>.009</td><td>.000</td></tr><tr><td>37</td><td>User</td><td>resto_3</td><td>r_cuisine french</td><td>.014</td><td>.001</td><td>.000</td></tr><tr><td>38</td><td>User</td><td>resto_3</td><td>r_location paris</td><td>.028</td><td>.016</td><td>.001</td></tr><tr><td>39</td><td>User</td><td>resto_3</td><td>r_number six</td><td>.024</td><td>.022</td><td>.004</td></tr><tr><td>40</td><td>User</td><td>resto_3</td><td>r_price moderate</td><td>.039</td><td>.015</td><td>.001</td></tr><tr><td colspan="2">User input</td><td colspan="6">&lt;silence&gt;</td></tr><tr><td colspan="2">Correct answer</td><td colspan="6">what do you think of this option:resto_1</td></tr><tr><td colspan="2">Predictedanswer</td><td colspan="6">what do you think of this option:resto_1 [Correct]</td></tr></table>
+
+Table 6: Task 4 (Providing extra-information) The model knows it must display a phone or an address, but, as explained in Section A the embeddings mix up the information and make it hard to distinguish between different phone numbers or addresses, making answering correctly very hard. As shown in the results of Tab. 2, this problem can be solved by adding match type features, that allow to emphasize entities actually appearing in the history. The attention is globally wrong here.   
+
+<table><tr><td rowspan=1 colspan=1>Time</td><td rowspan=1 colspan=1>Locutor</td><td rowspan=1 colspan=2>Dialog history</td><td rowspan=1 colspan=2>Hop #1</td><td rowspan=1 colspan=1>Hop #2</td><td rowspan=1 colspan=1>Hop #3</td></tr><tr><td rowspan=2 colspan=1>1415</td><td rowspan=1 colspan=1>Bot</td><td rowspan=2 colspan=2>api_call indian paris six moderateinstead could it be with french food</td><td rowspan=1 colspan=2>.006</td><td rowspan=1 colspan=1>.000</td><td rowspan=1 colspan=1>.000</td></tr><tr><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=2>.024</td><td rowspan=1 colspan=1>.011</td><td rowspan=1 colspan=1>.007</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>Bot</td><td rowspan=1 colspan=2>api_call french paris six moderate</td><td rowspan=1 colspan=2>.005</td><td rowspan=1 colspan=1>.000</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=1 colspan=1>21</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=2>resto_1 r_phone resto_l_phone</td><td rowspan=1 colspan=2>.011</td><td rowspan=1 colspan=1>.005</td><td rowspan=1 colspan=1>.004</td></tr><tr><td rowspan=1 colspan=1>22</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=2>resto_1 r_address resto_1_address</td><td rowspan=1 colspan=2>.018</td><td rowspan=1 colspan=1>.004</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=1 colspan=1>23</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_1</td><td rowspan=1 colspan=1>.r_cuisine french</td><td rowspan=1 colspan=2>.018</td><td rowspan=1 colspan=1>.003</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=1 colspan=1>24</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_1</td><td rowspan=1 colspan=1>r_location paris</td><td rowspan=1 colspan=2>.068</td><td rowspan=1 colspan=1>.091</td><td rowspan=1 colspan=1>.108</td></tr><tr><td rowspan=1 colspan=1>25</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_1</td><td rowspan=1 colspan=1>r_number six</td><td rowspan=1 colspan=2>.086</td><td rowspan=1 colspan=1>.078</td><td rowspan=1 colspan=1>.020</td></tr><tr><td rowspan=1 colspan=1>26</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_1</td><td rowspan=1 colspan=1>r_price moderate</td><td rowspan=1 colspan=2>.070</td><td rowspan=1 colspan=1>.225</td><td rowspan=1 colspan=1>.369</td></tr><tr><td rowspan=1 colspan=1>27</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_1</td><td rowspan=1 colspan=1>r_rating 6</td><td rowspan=1 colspan=2>.014</td><td rowspan=1 colspan=1>.006</td><td rowspan=1 colspan=1>.008</td></tr><tr><td rowspan=1 colspan=1>28</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_2</td><td rowspan=1 colspan=1>r_phone resto_2_phone</td><td rowspan=1 colspan=2>.015</td><td rowspan=1 colspan=1>.009</td><td rowspan=1 colspan=1>.006</td></tr><tr><td rowspan=1 colspan=1>29</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_2</td><td rowspan=1 colspan=1>r_address resto_2_address</td><td rowspan=1 colspan=2>.014</td><td rowspan=1 colspan=1>.004</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=1 colspan=1>31</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_2</td><td rowspan=1 colspan=1>r_location paris</td><td rowspan=1 colspan=2>.075</td><td rowspan=1 colspan=1>.176</td><td rowspan=1 colspan=1>.193</td></tr><tr><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_2</td><td rowspan=1 colspan=1>r_number six</td><td rowspan=1 colspan=2>.100</td><td rowspan=1 colspan=1>.126</td><td rowspan=1 colspan=1>.026</td></tr><tr><td rowspan=1 colspan=1>33</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_2</td><td rowspan=1 colspan=1>r_price moderate</td><td rowspan=1 colspan=2>.038</td><td rowspan=1 colspan=1>.090</td><td rowspan=1 colspan=1>.167</td></tr><tr><td rowspan=1 colspan=1>35</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_3</td><td rowspan=1 colspan=1>r_phone resto_3_phone</td><td rowspan=1 colspan=2>.004</td><td rowspan=1 colspan=1>.001</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=1 colspan=1>36</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_3</td><td rowspan=1 colspan=1>r_address resto_3_address</td><td rowspan=1 colspan=2>.005</td><td rowspan=1 colspan=1>.002</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=1 colspan=1>37</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_3</td><td rowspan=1 colspan=1>resto_3 r_location paris</td><td rowspan=1 colspan=2>.028</td><td rowspan=1 colspan=1>.028</td><td rowspan=1 colspan=1>.026</td></tr><tr><td rowspan=1 colspan=1>39</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_3</td><td rowspan=1 colspan=1>resto_3 r_number six</td><td rowspan=1 colspan=2>.039</td><td rowspan=1 colspan=1>.013</td><td rowspan=1 colspan=1>.002</td></tr><tr><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_3</td><td rowspan=1 colspan=1>resto_3 r_price moderate</td><td rowspan=1 colspan=2>.018</td><td rowspan=1 colspan=1>.008</td><td rowspan=1 colspan=1>.013</td></tr><tr><td rowspan=1 colspan=1>42</td><td rowspan=1 colspan=1>Bot</td><td rowspan=2 colspan=2>what do you think of this option: resto_1let&#x27;s do it</td><td rowspan=1 colspan=2>.074</td><td rowspan=1 colspan=1>.001</td><td rowspan=1 colspan=1>.000</td></tr><tr><td rowspan=2 colspan=1>4344</td><td rowspan=2 colspan=1>UserBot</td><td rowspan=1 colspan=2>.032</td><td rowspan=1 colspan=1>.004</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=1 colspan=2>great let me do the reservation</td><td rowspan=1 colspan=2>.003</td><td rowspan=1 colspan=1>.000</td><td rowspan=1 colspan=1>.000</td></tr><tr><td rowspan=1 colspan=2>User input</td><td rowspan=3 colspan=6>do you have itsaddresshere it is resto_1_addresshereitis:resto_8_address                          [Incorrect]</td></tr><tr><td rowspan=1 colspan=2>Correctanswer</td><td rowspan=2 colspan=3>here it is resto_1_addresshereitis:resto_8_address</td></tr><tr><td rowspan=1 colspan=2>Predictedanswer</td></tr></table>
+
+Table 7: Concierge Data The model is also able to learn from human-human dialogs. <person>, <org>, <number> and <date> are special tokens used to anonymize the data. We report the top 5 answers predicted by the model. They are all semantically equivalent. Note that the utterances, while all produced by humans, are not perfect English ("rservation", "I’ll check into it")   
+
+<table><tr><td>Time</td><td>Locutor</td><td>Dialog History</td><td>Hop #1</td><td>Hop #2</td></tr><tr><td>1</td><td>User</td><td>hey concierge</td><td>.189</td><td>.095</td></tr><tr><td>2</td><td>User</td><td>could you check if i can get a rservation at &lt;org&gt; &lt;date&gt; for brunch</td><td>.209</td><td>.178</td></tr><tr><td>134</td><td>User</td><td>&lt;number&gt; people</td><td>.197</td><td>.142</td></tr><tr><td>5</td><td>User</td><td>&lt;silence&gt;</td><td>.187</td><td>.167</td></tr><tr><td></td><td>Bot</td><td>hi &lt;person&gt; unfortunately &lt;org&gt; is fully booked for &lt;date&gt;</td><td>.225</td><td>.410</td></tr><tr><td>User input</td><td></td><td>and there&#x27;s &lt;number&gt; people on the waiting list when&#x27;sthe earliestavailability</td><td></td><td></td></tr><tr><td colspan="2">Correctanswer</td><td colspan="3">i&#x27;ll check</td></tr><tr><td colspan="2">Pred.answer#1</td><td>i&#x27;m on it</td><td>[Incorrect]</td><td></td></tr><tr><td colspan="2">Pred.answer #2</td><td>i&#x27;ll find out</td><td colspan="2">[Incorrect]</td></tr><tr><td colspan="2">Pred.answer #3</td><td>i&#x27;ll take a look</td><td colspan="2">[Incorrect]</td></tr><tr><td colspan="2">Pred.answer #4</td><td>i&#x27;ll check</td><td colspan="2">[Correct]</td></tr><tr><td colspan="2"></td><td></td><td colspan="2"></td></tr><tr><td colspan="2">Pred.answer #5</td><td>i&#x27;ll check into it</td><td colspan="2">[Incorrect]</td></tr></table>
+
+Table 8: Hyperparameters of Supervised Embeddings. When Use History is True, the whole conversation history is concatenated with the latest user utterance to create the input. If False, only the latest utterance is used as input.   
+
+<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>Learning Rate</td><td rowspan=1 colspan=1>Margin m</td><td rowspan=1 colspan=1>Embedding Dim d</td><td rowspan=1 colspan=1>Negative Cand. N</td><td rowspan=1 colspan=1>Use History</td></tr><tr><td rowspan=2 colspan=1>Task 1Task 2</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>100</td><td rowspan=3 colspan=1>TrueFalseFalseFalseTrue</td></tr><tr><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>Task 3Task 4Task 5</td><td rowspan=1 colspan=1>0.010.0010.01</td><td rowspan=1 colspan=1>0.10.10.01</td><td rowspan=1 colspan=1>12812832</td><td rowspan=1 colspan=1>10001000100</td></tr><tr><td rowspan=1 colspan=1>Task 6</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>False</td></tr><tr><td rowspan=1 colspan=1>Concierge</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>False</td></tr></table>
+
+Table 9: Hyperparameters of Memory Networks. The longer and more complex the dialogs are, the more hops are needed.   
+
+<table><tr><td>Task</td><td>Learning Rate</td><td>Margin m</td><td>Embedding Dimd</td><td>Negative Cand. N</td><td>Nb Hops</td></tr><tr><td>Task 1</td><td>0.01</td><td>0.1</td><td>128</td><td>100</td><td>1</td></tr><tr><td>Task 2</td><td>0.01</td><td>0.1</td><td>32</td><td>100</td><td>1</td></tr><tr><td>Task 3</td><td>0.01</td><td>0.1</td><td>32</td><td>100</td><td>3</td></tr><tr><td>Task 4</td><td>0.01</td><td>0.1</td><td>128</td><td>100</td><td>2</td></tr><tr><td>Task 5</td><td>0.01</td><td>0.1</td><td>32</td><td>100</td><td>3</td></tr><tr><td>Task 6</td><td>0.01</td><td>0.1</td><td>128</td><td>100</td><td>4</td></tr><tr><td>Concierge</td><td>0.001</td><td>0.1</td><td>128</td><td>100</td><td>2</td></tr></table>
+
+Table 10: Test results across all tasks and methods. For tasks T1-T5 results are given in the standard setup and the out-of-vocabulary (OOV) setup, where words (e.g. restaurant names) may not have been seen during training. Task T6 is the Dialog state tracking 2 task with real dialogs, and only has one setup. Best performing methods (or methods within $0 . 1 \%$ of best performing) are given in bold for the per-response accuracy metric, with the per-dialog accuracy given in parenthesis.   
+
+<table><tr><td rowspan="2">Task</td><td colspan="4">Supervised Embeddings</td><td rowspan="2"></td><td colspan="3">Memory Networks + match type</td></tr><tr><td>no match type no bigram</td><td>+ match type no bigram</td><td></td><td>+bigrams no match type</td><td colspan="3"> no match type</td></tr><tr><td>T1: Issuing API calls</td><td>100</td><td>(100) 83.2</td><td>(0)</td><td>98.6</td><td>(92.4)</td><td>99.9</td><td>(99.6)</td><td>100 (100)</td></tr><tr><td>T2: Updating API calls</td><td>68.4 （0)</td><td>68.4</td><td>(0）</td><td>68.3 (0)</td><td>100</td><td>(100)</td><td>98.3</td><td>(83.9)</td></tr><tr><td>T3:Displaying options</td><td>64.9 （0）</td><td>64.9</td><td>(0）</td><td>64.9 (0)</td><td></td><td>74.9 (2.0)</td><td>74.9</td><td>(0)</td></tr><tr><td>T4:Providing information</td><td>57.2 （0）</td><td>57.2</td><td>（0）</td><td>57.3 (0)</td><td>59.5</td><td>(3.0)</td><td>100</td><td>(100)</td></tr><tr><td>T5: Full dialogs</td><td>75.4 0）</td><td>76.2</td><td>（0）</td><td>83.4 (0)</td><td></td><td>96.1 (49.4)</td><td>93.4</td><td>(19.7)</td></tr><tr><td>T1(OOV): Issuing API calls</td><td>60.0 (0)</td><td>67.2</td><td>（0)</td><td>58.8 (0)</td><td></td><td>72.3 (0)</td><td>96.5</td><td>(82.7)</td></tr><tr><td>T2(OOV): Updating API calls</td><td>68.3 （0）</td><td>68.3</td><td>（0）</td><td>68.3</td><td>(0)</td><td>78.9 (0)</td><td>94.5</td><td>(48.4)</td></tr><tr><td>T3(OOV): Displaying options</td><td>65.0 （0）</td><td>65.0</td><td>（0)</td><td>62.1 (0)</td><td></td><td>74.4 （0)</td><td>75.2</td><td>(0)</td></tr><tr><td>T4(OOV): Providing inform.</td><td>57.0 （0）</td><td>57.1</td><td>（0）</td><td>57.0 (0)</td><td></td><td>57.6 (0)</td><td>100</td><td>(100)</td></tr><tr><td>T5(OOV): Full dialogs</td><td>58.2 0）</td><td>64.4</td><td>（0）</td><td>50.4</td><td>（0）</td><td>65.5 （0)</td><td>77.7</td><td>(0)</td></tr><tr><td>T6: Dialog state tracking 2</td><td>22.6 0)</td><td>22.1</td><td>（0)</td><td>21.8</td><td>（0)</td><td>41.1 （0)</td><td></td><td>41.0 （0）</td></tr></table>

parse/train/S1Bb3D5gg/S1Bb3D5gg_content_list.json

@@ -0,0 +1,1237 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING END-TO-END GOAL-ORIENTED DIALOG",
+        "text_level": 1,
+        "bbox": [
+            173,
+            98,
+            795,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Antoine Bordes, Y-Lan Boureau & Jason Weston   \nFacebook AI Research   \nNew York, USA   \n{abordes, ylan, jase}@fb.com ",
+        "bbox": [
+            184,
+            143,
+            526,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            238,
+            544,
+            252
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Traditional dialog systems used in goal-oriented applications require a lot of domain-specific handcrafting, which hinders scaling up to new domains. Endto-end dialog systems, in which all components are trained from the dialogs themselves, escape this limitation. But the encouraging success recently obtained in chit-chat dialog may not carry over to goal-oriented settings. This paper proposes a testbed to break down the strengths and shortcomings of end-to-end dialog systems in goal-oriented applications. Set in the context of restaurant reservation, our tasks require manipulating sentences and symbols in order to properly conduct conversations, issue API calls and use the outputs of such calls. We show that an end-to-end dialog system based on Memory Networks can reach promising, yet imperfect, performance and learn to perform non-trivial operations. We confirm those results by comparing our system to a hand-crafted slot-filling baseline on data from the second Dialog State Tracking Challenge (Henderson et al., 2014a). We show similar result patterns on data extracted from an online concierge service. ",
+        "bbox": [
+            233,
+            270,
+            766,
+            464
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            493,
+            336,
+            510
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The most useful applications of dialog systems such as digital personal assistants or bots are currently goal-oriented and transactional: the system needs to understand a user request and complete a related task with a clear goal within a limited number of dialog turns. The workhorse of traditional dialog systems is slot-filling (Lemon et al., 2006; Wang and Lemon, 2013; Young et al., 2013) which predefines the structure of a dialog state as a set of slots to be filled during the dialog. For a restaurant reservation system, such slots can be the location, price range or type of cuisine of a restaurant. Slot-filling has proven reliable but is inherently hard to scale to new domains: it is impossible to manually encode all features and slots that users might refer to in a conversation. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            631
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "End-to-end dialog systems, usually based on neural networks (Shang et al., 2015; Vinyals and Le, 2015; Sordoni et al., 2015; Serban et al., 2015a; Dodge et al., 2016), escape such limitations: all their components are directly trained on past dialogs, with no assumption on the domain or dialog state structure, thus making it easy to automatically scale up to new domains. They have shown promising performance in non goal-oriented chit-chat settings, where they were trained to predict the next utterance in social media and forum threads (Ritter et al., 2011; Wang et al., 2013; Lowe et al., 2015) or movie conversations (Banchs, 2012). But the performance achieved on chit-chat may not necessarily carry over to goal-oriented conversations. As illustrated in Figure 1 in a restaurant reservation scenario, conducting goal-oriented dialog requires skills that go beyond language modeling, e.g., asking questions to clearly define a user request, querying Knowledge Bases (KBs), interpreting results from queries to display options to users or completing a transaction. This makes it hard to ascertain how well end-to-end dialog models would do, especially since evaluating chit-chat performance in itself is not straightforward (Liu et al., 2016). In particular, it is unclear if end-to-end models are in a position to replace traditional dialog methods in a goal-directed setting: can end-to-end dialog models be competitive with traditional methods even in the well-defined narrow-domain tasks where they excel? If not, where do they fall short? ",
+        "bbox": [
+            174,
+            638,
+            825,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper aims to make it easier to address these questions by proposing an open resource to test endto-end dialog systems in a way that 1) favors reproducibility and comparisons, and 2) is lightweight and easy to use. We aim to break down a goal-directed objective into several subtasks to test some crucial capabilities that dialog systems should have (and hence provide error analysis by design). ",
+        "bbox": [
+            176,
+            868,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/93a7270b6412ec58156b4a762642cfa63137c3579e6070b83baeb398f09dc8b1.jpg",
+        "image_caption": [
+            "Figure 1: Goal-oriented dialog tasks. A user (in green) chats with a bot (in blue) to book a table at a restaurant. Models must predict bot utterances and API calls (in dark red). Task 1 tests the capacity of interpreting a request and asking the right questions to issue an API call. Task 2 checks the ability to modify an API call. Task 3 and 4 test the capacity of using outputs from an API call (in light red) to propose options (sorted by rating) and to provide extra-information. Task 5 combines everything. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            102,
+            759,
+            513
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the spirit of the bAbI tasks conceived as question answering testbeds (Weston et al., 2015b), we designed a set of five tasks within the goal-oriented context of restaurant reservation. Grounded with an underlying KB of restaurants and their properties (location, type of cuisine, etc.), these tasks cover several dialog stages and test if models can learn various abilities such as performing dialog management, querying KBs, interpreting the output of such queries to continue the conversation or dealing with new entities not appearing in dialogs from the training set. In addition to showing how the set of tasks we propose can be used to test the goal-directed capabilities of an end-to-end dialog system, we also propose results on two additional datasets extracted from real interactions with users, to confirm that the pattern of results observed in our tasks is indeed a good proxy for what would be observed on real data, with the added benefit of better reproducibility and interpretability. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            763
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The goal here is explicitly not to improve the state of the art in the narrow domain of restaurant booking, but to take a narrow domain where traditional handcrafted dialog systems are known to perform well, and use that to gauge the strengths and weaknesses of current end-to-end systems with no domain knowledge. Solving our tasks requires manipulating both natural language and symbols from a KB. Evaluation uses two metrics, per-response and per-dialog accuracies, the latter tracking completion of the actual goal. Figure 1 depicts the tasks and Section 3 details them. Section 4 compares multiple methods on these tasks. As an end-to-end neural model, we tested Memory Networks (Weston et al., 2015a), an attention-based architecture that has proven competitive for non goal-oriented dialog (Dodge et al., 2016). Our experiments in Section 5 show that Memory Networks can be trained to perform non-trivial operations such as issuing API calls to KBs and manipulating entities unseen in training. We confirm our findings on real human-machine dialogs from the restaurant reservation dataset of the $2 ^ { n d }$ Dialog State Tracking Challenge, or DSTC2 (Henderson et al., 2014a), which we converted into our task format, showing that Memory Networks can outperform a dedicated slot-filling rule-based baseline. We also evaluate on a dataset of humanhuman dialogs extracted from an online concierge service that books restaurants for users. Overall, the per-response performance is encouraging, but the per-dialog one remains low, indicating that end-to-end models still need to improve before being able to reliably handle goal-oriented dialog. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/33ee4680ec08b8c10d345f33670fabde678e8f14357ad205401587e623369049.jpg",
+        "table_caption": [
+            "Table 1: Data used in this paper. Tasks 1-5 were generated using our simulator and share the same KB. Task 6 was converted from the $2 ^ { n d }$ Dialog State Tracking Challenge (Henderson et al., 2014a). Concierge is made of chats extracted from a real online concierge service. (∗) Tasks 1-5 have two test sets, one using the vocabulary of the training set and the other using out-of-vocabulary words. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Tasks</td><td>T1</td><td>T2</td><td>T3</td><td>T4</td><td>T5</td><td>T6</td><td>Concierge</td></tr><tr><td rowspan=\"4\">DIALOGS Average statistics</td><td>Number of utterances:</td><td>12</td><td>17</td><td>43</td><td>15</td><td>55</td><td>54</td><td>8</td></tr><tr><td>- user utterances</td><td>5</td><td>7</td><td>7</td><td>4</td><td>13</td><td>6</td><td>4</td></tr><tr><td>- bot utterances</td><td>7</td><td>10</td><td>10</td><td>4</td><td>18</td><td>8</td><td>4</td></tr><tr><td>- outputs from API calls</td><td>0</td><td>0</td><td>23</td><td>7</td><td>24</td><td>40</td><td>0</td></tr><tr><td rowspan=\"4\">DATASETS</td><td>Vocabulary size</td><td></td><td></td><td>3,747</td><td></td><td></td><td>1,229</td><td>8.629</td></tr><tr><td>Candidate set size</td><td></td><td></td><td>4,212</td><td></td><td></td><td>2,406</td><td>11,482</td></tr><tr><td>Training dialogs</td><td></td><td></td><td>1,000</td><td></td><td></td><td>1,618</td><td>3,249</td></tr><tr><td>Validation dialogs</td><td></td><td></td><td>1,000</td><td></td><td></td><td>500</td><td>403</td></tr><tr><td>Tasks1-5 share the same data source</td><td>Test dialogs</td><td></td><td></td><td>1,000(*)</td><td></td><td></td><td>1,117</td><td>402</td></tr></table>",
+        "bbox": [
+            179,
+            167,
+            818,
+            299
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            321,
+            826,
+            406
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            434,
+            344,
+            450
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The most successful goal-oriented dialog systems model conversation as partially observable Markov decision processes (POMDP) (Young et al., 2013). However, despite recent efforts to learn modules (Henderson et al., 2014b), they still require many hand-crafted features for the state and action space representations, which restrict their usage to narrow domains. Our simulation, used to generate goal-oriented datasets, can be seen as an equivalent of the user simulators used to train POMDP (Young et al., 2013; Pietquin and Hastie, 2013), but for training end-to-end systems. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            553
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Serban et al. (2015b) list available corpora for training dialog systems. Unfortunately, no good resources exist to train and test end-to-end models in goal-oriented scenarios. Goal-oriented datasets are usually designed to train or test dialog state tracker components (Henderson et al., 2014a) and are hence of limited scale and not suitable for end-to-end learning (annotated at the state level and noisy). However, we do convert the Dialog State Tracking Challenge data into our framework. Some datasets are not open source, and require a particular license agreement or the participation to a challenge (e.g., the end-to-end task of DSTC4 (Kim et al., 2016)) or are proprietary (e.g., Chen et al. (2016)). Datasets are often based on interactions between users and existing systems (or ensemble of systems) like DSTC datasets, SFCore (Gašic et al., 2014) or ATIS (Dahl et al., 1994). This creates noise and makes it harder to interpret the errors of a model. Lastly, resources designed to connect dialog systems to users, in particular in the context of reinforcement learning, are usually built around a crowdsourcing setting such as Amazon Mechanical Turk, e.g., (Hixon et al., 2015; Wen et al., 2015; Su et al., 2015a;b). While this has clear advantages, it prevents reproducibility and consistent comparisons of methods in the exact same setting. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            753
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The closest resource to ours might be the set of tasks described in (Dodge et al., 2016), since some of them can be seen as goal-oriented. However, those are question answering tasks rather than dialog, i.e. the bot only responds with answers, never questions, which does not reflect full conversation. ",
+        "bbox": [
+            174,
+            761,
+            825,
+            803
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 GOAL-ORIENTED DIALOG TASKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            833,
+            485,
+            849
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "All our tasks involve a restaurant reservation system, where the goal is to book a table at a restaurant. The first five tasks are generated by a simulation, the last one uses real human-bot dialogs. The data for all tasks is available at http://fb.ai/babi. We also give results on a proprietary dataset extracted from an online restaurant reservation concierge service with anonymized users. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 RESTAURANT RESERVATION SIMULATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            503,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The simulation is based on an underlying KB, whose facts contain the restaurants that can be booked and their properties. Each restaurant is defined by a type of cuisine (10 choices, e.g., French, Thai), a location (10 choices, e.g., London, Tokyo), a price range (cheap, moderate or expensive) and a rating (from 1 to 8). For simplicity, we assume that each restaurant only has availability for a single party size (2, 4, 6 or 8 people). Each restaurant also has an address and a phone number listed in the KB. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            199
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The KB can be queried using API calls, which return the list of facts related to the corresponding restaurants. Each query must contain four fields: a location, a type of cuisine, a price range and a party size. It can return facts concerning one, several or no restaurant (depending on the party size). ",
+        "bbox": [
+            174,
+            205,
+            825,
+            248
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Using the KB, conversations are generated in the format shown in Figure 1. Each example is a dialog comprising utterances from a user and a bot, as well as API calls and the resulting facts. Dialogs are generated after creating a user request by sampling an entry for each of the four required fields: e.g. the request in Figure 1 is [cuisine: British, location: London, party size: six, price range: expensive]. We use natural language patterns to create user and bot utterances. There are 43 patterns for the user and 20 for the bot (the user can use up to 4 ways to say something, while the bot always uses the same). Those patterns are combined with the KB entities to form thousands of different utterances. ",
+        "bbox": [
+            174,
+            255,
+            825,
+            353
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 TASK DEFINITIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            368,
+            362,
+            382
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now detail each task. Tasks 1 and 2 test dialog management to see if end-to-end systems can learn to implicitly track dialog state (never given explicitly), whereas Task 3 and 4 check if they can learn to use KB facts in a dialog setting. Task 3 also requires to learn to sort. Task 5 combines all tasks. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            435
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Task 1: Issuing API calls A user request implicitly defines a query that can contain from 0 to 4 of the required fields (sampled uniformly; in Figure 1, it contains 3). The bot must ask questions for filling the missing fields and eventually generate the correct corresponding API call. The bot asks for information in a deterministic order, making prediction possible. ",
+        "bbox": [
+            174,
+            444,
+            825,
+            501
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Task 2: Updating API calls Starting by issuing an API call as in Task 1, users then ask to update their requests between 1 and 4 times (sampled uniformly). The order in which fields are updated is random. The bot must ask users if they are done with their updates and issue the updated API call. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            553
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Task 3: Displaying options Given a user request, we query the KB using the corresponding API call and add the facts resulting from the call to the dialog history. The bot must propose options to users by listing the restaurant names sorted by their corresponding rating (from higher to lower) until users accept. For each option, users have a $2 5 \\%$ chance of accepting. If they do, the bot must stop displaying options, otherwise propose the next one. Users always accept the option if this is the last remaining one. We only keep examples with API calls retrieving at least 3 options. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            647
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Task 4: Providing extra information Given a user request, we sample a restaurant and start the dialog as if users had agreed to book a table there. We add all KB facts corresponding to it to the dialog. Users then ask for the phone number of the restaurant, its address or both, with proportions $2 5 \\%$ , $2 5 \\%$ and $50 \\%$ respectively. The bot must learn to use the KB facts correctly to answer. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            713
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Task 5: Conducting full dialogs We combine Tasks 1-4 to generate full dialogs just as in Figure 1.   \nUnlike in Task 3, we keep examples if API calls return at least 1 option instead of 3. ",
+        "bbox": [
+            174,
+            723,
+            823,
+            751
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            766,
+            302,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We want to test how well models handle entities appearing in the KB but not in the dialog training sets. We split types of cuisine and locations in half, and create two KBs, one with all facts about restaurants within the first halves and one with the rest. This yields two KBs of 4,200 facts and 600 restaurants each (5 types of cuisine $\\times 5$ locations $\\times 3$ price ranges $\\times 8$ ratings) that only share price ranges, ratings and party sizes, but have disjoint sets of restaurants, locations, types of cuisine, phones and addresses. We use one of the KBs to generate the standard training, validation and test dialogs, and use the other KB only to generate test dialogs, termed Out-Of-Vocabulary (OOV) test sets. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For training, systems have access to the training examples and both KBs. We then evaluate on both test sets, plain and OOV. Beyond the intrinsic difficulty of each task, the challenge on the OOV test sets is for models to generalize to new entities (restaurants, locations and cuisine types) unseen in any training dialog – something natively impossible for embedding methods. Ideally, models could, for instance, leverage information coming from the entities of the same type seen during training. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We generate five datasets, one per task defined in 3.1.1. Table 1 gives their statistics. Training sets are relatively small (1,000 examples) to create realistic learning conditions. The dialogs from the training and test sets are different, never being based on the same user requests. Thus, we test if models can generalize to new combinations of fields. Dialog systems are evaluated in a ranking, not a generation, setting: at each turn of the dialog, we test whether they can predict bot utterances and API calls by selecting a candidate, not by generating it.1 Candidates are ranked from a set of all bot utterances and API calls appearing in training, validation and test sets (plain and OOV) for all tasks combined. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            251
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 DIALOG STATE TRACKING CHALLENGE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            268,
+            490,
+            282
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since our tasks rely on synthetically generated language for the user, we supplement our dataset with real human-bot dialogs. We use data from DSTC2 (Henderson et al., 2014a), that is also in the restaurant booking domain. Unlike our tasks, its user requests only require 3 fields: type of cuisine (91 choices), location (5 choices) and price range (3 choices). The dataset was originally designed for dialog state tracking hence every dialog turn is labeled with a state (a user intent $^ +$ slots) to be predicted. As our goal is to evaluate end-to-end training, we did not use that, but instead converted the data into the format of our 5 tasks and included it in the dataset as Task 6. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            392
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We used the provided speech transcriptions to create the user and bot utterances, and given the dialog states we created the API calls to the KB and their outputs which we added to the dialogs. We also added ratings to the restaurants returned by the API calls, so that the options proposed by the bots can be consistently predicted (by using the highest rating). We did use the original test set but use a slightly different training/validation split. Our evaluation differs from the challenge (we do not predict the dialog state), so we cannot compare with the results from (Henderson et al., 2014a). ",
+        "bbox": [
+            174,
+            400,
+            825,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This dataset has similar statistics to our Task 5 (see Table 1) but is harder. The dialogs are noisier and the bots made mistakes due to speech recognition errors or misinterpretations and also do not always have a deterministic behavior (the order in which they can ask for information varies). ",
+        "bbox": [
+            176,
+            489,
+            821,
+            531
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 ONLINE CONCIERGE SERVICE",
+        "text_level": 1,
+        "bbox": [
+            176,
+            550,
+            423,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Tasks 1-6 are, at least partially, artificial. This provides perfect control over their design (at least for Tasks 1-5), but no guarantee that good performance would carry over from such synthetic to more realistic conditions. To quantify this, we also evaluate the models from Section 4 on data extracted from a real online concierge service performing restaurant booking: users make requests through a text-based chat interface that are handled by human operators who can make API calls. All conversations are between native English speakers. ",
+        "bbox": [
+            174,
+            577,
+            825,
+            661
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We collected around 4k chats to create this extra dataset, denoted Concierge. All conversations have been anonymized by (1) removing all user identifiers, (2) using the Stanford NER tagger to remove named entities (locations, timestamps, etc.), (3) running some manually defined regex to filter out any remaining salient information (phone numbers, etc.). The dataset does not contain results from API calls, but still records when operators made use of an external service (Yelp or OpenTable) to gather information. Hence, these have to be predicted, but without any argument (unlike in Task 2). ",
+        "bbox": [
+            174,
+            667,
+            825,
+            751
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The statistics of Concierge are given in Table 1. The dialogs are shorter than in Tasks 1-6, especially since they do not include results of API calls, but the vocabulary is more diverse and so is the candidate set; the candidate set is made of all utterances of the operator appearing in the training, validation and test sets. Beyond the higher variability of the language used by human operators compared to bots, the dataset offers additional challenges. The set of user requests is much wider, ranging from managing restaurant reservations to asking for recommendations or specific information. Users do not always stay focused on the request. API calls are not always used (e.g., the operator might use neither Yelp nor OpenTable to find a restaurant), and facts about restaurants are not structured nor constrained as in a KB. The structure of dialogs is thus much more variable. Users and operators also make typos, spelling and grammar mistakes. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            897
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            279,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate how to use the dataset and provide baselines, we evaluate several learning methods on our goal-oriented dialog tasks: rule-based systems, classical information retrieval methods, supervised embeddings, and end-to-end Memory networks. ",
+        "bbox": [
+            174,
+            131,
+            825,
+            172
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 RULE-BASED SYSTEMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            190,
+            377,
+            205
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our tasks T1-T5 are built with a simulator so as to be completely predictable. Thus it is possible to hand-code a rule based system that achieves $100 \\%$ on them, similar to the bAbI tasks of Weston et al. (2015b). Indeed, the point of these tasks is not to check whether a human is smart enough to be able to build a rule-based system to solve them, but to help analyze in which circumstances machine learning algorithms are smart enough to work, and where they fail. ",
+        "bbox": [
+            174,
+            214,
+            825,
+            284
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "However, the Dialog State Tracking Challenge task (T6) contains some real interactions with users. This makes rule-based systems less straightforward and not so accurate (which is where we expect machine learning to be useful). We implemented a rule-based system for this task in the following way. We initialized a dialog state using the 3 relevant slots for this task: cuisine type, location and price range. Then we analyzed the training data and wrote a series of rules that fire for triggers like word matches, positions in the dialog, entity detections or dialog state, to output particular responses, API calls and/or update a dialog state. Responses are created by combining patterns extracted from the training set with entities detected in the previous turns or stored in the dialog state. Overall we built 28 rules and extracted 21 patterns. We optimized the choice of rules and their application priority (when needed) using the validation set, reaching a validation per-response accuracy of $4 0 . 7 \\%$ . We did not build a rule-based system for Concierge data as it is even less constrained. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            444
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 CLASSICAL INFORMATION RETRIEVAL MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            462,
+            549,
+            477
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Classical information retrieval (IR) models with no machine learning are standard baselines that often perform surprisingly well on dialog tasks (Isbell et al., 2000; Jafarpour et al., 2010; Ritter et al., 2011; Sordoni et al., 2015). We tried two standard variants: ",
+        "bbox": [
+            174,
+            486,
+            825,
+            527
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "TF-IDF Match For each possible candidate response, we compute a matching score between the input and the response, and rank the responses by score. The score is the TF–IDF weighted cosine similarity between the bag-of-words of the input and bag-of-words of the candidate response. We consider the case of the input being either only the last utterance or the entire conversation history, and choose the variant that works best on the validation set (typically the latter). ",
+        "bbox": [
+            174,
+            541,
+            825,
+            611
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Nearest Neighbor Using the input, we find the most similar conversation in the training set, and output the response from that example. In this case we consider the input to only be the last utterance, and consider the training set as (utterance, response) pairs that we select from. We use word overlap as the scoring method. When several responses are associated with the same utterance in training, we sort them by decreasing co-occurence frequency. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            694
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 SUPERVISED EMBEDDING MODELS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            712,
+            459,
+            727
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A standard, often strong, baseline is to use supervised word embedding models for scoring (conversation history, response) pairs. The embedding vectors are trained directly for this goal. In contrast, word embeddings are most well-known in the context of unsupervised training on raw text as in word2vec (Mikolov et al., 2013). Such models are trained by learning to predict the middle word given the surrounding window of words, or vice-versa. However, given training data consisting of dialogs, a much more direct and strongly performing training procedure can be used: predict the next response given the previous conversation. In this setting a candidate reponse $y$ is scored against the input $x$ : $\\bar { f } ( x , y ) = \\bar { ( } A x ) ^ { \\top } B y$ , where $A$ and $B$ are $d \\times V$ word embedding matrices, i.e. input and response are treated as summed bags-of-embeddings. We also consider the case of enforcing $A = B$ , which sometimes works better, and optimize the choice on the validation set. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The embeddings are trained with a margin ranking loss: $f ( x , y ) > m + f ( x , { \\bar { y } } )$ , with $m$ the size of the margin, and we sample $N$ negative candidate responses $\\bar { y }$ per example, and train with SGD. This approach has been previously shown to be very effective in a range of contexts (Bai et al., 2009; ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dodge et al., 2016). This method can be thought of as a classical information retrieval model, but where the matching function is learnt. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 MEMORY NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            148,
+            364,
+            162
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Memory Networks (Weston et al., 2015a; Sukhbaatar et al., 2015) are a recent class of models that have been applied to a range of natural language processing tasks, including question answering (Weston et al., 2015b), language modeling (Sukhbaatar et al., 2015), and non-goal-oriented dialog (Dodge et al., 2016). By first writing and then iteratively reading from a memory component (using hops) that can store historical dialogs and short-term context to reason about the required response, they have been shown to perform well on those tasks and to outperform some other end-to-end architectures based on Recurrent Neural Networks. Hence, we chose them as end-to-end model baseline. ",
+        "bbox": [
+            174,
+            171,
+            825,
+            282
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use the MemN2N architecture of Sukhbaatar et al. (2015), with an additional modification to leverage exact matches and types, described shortly. Apart from that addition, the main components of the model are (i) how it stores the conversation in memory, (ii) how it reads from the memory to reason about the response; and (iii) how it outputs the response. The details are given in Appendix A. ",
+        "bbox": [
+            174,
+            290,
+            825,
+            345
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.5 MATCH TYPE FEATURES TO DEAL WITH ENTITIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            361,
+            555,
+            375
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Words denoting entities have two important traits: 1) exact matches are usually more appropriate to deal with them than approximate matches, and 2) they frequently appear as OOV words (e.g., the name of a new restaurant). Both are a challenge for embedding-based methods. Firstly, embedding into a low dimensional space makes it hard to differentiate between exact word matches, and matches between words with similar meaning (Bai et al., 2009). While this can be a virtue (e.g. when using synonyms), it is often a flaw when dealing with entities (e.g. failure to differentiate between phone numbers since they have similar embeddings). Secondly, when a new word is used (e.g. the name of a new restaurant) not seen before in training, no word embedding is available, typically resulting in failure (Weston et al., 2015a). ",
+        "bbox": [
+            174,
+            386,
+            825,
+            511
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Both problems can be alleviated with match type features. Specifically, we augment the vocabulary with 7 special words, one for each of the KB entity types (cuisine type, location, price range, party size, rating, phone number and address). For each type, the corresponding type word is added to the candidate representation if a word is found that appears 1) as a KB entity of that type, 2) in the candidate, and 3) in the input or memory. Any word that matches as a KB entity can be typed even if it has never been seen before in training dialogs. These features allow the model to learn to rely on type information using exact matching words cues when OOV entity embeddings are not known, as long as it has access to a KB with the OOV entities. We assess the impact of such features for TF-IDF Match, Supervised Embeddings and Memory Networks. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            642
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            662,
+            326,
+            679
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our main results across all the models and tasks are given in Table 2 (extra results are also given in Table 10 of Appendix D). The first 5 rows show tasks T1-T5, and rows 6-10 show the same tasks in the out-of-vocabulary setting. Rows 11 and 12 give results for the Dialog State Tracking Challenge task (T6) and Concierge respectively. Columns 2-7 give the results of each method tried in terms of per-response accuracy and per-dialog accuracy, the latter given in parenthesis. Per-response accuracy counts the percentage of responses that are correct (i.e., the correct candidate is chosen out of all possible candidates). Per-dialog accuracy counts the percentage of dialogs where every response is correct. Ultimately, if only one response is incorrect this could result in a failed dialog, i.e. failure to achieve the goal (in this case, of achieving a restaurant booking). Note that we test Memory Networks (MemNNs) with and without match type features, the results are shown in the last two columns. The hyperparameters for all models were optimized on the validation sets; values for best performing models are given in Appendix C. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The classical IR method TF-IDF Match performs the worst of all methods, and much worse than the Nearest Neighbor IR method, which is true on both the simulated tasks T1-T5 and on the real data of T6 and Concierge. Supplementing TF-IDF Match with match type features noticeably improves performance, which however still remains far behind Nearest Neighbor IR (adding bigrams to the ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Test results across all tasks and methods. For tasks T1-T5 results are given in the standard setup and the out-of-vocabulary (OOV) setup, where words (e.g. restaurant names) may not have been seen during training. Task T6 is the Dialog state tracking 2 task with real dialogs, and only has one setup. Best performing methods (or methods within $0 . 1 \\%$ of best performing) are given in bold for the per-response accuracy metric, with the per-dialog accuracy given in parenthesis. (∗) For Concierge, an example is considered correctly answered if the correct response is ranked among the top 10 candidates by the bot, to accommodate the much larger range of semantically equivalent responses among candidates (see ex. in Tab. 7) . (†) We did not implement MemNNs+match type on Concierge, because this method requires a KB and there is none associated with it. ",
+        "bbox": [
+            173,
+            112,
+            825,
+            224
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/4fe41f8a8220a6662325c41aa4fef1baa95553194d09c67bf7c53a3942a5782c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td rowspan=\"2\">Rule-based Systems</td><td colspan=\"2\">TF-IDF Match</td><td rowspan=\"2\">Nearest</td><td colspan=\"2\">Supervised</td><td rowspan=\"2\"></td><td colspan=\"3\">Memory Networks</td></tr><tr><td>no type</td><td>+type</td><td>Neighbor</td><td>Embeddings</td><td>no match type</td><td></td><td>+ match type</td></tr><tr><td>T1: Issuing API calls</td><td>100 (100)</td><td>5.6 (0)</td><td>22.4(0)</td><td>55.1 (0)</td><td>100</td><td>(100)</td><td></td><td>99.9 (99.6)</td><td>100</td><td>(100)</td></tr><tr><td>T2: Updating API calls</td><td>100 (100)</td><td>3.4(0)</td><td>16.4(0)</td><td>68.3(0)</td><td>68.4</td><td>(0）)</td><td>100</td><td>(100)</td><td>98.3</td><td>(83.9)</td></tr><tr><td>T3:Displaying options</td><td>100 (100)</td><td>8.0 (0)</td><td>8.0 (0)</td><td>58.8 (0)</td><td>64.9</td><td>(0)</td><td>74.9</td><td>(2.0)</td><td>74.9</td><td>(0)</td></tr><tr><td>T4:Providing information</td><td>100 (100)</td><td>9.5 (0)</td><td>17.8(0)</td><td>28.6 (0)</td><td>57.2</td><td>(0)</td><td>59.5</td><td>(3.0)</td><td>100</td><td>(100)</td></tr><tr><td>T5: Full dialogs</td><td>100 (100)</td><td>4.6 (0)</td><td>8.1(0)</td><td>57.1 (0)</td><td>75.4</td><td>(0)</td><td>96.1</td><td>(49.4)</td><td>93.4</td><td>(19.7)</td></tr><tr><td>T1(OOV): Issuing API calls</td><td>100 (100)</td><td>5.8 (0）</td><td>22.4(0)</td><td>44.1 (0)</td><td>60.0</td><td>(0)</td><td>72.3</td><td>(0)</td><td>96.5</td><td>(82.7)</td></tr><tr><td>T2(OOV): Updating API calls</td><td>100 (100)</td><td>3.5 (0)</td><td>16.8(0)</td><td>68.3 (0)</td><td>68.3</td><td>(0)</td><td>78.9</td><td>(0)</td><td>94.5</td><td>(48.4)</td></tr><tr><td>T3(OOV): Displaying options</td><td>100 (100)</td><td>8.3 (0）</td><td>8.3 (0)</td><td>58.8 (0)</td><td>65.0</td><td>(0）</td><td>74.4</td><td>(0)</td><td>75.2</td><td>(0)</td></tr><tr><td>T4(OOV): Providing inform.</td><td>100 (100)</td><td>9.8 (0)</td><td>17.2(0)</td><td>28.6 (0)</td><td>57.0</td><td>(0)</td><td>57.6</td><td>(0)</td><td>100</td><td>(100)</td></tr><tr><td>T5(OOV): Full dialogs</td><td>100 (100)</td><td>4.6(0)</td><td>9.0 (0)</td><td>48.4 (0)</td><td>58.2</td><td>(0)</td><td>65.5</td><td>（0）</td><td>77.7</td><td>(0)</td></tr><tr><td>T6: Dialog state tracking 2</td><td>33.3 0</td><td>1.6(0)</td><td>1.6 (0)</td><td>21.9 （0）</td><td>22.6</td><td>0</td><td>41.1</td><td>（0)</td><td>41.0</td><td>（0</td></tr><tr><td>Concierge(*）</td><td>n/a</td><td>1.1(0.2)</td><td>n/a</td><td>13.4(0.5)</td><td>14.6</td><td>(0.5)</td><td>16.7</td><td>(1.2)</td><td>n/a(）</td><td></td></tr></table>",
+        "bbox": [
+            178,
+            233,
+            825,
+            388
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "dictionary has no effect on performance). This is in sharp contrast to other recent results on datadriven non-goal directed conversations, e.g. over dialogs on Twitter (Ritter et al., 2011) or Reddit (Dodge et al., 2016), where it was found that TF-IDF Match outperforms Nearest Neighbor, as general conversations on a given subject typically share many words. We conjecture that the goal-oriented nature of the conversation means that the conversation moves forward more quickly, sharing fewer words per (input, response) pair, e.g. consider the example in Figure 1. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            520
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Supervised embeddings outperform classical IR methods in general, indicating that learning mappings between words (via word embeddings) is important. However, only one task (T1, Issuing API calls) is completely successful. In the other tasks, some responses are correct, as shown by the per-response accuracy, however there is no dialog where the goal is actually achieved (i.e., the mean dialogaccuracy is 0). Typically the model can provide correct responses for greeting messages, asking to wait, making API calls and asking if there are any other options necessary. However, it fails to interpret the results of API calls to display options, provide information or update the calls with new information, resulting in most of its errors, even when match type features are provided. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            638
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Memory Networks (without match type features) outperform classical IR and supervised embeddings across all of the tasks. They can solve the first two tasks (issuing and updating API calls) adequately. On the other tasks, they give improved results, but do not solve them. While the per-response accuracy is improved, the per-dialog accuracy is still close to 0 on T3 and T4. Some examples of predictions of the MemNN for T1-4 are given in Appendix B. On the OOV tasks again performance is improved, but this is all due to better performance on known words, as unknown words are simply not used without the match type features. As stated in Appendix C, optimal hyperparameters on several of the tasks involve 3 or 4 hops, indicating that iterative accessing and reasoning over the conversation helps, e.g. on T3 using 1 hop gives $6 4 . 8 \\%$ while 2 hops yields $7 4 . 7 \\%$ . Appendix B displays illustrative examples of Memory Networks predictions on T 1-4 and Concierge. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            784
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Memory Networks with match type features give two performance gains over the same models without match type features: (i) T4 (providing information) becomes solvable because matches can be made to the results of the API call; and (ii) out-of-vocabulary results are significantly improved as well. Still, tasks T3 and T5 are still fail cases, performance drops slightly on T2 compared to not using match type features, and no relative improvement is observed on T6. Finally, note that matching words on its own is not enough, as evidenced by the poor performance of TF-IDF matching; this idea must be combined with types and the other properties of the MemNN model. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Unsurprisingly, perfectly coded rule-based systems can solve the simulated tasks T1-T5 perfectly, whereas our machine learning methods cannot. However, it is not easy to build an effective rule-based system when dealing with real language on real problems, and our rule based system is outperformed by MemNNs on the more realistic task T6. ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            131
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Overall, while the methods we tried made some inroads into these tasks, there are still many challenges left unsolved. Our best models can learn to track implicit dialog states and manipulate OOV words and symbols (T1-T2) to issue API calls and progress in conversations, but they are still unable to perfectly handle interpreting knowledge about entities (from returned API calls) to present results to the user, e.g. displaying options in T3. The improvement observed on the simulated tasks e.g. where MemNNs outperform supervised embeddings which in turn outperform IR methods, is also seen on the realistic data of T6 with similar relative gains. This is encouraging as it indicates that future work on breaking down, analysing and developing models over the simulated tasks should help in the real tasks as well. Results on Concierge confirm this observation: the pattern of relative performances of methods is the same on Concierge and on our series of tasks. This suggests that our synthetic data can indeed be used as an effective evaluation proxy. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            291
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            311,
+            318,
+            328
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have introduced an open dataset and task set for evaluating end-to-end goal-oriented dialog learning methods in a systematic and controlled way. We hope this will help foster progress of end-toend conversational agents because (i) existing measures of performance either prevent reproducibility (different Mechanical Turk jobs) or do not correlate well with human judgements (Liu et al., 2016); (ii) the breakdown in tasks will help focus research and development to improve the learning methods; and (iii) goal-oriented dialog has clear utility in real applications. We illustrated how to use the testbed using a variant of end-to-end Memory Networks, which prove an effective model on these tasks relative to other baselines, but are still lacking in some key areas. ",
+        "bbox": [
+            174,
+            343,
+            825,
+            455
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            473,
+            326,
+            486
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The authors would like to thank Martin Raison, Alex Lebrun and Laurent Landowski for their help with the Concierge data. ",
+        "bbox": [
+            176,
+            497,
+            823,
+            526
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            546,
+            285,
+            560
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bai, B., Weston, J., Grangier, D., Collobert, R., Sadamasa, K., Qi, Y., Chapelle, O., and Weinberger, K. (2009). Supervised semantic indexing. In Proceedings of ACM CIKM, pages 187–196. ACM.   \nBanchs, R. E. (2012). Movie-dic: a movie dialogue corpus for research and development. In Proceedings of the 50th Annual Meeting of the ACL.   \nChen, Y.-N., Hakkani-Tür, D., Tur, G., Gao, J., and Deng, L. (2016). End-to-end memory networks with knowledge carryover for multi-turn spoken language understanding. In Proceedings of Interspeech.   \nDahl, D. A., Bates, M., Brown, M., Fisher, W., Hunicke-Smith, K., Pallett, D., Pao, C., Rudnicky, A., and Shriberg, E. (1994). Expanding the scope of the atis task: The atis-3 corpus. In Proceedings of the workshop on Human Language Technology, pages 43–48. Association for Computational Linguistics.   \nDodge, J., Gane, A., Zhang, X., Bordes, A., Chopra, S., Miller, A., Szlam, A., and Weston, J. (2016). Evaluating prerequisite qualities for learning end-to-end dialog systems. In Proc. of ICLR.   \nGašic, M., Kim, D., Tsiakoulis, P., Breslin, C., Henderson, M., Szummer, M., Thomson, B., and Young, S. (2014). Incremental on-line adaptation of pomdp-based dialogue managers to extended domains. In Proceedings on InterSpeech.   \nHenderson, M., Thomson, B., and Williams, J. (2014a). The second dialog state tracking challenge. In 15th Annual Meeting of the Special Interest Group on Discourse and Dialogue, page 263.   \nHenderson, M., Thomson, B., and Young, S. (2014b). Word-based dialog state tracking with recurrent neural networks. In Proceedings of the 15th Annual Meeting of the Special Interest Group on Discourse and Dialogue (SIGDIAL), pages 292–299.   \nHixon, B., Clark, P., and Hajishirzi, H. (2015). Learning knowledge graphs for question answering through conversational dialog. In Proceedings of the the 2015 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Denver, Colorado, USA.   \nIsbell, C. L., Kearns, M., Kormann, D., Singh, S., and Stone, P. (2000). Cobot in lambdamoo: A social statistics agent. In AAAI/IAAI, pages 36–41.   \nJafarpour, S., Burges, C. J., and Ritter, A. (2010). Filter, rank, and transfer the knowledge: Learning to chat. Advances in Ranking, 10.   \nKim, S., D’Haro, L. F., Banchs, R. E., Williams, J. D., and Henderson, M. (2016). The fourth dialog state tracking challenge. In Proceedings of the 7th International Workshop on Spoken Dialogue Systems (IWSDS).   \nLemon, O., Georgila, K., Henderson, J., and Stuttle, M. (2006). An isu dialogue system exhibiting reinforcement learning of dialogue policies: generic slot-filling in the talk in-car system. In Proceedings of the 11th Conference of the European Chapter of the ACL: Posters & Demonstrations, pages 119–122.   \nLiu, C.-W., Lowe, R., Serban, I. V., Noseworthy, M., Charlin, L., and Pineau, J. (2016). How not to evaluate your dialogue system: An empirical study of unsupervised evaluation metrics for dialogue response generation. arXiv preprint arXiv:1603.08023.   \nLowe, R., Pow, N., Serban, I., and Pineau, J. (2015). The ubuntu dialogue corpus: A large dataset for research in unstructured multi-turn dialogue systems. arXiv preprint arXiv:1506.08909.   \nLowe, R., Serban, I. V., Noseworthy, M., Charlin, L., and Pineau, J. (2016). On the evaluation of dialogue systems with next utterance classification. arXiv preprint arXiv:1605.05414.   \nMikolov, T., Chen, K., Corrado, G., and Dean, J. (2013). Efficient estimation of word representations in vector space. arXiv:1301.3781.   \nPietquin, O. and Hastie, H. (2013). A survey on metrics for the evaluation of user simulations. The knowledge engineering review, 28(01), 59–73.   \nRitter, A., Cherry, C., and Dolan, W. B. (2011). Data-driven response generation in social media. In Proceedings of the Conference on Empirical Methods in Natural Language Processing.   \nSerban, I. V., Sordoni, A., Bengio, Y., Courville, A., and Pineau, J. (2015a). Building end-to-end dialogue systems using generative hierarchical neural network models. In Proc. of the AAAI Conference on Artificial Intelligence.   \nSerban, I. V., Lowe, R., Charlin, L., and Pineau, J. (2015b). A survey of available corpora for building data-driven dialogue systems. arXiv preprint arXiv:1512.05742.   \nShang, L., Lu, Z., and Li, H. (2015). Neural responding machine for short-text conversation. arXiv preprint arXiv:1503.02364.   \nSordoni, A., Galley, M., Auli, M., Brockett, C., Ji, Y., Mitchell, M., Nie, J.-Y., Gao, J., and Dolan, B. (2015). A neural network approach to context-sensitive generation of conversational responses. Proceedings of NAACL.   \nSu, P.-H., Vandyke, D., Gasic, M., Kim, D., Mrksic, N., Wen, T.-H., and Young, S. (2015a). Learning from real users: Rating dialogue success with neural networks for reinforcement learning in spoken dialogue systems. arXiv preprint arXiv:1508.03386.   \nSu, P.-H., Vandyke, D., Gasic, M., Mrksic, N., Wen, T.-H., and Young, S. (2015b). Reward shaping with recurrent neural networks for speeding up on-line policy learning in spoken dialogue systems. arXiv preprint arXiv:1508.03391.   \nSukhbaatar, S., Szlam, A., Weston, J., and Fergus, R. (2015). End-to-end memory networks. Proceedings of NIPS.   \nVinyals, O. and Le, Q. (2015). A neural conversational model. arXiv preprint arXiv:1506.05869.   \nWang, H., Lu, Z., Li, H., and Chen, E. (2013). A dataset for research on short-text conversations. In EMNLP.   \nWang, Z. and Lemon, O. (2013). A simple and generic belief tracking mechanism for the dialog state tracking challenge: On the believability of observed information. In Proceedings of the SIGDIAL 2013 Conference.   \nWen, T.-H., Gasic, M., Mrksic, N., Su, P.-H., Vandyke, D., and Young, S. (2015). Semantically conditioned lstm-based natural language generation for spoken dialogue systems. arXiv preprint arXiv:1508.01745.   \nWeston, J., Chopra, S., and Bordes, A. (2015a). Memory networks. Proceedings of ICLR.   \nWeston, J., Bordes, A., Chopra, S., and Mikolov, T. (2015b). Towards ai-complete question answering: a set of prerequisite toy tasks. arXiv preprint arXiv:1502.05698.   \nYoung, S., Gasic, M., Thomson, B., and Williams, J. D. (2013). Pomdp-based statistical spoken dialog systems: A review. Proceedings of the IEEE, 101(5), 1160–1179. ",
+        "bbox": [
+            171,
+            568,
+            826,
+            925
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            64,
+            828,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A MEMORY NETWORKS IMPLEMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            547,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Storing and representing the conversation history As the model conducts a conversation with the user, at each time step $t$ the previous utterance (from the user) and response (from the model) are appended to the memory. Hence, at any given time there are $c _ { 1 } ^ { u } , \\ldots c _ { t } ^ { u }$ user utterances and $c _ { 1 } ^ { r } , \\ldots . c _ { t - 1 } ^ { r }$ model responses stored (i.e. the entire conversation).2 The aim at time $t$ is to thus choose the next response $c _ { t } ^ { r }$ . We train on existing full dialog transcripts, so at training time we know the upcoming utterance $\\boldsymbol { c } _ { t } ^ { r }$ and can use it as a training target. Following Dodge et al. (2016), we represent each utterance as a bag-of-words and in memory it is represented as a vector using the embedding matrix $A$ , i.e. the memory is an array with entries: ",
+        "bbox": [
+            173,
+            131,
+            825,
+            223
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e4fe1c78de9fdd2dea0131748e201c3c80d8f4ec3d9c4248263262418c094a59.jpg",
+        "text": "$$\nm = ( A \\Phi ( c _ { 1 } ^ { u } ) , A \\Phi ( c _ { 1 } ^ { r } ) \\dots , A \\Phi ( c _ { t - 1 } ^ { u } ) , A \\Phi ( c _ { t - 1 } ^ { r } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            231,
+            653,
+            246
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "where $\\Phi ( \\cdot )$ maps the utterance to a bag of dimension $V$ (the vocabulary), and $A$ is a $d \\times V$ matrix, where $d$ is the embedding dimension. We retain the last user utterance $c _ { t } ^ { u }$ as the “input” to be used directly in the controller. The contents of each memory slot $m _ { i }$ so far does not contain any information of which speaker spoke an utterance, and at what time during the conversation. We therefore encode both of those pieces of information in the mapping $\\Phi$ by extending the vocabulary to contain $T = 1 0 0 0$ extra “time features” which encode the index $_ { i }$ into the bag-of-words, and two more features that encode whether the utterance was spoken by the user or the model. ",
+        "bbox": [
+            173,
+            252,
+            825,
+            342
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Attention over the memory The last user utterance $c _ { t } ^ { u }$ is embedded using the same matrix $A$ giving $q = A \\Phi ( c _ { t } ^ { u } )$ , which can also be seen as the initial state of the controller. At this point the controller reads from the memory to find salient parts of the previous conversation that are relevant to producing a response. The match between $q$ and the memories is computed by taking the inner product followed by a softmax: $p _ { i } = \\mathrm { S o f t m a x } ( u ^ { \\top } m _ { i } )$ , giving a probability vector over the memories. The vector that is returned back to the controller is then computed by $\\begin{array} { r } { o = R \\sum _ { i } ^ { } p _ { i } m _ { i } } \\end{array}$ where $R$ is a $d \\times d$ square matrix. The controller state is then updated with $q _ { 2 } = o + q$ . The memory can be iteratively reread to look for additional pertinent information using the updated state of the controller $q _ { 2 }$ instead of $q$ , and in general using $q _ { h }$ on iteration $h$ , with a fixed number of iterations $N$ (termed $N$ hops). Empirically we find improved performance on our tasks with up to 3 or 4 hops. ",
+        "bbox": [
+            173,
+            353,
+            826,
+            481
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Choosing the response The final prediction is then defined as: ",
+        "bbox": [
+            173,
+            492,
+            568,
+            506
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bfe82b2891f3af7907a5a681c8500e5af596118c307f5bae5017805b6b8a05d4.jpg",
+        "text": "$$\n\\hat { a } = \\operatorname { S o f t m a x } \\bigl ( { q _ { N + 1 } } ^ { \\top } W \\Phi ( y _ { 1 } ) , \\ldots , { q _ { N + 1 } } ^ { \\top } W \\Phi ( y _ { C } ) \\bigr )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            512,
+            660,
+            530
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "where there are $C$ candidate responses in $y$ , and $W$ is of dimension $d \\times V$ . In our tasks the set $_ y$ is a (large) set of candidate responses which includes all possible bot utterances and API calls. ",
+        "bbox": [
+            176,
+            536,
+            823,
+            564
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The entire model is trained using stochastic gradient descent (SGD), minimizing a standard cross-entropy loss between $\\hat { a }$ and the true label $a$ . ",
+        "bbox": [
+            173,
+            569,
+            821,
+            597
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B EXAMPLES OF PREDICTIONS OF A MEMORY NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            614,
+            668,
+            632
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tables 3, 4, 5 and 6 display examples of predictions of the best performing Memory Network on full dialogs, Task 5, (with 3 hops) on test examples of Tasks 1-4 along with the values of the attention over each memory for each hop ${ p } _ { i }$ as defined in Sec. A). This model does not use match type features. Then, Table 7 displays an example of prediction of the best performing Memory Network on Concierge (with 2 hops) on a test example along with the values of the attention over each memory for each hop. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            710
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            729,
+            380,
+            744
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tables 8 and 9 respectively display the values of the hyperparameters of the best Supervised Embeddings and Memory Networks selected for each task. These models were selected using the best validation validation sets. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            785
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "D ADDITIONAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            805,
+            400,
+            821
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Table 10 provides results for additional variants of supervised embeddings, using either a dictionary that includes all bigrams to leverage some word order information, or match type features. On some tasks, supervised embeddings perform better when the last user utterance is used as sole input, without the full dialog history (see Table 8). When no history is used, we slightly adapt match type features to only record type: a special word corresponding to type $T$ (e.g., phone, address, etc) is appended to the representation of a candidate if the candidate contains a word that appears in the knowledge base as an entity of type $T$ , regardless of whether the same word appeared earlier in the conversation. As seen on Table 10, match type features improve performance on out-of-vocabulary tasks 1 and 5, bringing it closer to that of Memory Networks without match type features, but still quite lagging Memory Networks with match type features. Bigrams slightly hurt rather than help performance, except in Task 5 in the standard in-vocabulary setup (performance is lower in the OOV setup). ",
+        "bbox": [
+            174,
+            835,
+            823,
+            900
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/49cbab3b2d7e850a854708adc54af6de813d8549dbe595612313c73bddc8e567.jpg",
+        "table_caption": [
+            "Table 3: Task 1 (Issue API call) The model learns to direct its attention towards the 4 memories containing the information key to issue the API call. More hops help to strengthen this signal. <silence> is a special token used to indicate that the user did not speak at this turn – the model has to carry out the conversation with no additional input. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Time</td><td>Locutor</td><td colspan=\"3\">Dialog History</td><td>Hop #1</td><td>Hop #2</td><td>Hop #3</td></tr><tr><td>1</td><td>User</td><td colspan=\"3\">hi</td><td>.054</td><td>.016</td><td>.020</td></tr><tr><td>2</td><td>Bot</td><td colspan=\"3\">hello what can i help you with today</td><td>.040</td><td>.024</td><td>.008</td></tr><tr><td>3</td><td>User</td><td colspan=\"3\">may i have a table in paris</td><td>.099</td><td>.137</td><td>.141</td></tr><tr><td>4</td><td>Bot</td><td colspan=\"3\">i&#x27;m on it</td><td>.048</td><td>.028</td><td>.004</td></tr><tr><td>5</td><td>User</td><td colspan=\"3\">&lt;silence&gt;</td><td>.181</td><td>.099</td><td>.037</td></tr><tr><td>6</td><td>Bot</td><td colspan=\"3\">any preference on a type of cuisine</td><td>.056</td><td>.090</td><td>.014</td></tr><tr><td>7</td><td>User</td><td colspan=\"3\">i love indian food</td><td>.159</td><td>.188</td><td>.238</td></tr><tr><td>8</td><td>Bot</td><td colspan=\"3\">how many people would be in your party</td><td>.051</td><td>.022</td><td>.010</td></tr><tr><td>9</td><td>User</td><td colspan=\"3\">we will be six</td><td>.129</td><td>.144</td><td>.114</td></tr><tr><td>10</td><td>Bot</td><td colspan=\"3\">which price range are looking for</td><td>.039</td><td>.028</td><td>.006</td></tr><tr><td>11</td><td>User</td><td colspan=\"3\">in a moderate price range please</td><td>.128</td><td>.213</td><td>.405</td></tr><tr><td>12</td><td>Bot</td><td colspan=\"3\">ok let me look into some options for you</td><td>.016</td><td>.011</td><td>.003</td></tr><tr><td colspan=\"2\">User input</td><td colspan=\"6\">&lt;silence&gt;</td></tr><tr><td colspan=\"2\">Correct answer</td><td>api_call indian</td><td>paris</td><td>six moderate</td><td></td><td></td><td></td></tr><tr><td colspan=\"2\">Predicted answer</td><td>api_call</td><td>indian paris six moderate</td><td></td><td>[Correct]</td><td></td><td></td></tr></table>",
+        "bbox": [
+            176,
+            226,
+            823,
+            431
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/e3adf4976e07d0e628a1e9abd25e0a1b90fb9988efb050a689baf3843e735cd3.jpg",
+        "table_caption": [
+            "Table 4: Task 2 (Update API call) Out of the multiple memories from the current dialog, the model correctly focuses on the 2 important pieces: the original API call and the utterance giving the update. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Time</td><td rowspan=1 colspan=1>Locutor</td><td rowspan=1 colspan=3>Dialog history</td><td rowspan=1 colspan=1>Hop #1</td><td rowspan=1 colspan=1>Hop #2</td><td rowspan=1 colspan=1>Hop #3</td></tr><tr><td rowspan=2 colspan=1>34</td><td rowspan=2 colspan=1>UserBot</td><td rowspan=2 colspan=3>mayihavea table in parisi&#x27;m on it</td><td rowspan=1 colspan=1>.061</td><td rowspan=1 colspan=1>.072</td><td rowspan=1 colspan=1>.040</td></tr><tr><td rowspan=1 colspan=1>.026</td><td rowspan=1 colspan=1>.012</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=2 colspan=1>56</td><td rowspan=2 colspan=1>UserBot</td><td rowspan=5 colspan=3>&lt;silence&gt;any preference on a type of cuisinei love indian foodhow many people would be in your partywe will be six</td><td rowspan=1 colspan=1>.087</td><td rowspan=1 colspan=1>.042</td><td rowspan=1 colspan=1>.012</td></tr><tr><td rowspan=1 colspan=1>.026</td><td rowspan=1 colspan=1>.023</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=6 colspan=1>789101112</td><td rowspan=6 colspan=1>UserBotUserBotUserBot</td><td rowspan=1 colspan=1>i</td><td rowspan=1 colspan=1>.081</td><td rowspan=1 colspan=1>.070</td><td rowspan=1 colspan=1>.055</td></tr><tr><td rowspan=1 colspan=2>how</td><td rowspan=1 colspan=1>.025</td><td rowspan=1 colspan=1>.006</td><td rowspan=2 colspan=1>.001.018</td></tr><tr><td rowspan=4 colspan=3>we will be sixwhich price range are looking forin a moderate price range pleaseok let me look into some options for you</td><td rowspan=1 colspan=1>.059</td><td rowspan=2 colspan=1>.051.043</td><td rowspan=2 colspan=1>.018.004</td></tr><tr><td rowspan=1 colspan=1>.038</td></tr><tr><td rowspan=1 colspan=1>.080</td><td rowspan=1 colspan=1>.095</td><td rowspan=1 colspan=1>.096</td></tr><tr><td rowspan=1 colspan=1>.025</td><td rowspan=1 colspan=1>.042</td><td rowspan=1 colspan=1>.003</td></tr><tr><td rowspan=1 colspan=1>13</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=3>&lt;silence&gt;</td><td rowspan=1 colspan=1>.127</td><td rowspan=1 colspan=1>.069</td><td rowspan=1 colspan=1>.032</td></tr><tr><td rowspan=1 colspan=1>14</td><td rowspan=1 colspan=1>Bot</td><td rowspan=2 colspan=3>api_call indian paris six moderateinstead could it be with french food</td><td rowspan=1 colspan=1>.062</td><td rowspan=1 colspan=1>.113</td><td rowspan=1 colspan=1>.043</td></tr><tr><td rowspan=4 colspan=1>15161718</td><td rowspan=4 colspan=1>UserBotUserBot</td><td rowspan=4 colspan=3>instead could it be with french foodsure is there anything else to updatenook let me look into some options for you</td><td rowspan=1 colspan=1>.188</td><td rowspan=1 colspan=1>.311</td><td rowspan=1 colspan=1>.683</td></tr><tr><td rowspan=1 colspan=1>.016</td><td rowspan=1 colspan=1>.007</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=2 colspan=1>.028.011</td><td rowspan=1 colspan=1>.013</td><td rowspan=1 colspan=1>.007</td></tr><tr><td rowspan=1 colspan=1>.006</td><td rowspan=1 colspan=1>.000</td></tr><tr><td rowspan=1 colspan=2>User input</td><td rowspan=1 colspan=6>&lt;silence&gt;</td></tr><tr><td rowspan=1 colspan=2>Correct answer</td><td rowspan=1 colspan=6>api__callfrenchparissix moderate</td></tr><tr><td rowspan=1 colspan=2>Predictedanswer</td><td rowspan=1 colspan=4>api_callfrench paris six moderate  [Correct]</td><td rowspan=1 colspan=2></td></tr></table>",
+        "bbox": [
+            176,
+            602,
+            823,
+            857
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/4b963192eec7e422314ec1bc7dbcadeab931f877bdb8536a1638fcae7b1b4c64.jpg",
+        "table_caption": [
+            "Table 5: Task 3 (Displaying options) The model knows it has to display options but the attention is wrong: it should attend on the ratings to select the best option (with highest rating). It cannot learn that properly and match type features do not help. It is correct here by luck, the task is not solved overall (see Tab. 2). We do not show all memories in the table, only those with meaningful attention. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Time</td><td>Locutor</td><td>Dialog history</td><td></td><td>Hop #1</td><td>Hop #2</td><td>Hop #3</td></tr><tr><td>14</td><td>Bot</td><td></td><td>api_call indian paris six moderate</td><td>.012</td><td>.000</td><td>.000</td></tr><tr><td>15</td><td>User</td><td></td><td>instead could it be with french food</td><td>.067</td><td>.103</td><td>.147</td></tr><tr><td>20</td><td>Bot</td><td></td><td>api_call french paris six moderate</td><td>.012</td><td>.000</td><td>.000</td></tr><tr><td>21</td><td>User</td><td>resto_1</td><td>r_phone rest_1_phone</td><td>.018</td><td>.004</td><td>.000</td></tr><tr><td>23</td><td>User</td><td>resto_1</td><td>1 r_cuisine french</td><td>.029</td><td>.005</td><td>.000</td></tr><tr><td>24</td><td>User</td><td>resto_1</td><td>r_location paris</td><td>.060</td><td>.292</td><td>.094</td></tr><tr><td>25</td><td>User</td><td>resto_1</td><td>r_number six</td><td>.050</td><td>.298</td><td>.745</td></tr><tr><td>26</td><td>User</td><td>resto_1</td><td>r_price moderate</td><td>.060</td><td>.090</td><td>.002</td></tr><tr><td>27</td><td>User</td><td>resto_1</td><td>r_rating 6</td><td>.016</td><td>.002</td><td>.000</td></tr><tr><td>30</td><td>User</td><td>resto_2</td><td>r_cuisine french</td><td>.031</td><td>.007</td><td>.000</td></tr><tr><td>31</td><td>User</td><td>resto_2</td><td>r_location paris</td><td>.040</td><td>.081</td><td>.004</td></tr><tr><td>32</td><td>User</td><td>resto_2</td><td>r_number six</td><td>.020</td><td>.012</td><td>.000</td></tr><tr><td>33</td><td>User</td><td>resto_2</td><td>r_price moderate</td><td>.029</td><td>.009</td><td>.000</td></tr><tr><td>37</td><td>User</td><td>resto_3</td><td>r_cuisine french</td><td>.014</td><td>.001</td><td>.000</td></tr><tr><td>38</td><td>User</td><td>resto_3</td><td>r_location paris</td><td>.028</td><td>.016</td><td>.001</td></tr><tr><td>39</td><td>User</td><td>resto_3</td><td>r_number six</td><td>.024</td><td>.022</td><td>.004</td></tr><tr><td>40</td><td>User</td><td>resto_3</td><td>r_price moderate</td><td>.039</td><td>.015</td><td>.001</td></tr><tr><td colspan=\"2\">User input</td><td colspan=\"6\">&lt;silence&gt;</td></tr><tr><td colspan=\"2\">Correct answer</td><td colspan=\"6\">what do you think of this option:resto_1</td></tr><tr><td colspan=\"2\">Predictedanswer</td><td colspan=\"6\">what do you think of this option:resto_1 [Correct]</td></tr></table>",
+        "bbox": [
+            176,
+            170,
+            820,
+            439
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/0842b8fcd04cdd11a5ddd427b3bd2bfb4565a80e5c620ca5913acd400ecc84c5.jpg",
+        "table_caption": [
+            "Table 6: Task 4 (Providing extra-information) The model knows it must display a phone or an address, but, as explained in Section A the embeddings mix up the information and make it hard to distinguish between different phone numbers or addresses, making answering correctly very hard. As shown in the results of Tab. 2, this problem can be solved by adding match type features, that allow to emphasize entities actually appearing in the history. The attention is globally wrong here. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Time</td><td rowspan=1 colspan=1>Locutor</td><td rowspan=1 colspan=2>Dialog history</td><td rowspan=1 colspan=2>Hop #1</td><td rowspan=1 colspan=1>Hop #2</td><td rowspan=1 colspan=1>Hop #3</td></tr><tr><td rowspan=2 colspan=1>1415</td><td rowspan=1 colspan=1>Bot</td><td rowspan=2 colspan=2>api_call indian paris six moderateinstead could it be with french food</td><td rowspan=1 colspan=2>.006</td><td rowspan=1 colspan=1>.000</td><td rowspan=1 colspan=1>.000</td></tr><tr><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=2>.024</td><td rowspan=1 colspan=1>.011</td><td rowspan=1 colspan=1>.007</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>Bot</td><td rowspan=1 colspan=2>api_call french paris six moderate</td><td rowspan=1 colspan=2>.005</td><td rowspan=1 colspan=1>.000</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=1 colspan=1>21</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=2>resto_1 r_phone resto_l_phone</td><td rowspan=1 colspan=2>.011</td><td rowspan=1 colspan=1>.005</td><td rowspan=1 colspan=1>.004</td></tr><tr><td rowspan=1 colspan=1>22</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=2>resto_1 r_address resto_1_address</td><td rowspan=1 colspan=2>.018</td><td rowspan=1 colspan=1>.004</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=1 colspan=1>23</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_1</td><td rowspan=1 colspan=1>.r_cuisine french</td><td rowspan=1 colspan=2>.018</td><td rowspan=1 colspan=1>.003</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=1 colspan=1>24</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_1</td><td rowspan=1 colspan=1>r_location paris</td><td rowspan=1 colspan=2>.068</td><td rowspan=1 colspan=1>.091</td><td rowspan=1 colspan=1>.108</td></tr><tr><td rowspan=1 colspan=1>25</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_1</td><td rowspan=1 colspan=1>r_number six</td><td rowspan=1 colspan=2>.086</td><td rowspan=1 colspan=1>.078</td><td rowspan=1 colspan=1>.020</td></tr><tr><td rowspan=1 colspan=1>26</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_1</td><td rowspan=1 colspan=1>r_price moderate</td><td rowspan=1 colspan=2>.070</td><td rowspan=1 colspan=1>.225</td><td rowspan=1 colspan=1>.369</td></tr><tr><td rowspan=1 colspan=1>27</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_1</td><td rowspan=1 colspan=1>r_rating 6</td><td rowspan=1 colspan=2>.014</td><td rowspan=1 colspan=1>.006</td><td rowspan=1 colspan=1>.008</td></tr><tr><td rowspan=1 colspan=1>28</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_2</td><td rowspan=1 colspan=1>r_phone resto_2_phone</td><td rowspan=1 colspan=2>.015</td><td rowspan=1 colspan=1>.009</td><td rowspan=1 colspan=1>.006</td></tr><tr><td rowspan=1 colspan=1>29</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_2</td><td rowspan=1 colspan=1>r_address resto_2_address</td><td rowspan=1 colspan=2>.014</td><td rowspan=1 colspan=1>.004</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=1 colspan=1>31</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_2</td><td rowspan=1 colspan=1>r_location paris</td><td rowspan=1 colspan=2>.075</td><td rowspan=1 colspan=1>.176</td><td rowspan=1 colspan=1>.193</td></tr><tr><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_2</td><td rowspan=1 colspan=1>r_number six</td><td rowspan=1 colspan=2>.100</td><td rowspan=1 colspan=1>.126</td><td rowspan=1 colspan=1>.026</td></tr><tr><td rowspan=1 colspan=1>33</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_2</td><td rowspan=1 colspan=1>r_price moderate</td><td rowspan=1 colspan=2>.038</td><td rowspan=1 colspan=1>.090</td><td rowspan=1 colspan=1>.167</td></tr><tr><td rowspan=1 colspan=1>35</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_3</td><td rowspan=1 colspan=1>r_phone resto_3_phone</td><td rowspan=1 colspan=2>.004</td><td rowspan=1 colspan=1>.001</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=1 colspan=1>36</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_3</td><td rowspan=1 colspan=1>r_address resto_3_address</td><td rowspan=1 colspan=2>.005</td><td rowspan=1 colspan=1>.002</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=1 colspan=1>37</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_3</td><td rowspan=1 colspan=1>resto_3 r_location paris</td><td rowspan=1 colspan=2>.028</td><td rowspan=1 colspan=1>.028</td><td rowspan=1 colspan=1>.026</td></tr><tr><td rowspan=1 colspan=1>39</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_3</td><td rowspan=1 colspan=1>resto_3 r_number six</td><td rowspan=1 colspan=2>.039</td><td rowspan=1 colspan=1>.013</td><td rowspan=1 colspan=1>.002</td></tr><tr><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>User</td><td rowspan=1 colspan=1>resto_3</td><td rowspan=1 colspan=1>resto_3 r_price moderate</td><td rowspan=1 colspan=2>.018</td><td rowspan=1 colspan=1>.008</td><td rowspan=1 colspan=1>.013</td></tr><tr><td rowspan=1 colspan=1>42</td><td rowspan=1 colspan=1>Bot</td><td rowspan=2 colspan=2>what do you think of this option: resto_1let&#x27;s do it</td><td rowspan=1 colspan=2>.074</td><td rowspan=1 colspan=1>.001</td><td rowspan=1 colspan=1>.000</td></tr><tr><td rowspan=2 colspan=1>4344</td><td rowspan=2 colspan=1>UserBot</td><td rowspan=1 colspan=2>.032</td><td rowspan=1 colspan=1>.004</td><td rowspan=1 colspan=1>.001</td></tr><tr><td rowspan=1 colspan=2>great let me do the reservation</td><td rowspan=1 colspan=2>.003</td><td rowspan=1 colspan=1>.000</td><td rowspan=1 colspan=1>.000</td></tr><tr><td rowspan=1 colspan=2>User input</td><td rowspan=3 colspan=6>do you have itsaddresshere it is resto_1_addresshereitis:resto_8_address                          [Incorrect]</td></tr><tr><td rowspan=1 colspan=2>Correctanswer</td><td rowspan=2 colspan=3>here it is resto_1_addresshereitis:resto_8_address</td></tr><tr><td rowspan=1 colspan=2>Predictedanswer</td></tr></table>",
+        "bbox": [
+            176,
+            569,
+            821,
+            911
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/aa28576536d29c67bda0ef090e6e946e541059fd07f1104dda2ed1c365fb775a.jpg",
+        "table_caption": [
+            "Table 7: Concierge Data The model is also able to learn from human-human dialogs. <person>, <org>, <number> and <date> are special tokens used to anonymize the data. We report the top 5 answers predicted by the model. They are all semantically equivalent. Note that the utterances, while all produced by humans, are not perfect English (\"rservation\", \"I’ll check into it\") "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Time</td><td>Locutor</td><td>Dialog History</td><td>Hop #1</td><td>Hop #2</td></tr><tr><td>1</td><td>User</td><td>hey concierge</td><td>.189</td><td>.095</td></tr><tr><td>2</td><td>User</td><td>could you check if i can get a rservation at &lt;org&gt; &lt;date&gt; for brunch</td><td>.209</td><td>.178</td></tr><tr><td>134</td><td>User</td><td>&lt;number&gt; people</td><td>.197</td><td>.142</td></tr><tr><td>5</td><td>User</td><td>&lt;silence&gt;</td><td>.187</td><td>.167</td></tr><tr><td></td><td>Bot</td><td>hi &lt;person&gt; unfortunately &lt;org&gt; is fully booked for &lt;date&gt;</td><td>.225</td><td>.410</td></tr><tr><td>User input</td><td></td><td>and there&#x27;s &lt;number&gt; people on the waiting list when&#x27;sthe earliestavailability</td><td></td><td></td></tr><tr><td colspan=\"2\">Correctanswer</td><td colspan=\"3\">i&#x27;ll check</td></tr><tr><td colspan=\"2\">Pred.answer#1</td><td>i&#x27;m on it</td><td>[Incorrect]</td><td></td></tr><tr><td colspan=\"2\">Pred.answer #2</td><td>i&#x27;ll find out</td><td colspan=\"2\">[Incorrect]</td></tr><tr><td colspan=\"2\">Pred.answer #3</td><td>i&#x27;ll take a look</td><td colspan=\"2\">[Incorrect]</td></tr><tr><td colspan=\"2\">Pred.answer #4</td><td>i&#x27;ll check</td><td colspan=\"2\">[Correct]</td></tr><tr><td colspan=\"2\"></td><td></td><td colspan=\"2\"></td></tr><tr><td colspan=\"2\">Pred.answer #5</td><td>i&#x27;ll check into it</td><td colspan=\"2\">[Incorrect]</td></tr></table>",
+        "bbox": [
+            173,
+            179,
+            844,
+            361
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/4ff43a925cd3b6749e407a803f5d44c63d196bc1f92580bc7823466c7640895a.jpg",
+        "table_caption": [
+            "Table 8: Hyperparameters of Supervised Embeddings. When Use History is True, the whole conversation history is concatenated with the latest user utterance to create the input. If False, only the latest utterance is used as input. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>Learning Rate</td><td rowspan=1 colspan=1>Margin m</td><td rowspan=1 colspan=1>Embedding Dim d</td><td rowspan=1 colspan=1>Negative Cand. N</td><td rowspan=1 colspan=1>Use History</td></tr><tr><td rowspan=2 colspan=1>Task 1Task 2</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>100</td><td rowspan=3 colspan=1>TrueFalseFalseFalseTrue</td></tr><tr><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>Task 3Task 4Task 5</td><td rowspan=1 colspan=1>0.010.0010.01</td><td rowspan=1 colspan=1>0.10.10.01</td><td rowspan=1 colspan=1>12812832</td><td rowspan=1 colspan=1>10001000100</td></tr><tr><td rowspan=1 colspan=1>Task 6</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>False</td></tr><tr><td rowspan=1 colspan=1>Concierge</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>False</td></tr></table>",
+        "bbox": [
+            173,
+            443,
+            843,
+            559
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/1cbc2ae913d6cb18ffc1cf4ab099d84d5f47239e2d69f458cdad176e70490710.jpg",
+        "table_caption": [
+            "Table 9: Hyperparameters of Memory Networks. The longer and more complex the dialogs are, the more hops are needed. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>Learning Rate</td><td>Margin m</td><td>Embedding Dimd</td><td>Negative Cand. N</td><td>Nb Hops</td></tr><tr><td>Task 1</td><td>0.01</td><td>0.1</td><td>128</td><td>100</td><td>1</td></tr><tr><td>Task 2</td><td>0.01</td><td>0.1</td><td>32</td><td>100</td><td>1</td></tr><tr><td>Task 3</td><td>0.01</td><td>0.1</td><td>32</td><td>100</td><td>3</td></tr><tr><td>Task 4</td><td>0.01</td><td>0.1</td><td>128</td><td>100</td><td>2</td></tr><tr><td>Task 5</td><td>0.01</td><td>0.1</td><td>32</td><td>100</td><td>3</td></tr><tr><td>Task 6</td><td>0.01</td><td>0.1</td><td>128</td><td>100</td><td>4</td></tr><tr><td>Concierge</td><td>0.001</td><td>0.1</td><td>128</td><td>100</td><td>2</td></tr></table>",
+        "bbox": [
+            174,
+            617,
+            823,
+            732
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            765,
+            825,
+            829
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/f0b3ab2d26e71d58bff7193d8d3dab43d556664a9550e221114d8401c7d110c4.jpg",
+        "table_caption": [
+            "Table 10: Test results across all tasks and methods. For tasks T1-T5 results are given in the standard setup and the out-of-vocabulary (OOV) setup, where words (e.g. restaurant names) may not have been seen during training. Task T6 is the Dialog state tracking 2 task with real dialogs, and only has one setup. Best performing methods (or methods within $0 . 1 \\%$ of best performing) are given in bold for the per-response accuracy metric, with the per-dialog accuracy given in parenthesis. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Task</td><td colspan=\"4\">Supervised Embeddings</td><td rowspan=\"2\"></td><td colspan=\"3\">Memory Networks + match type</td></tr><tr><td>no match type no bigram</td><td>+ match type no bigram</td><td></td><td>+bigrams no match type</td><td colspan=\"3\"> no match type</td></tr><tr><td>T1: Issuing API calls</td><td>100</td><td>(100) 83.2</td><td>(0)</td><td>98.6</td><td>(92.4)</td><td>99.9</td><td>(99.6)</td><td>100 (100)</td></tr><tr><td>T2: Updating API calls</td><td>68.4 （0)</td><td>68.4</td><td>(0）</td><td>68.3 (0)</td><td>100</td><td>(100)</td><td>98.3</td><td>(83.9)</td></tr><tr><td>T3:Displaying options</td><td>64.9 （0）</td><td>64.9</td><td>(0）</td><td>64.9 (0)</td><td></td><td>74.9 (2.0)</td><td>74.9</td><td>(0)</td></tr><tr><td>T4:Providing information</td><td>57.2 （0）</td><td>57.2</td><td>（0）</td><td>57.3 (0)</td><td>59.5</td><td>(3.0)</td><td>100</td><td>(100)</td></tr><tr><td>T5: Full dialogs</td><td>75.4 0）</td><td>76.2</td><td>（0）</td><td>83.4 (0)</td><td></td><td>96.1 (49.4)</td><td>93.4</td><td>(19.7)</td></tr><tr><td>T1(OOV): Issuing API calls</td><td>60.0 (0)</td><td>67.2</td><td>（0)</td><td>58.8 (0)</td><td></td><td>72.3 (0)</td><td>96.5</td><td>(82.7)</td></tr><tr><td>T2(OOV): Updating API calls</td><td>68.3 （0）</td><td>68.3</td><td>（0）</td><td>68.3</td><td>(0)</td><td>78.9 (0)</td><td>94.5</td><td>(48.4)</td></tr><tr><td>T3(OOV): Displaying options</td><td>65.0 （0）</td><td>65.0</td><td>（0)</td><td>62.1 (0)</td><td></td><td>74.4 （0)</td><td>75.2</td><td>(0)</td></tr><tr><td>T4(OOV): Providing inform.</td><td>57.0 （0）</td><td>57.1</td><td>（0）</td><td>57.0 (0)</td><td></td><td>57.6 (0)</td><td>100</td><td>(100)</td></tr><tr><td>T5(OOV): Full dialogs</td><td>58.2 0）</td><td>64.4</td><td>（0）</td><td>50.4</td><td>（0）</td><td>65.5 （0)</td><td>77.7</td><td>(0)</td></tr><tr><td>T6: Dialog state tracking 2</td><td>22.6 0)</td><td>22.1</td><td>（0)</td><td>21.8</td><td>（0)</td><td>41.1 （0)</td><td></td><td>41.0 （0）</td></tr></table>",
+        "bbox": [
+            179,
+            469,
+            825,
+            637
+        ],
+        "page_idx": 14
+    }
+]

parse/train/SyProzZAW/SyProzZAW.md

@@ -0,0 +1,427 @@
+# THE POWER OF DEEPER NETWORKS FOR EXPRESSING NATURAL FUNCTIONS
+
+David Rolnick, Max Tegmark Massachusetts Institute of Technology {drolnick, tegmark}@mit.edu
+
+# ABSTRACT
+
+It is well-known that neural networks are universal approximators, but that deeper networks tend in practice to be more powerful than shallower ones. We shed light on this by proving that the total number of neurons $m$ required to approximate natural classes of multivariate polynomials of $n$ variables grows only linearly with $n$ for deep neural networks, but grows exponentially when merely a single hidden layer is allowed. We also provide evidence that when the number of hidden layers is increased from 1 to $k$ , the neuron requirement grows exponentially not with $n$ but with $n ^ { 1 / k }$ , suggesting that the minimum number of layers required for practical expressibility grows only logarithmically with $n$ .
+
+# 1 INTRODUCTION
+
+Deep learning has lately been shown to be a very powerful tool for a wide range of problems, from image segmentation to machine translation. Despite its success, many of the techniques developed by practitioners of artificial neural networks (ANNs) are heuristics without theoretical guarantees. Perhaps most notably, the power of feedforward networks with many layers (deep networks) has not been fully explained. The goal of this paper is to shed more light on this question and to suggest heuristics for how deep is deep enough.
+
+It is well-known (Cybenko, 1989; Funahashi, 1989; Hornik et al., 1989; Barron, 1994; Pinkus, 1999) that neural networks with a single hidden layer can approximate any function under reasonable assumptions, but it is possible that the networks required will be extremely large. Recent authors have shown that some functions can be approximated by deeper networks much more efficiently (i.e. with fewer neurons) than by shallower ones. Often, these results admit one or more of the following limitations: “existence proofs” without explicit constructions of the functions in question; explicit constructions, but relatively complicated functions; or applicability only to types of network rarely used in practice.
+
+It is important and timely to extend this work to make it more concrete and actionable, by deriving resource requirements for approximating natural classes of functions using today’s most common neural network architectures. Lin et al. (2017) recently proved that it is exponentially more efficient to use a deep network than a shallow network when Taylor-approximating the product of input variables. In the present paper, we move far beyond this result in the following ways: (i) we use standard uniform approximation instead of Taylor approximation, (ii) we show that the exponential advantage of depth extends to all general sparse multivariate polynomials, and (iii) we address the question of how the number of neurons scales with the number of layers. Our results apply to standard feedforward neural networks and are borne out by empirical tests.
+
+Our primary contributions are as follows:
+
+• It is possible to achieve arbitrarily close approximations of simple multivariate and univariate polynomials with neural networks having a bounded number of neurons (see $\ S 3$ ). • Such polynomials are exponentially easier to approximate with deep networks than with shallow networks (see $\ S 4$ ).
+
+• The power of networks improves rapidly with depth; for natural polynomials, the number of layers required is at most logarithmic in the number of input variables, where the base of the logarithm depends upon the layer width (see §5).
+
+# 2 RELATED WORK
+
+Deeper networks have been shown to have greater representational power with respect to various notions of complexity, including piecewise linear decision boundaries (Montufar et al., 2014) and topological invariants (Bianchini & Scarselli, 2014). Recently, Poole et al. (2016) and Raghu et al. (2016) showed that the trajectories of input variables attain exponentially greater length and curvature with greater network depth.
+
+Work including Daniely (2017); Eldan & Shamir (2016); Pinkus (1999); Poggio et al. (2017); Telgarsky (2016) shows that there exist functions that require exponential width to be approximated by a shallow network. Barron (1994) provides bounds on the error in approximating general functions by shallow networks. Mhaskar et al. (2016) and Poggio et al. (2017) show that for compositional functions (those that can be expressed by recursive function composition), the number of neurons required for approximation by a deep network is exponentially smaller than the best known upper bounds for a shallow network. Mhaskar et al. (2016) ask whether functions with tight lower bounds must be pathologically complicated, a question which we answer here in the negative.
+
+Various authors have also considered the power of deeper networks of types other than the standard feedforward model. The problem has also been posed for sum-product networks (Delalleau & Bengio, 2011) and restricted Boltzmann machines (Martens et al., 2013). Cohen et al. (2016) showed, using tools from tensor decomposition, that shallow arithmetic circuits can express only a measure-zero set of the functions expressible by deep circuits. A weak generalization of this result to convolutional neural networks was shown in Cohen & Shashua (2016).
+
+# 3 THE POWER OF APPROXIMATION
+
+In this paper, we will consider the standard model of feedforward neural networks (also called multilayer perceptrons). Formally, the network may be considered as a multivariate function $N ( \mathbf { x } ) =$ $\mathbf { A } _ { k } \sigma ( \cdot \cdot \cdot \sigma ( \mathbf { A } _ { 1 } \sigma ( \mathbf { A } _ { 0 } \mathbf { x } ) ) \cdot \cdot \cdot )$ , where $\mathbf { A } _ { 0 } , \mathbf { A } _ { 1 } , \ldots , \mathbf { A } _ { k }$ are constant matrices and $\sigma$ denotes a scalar nonlinear function applied element-wise to vectors. The constant $k$ is referred to as the depth of the network. The neurons of the network are the entries of the vectors $\sigma ( \mathbf { A } _ { \ell } \cdot \cdot \cdot \sigma ( \mathbf { A } _ { 1 } \sigma ( \mathbf { A } _ { 0 } \mathbf { x } ) ) \cdot \cdot \cdot )$ , for $\ell = 1 , \dots , k - 1$ . These vectors are referred to as the hidden layers of the network.
+
+Two notions of approximation will be relevant in our results: $\epsilon$ -approximation, also known as uniform approximation, and Taylor approximation.
+
+Definition 3.1. For constant $\epsilon > 0$ , we say that a network $N ( \mathbf { x } )$ $\epsilon$ -approximates a multivariate function $f ( \mathbf { x } )$ (for $\mathbf { x }$ in a specified domain $( - R , R ) ^ { n } ) i f \operatorname* { s u p } _ { \mathbf { x } } | N ( \mathbf { x } ) - f ( \mathbf { x } ) | < \epsilon .$ .
+
+Definition 3.2. We say that a network $N ( \mathbf { x } )$ Taylor-approximates $a$ multivariate polynomial $p ( \mathbf { x } )$ of degree d if $p ( \mathbf { x } )$ is the dth order Taylor polynomial (about the origin) of $N ( \mathbf { x } )$ .
+
+The following proposition shows that Taylor approximation implies $\epsilon$ -approximation for homogeneous polynomials. The reverse implication does not hold.
+
+Proposition 3.3. Suppose that the network $N ( \mathbf { x } )$ Taylor-approximates the homogeneous multivariate polynomial $p ( \mathbf { x } )$ . Then, for every , there exists a network $N _ { \epsilon } ( \mathbf { x } )$ that $\epsilon$ -approximates $p ( \mathbf { x } )$ , such that $N ( \mathbf { x } )$ and $N _ { \epsilon } ( \mathbf { x } )$ have the same number of neurons in each layer. (This statement holds for $\mathbf { x } \in ( - R , R ) ^ { n }$ for any specified $R .$ .)
+
+Proof. Suppose that ${ \cal N } ( { \bf x } ) = { \bf A } _ { k } \sigma ( \cdot \cdot \cdot \sigma ( { \bf A } _ { 1 } \sigma ( { \bf A } _ { 0 } { \bf x } ) ) \cdot \cdot \cdot )$ and that $p ( \mathbf { x } )$ has degree $d$ . Since $p ( \mathbf { x } )$ is a Taylor approximation of $N ( \mathbf { x } )$ , we can write $N ( \mathbf { x } )$ as $p ( \mathbf { x } ) + E ( \mathbf { x } )$ , where $\begin{array} { r } { E ( \bar { \mathbf { x } } ) = \sum _ { i = d + 1 } ^ { \infty } \bar { E } _ { i } ( \mathbf { x } ) } \end{array}$ is a Taylor series with each $E _ { i } ( \mathbf { x } )$ homogeneous of degree $i$ . Since $N ( \mathbf { x } )$ is the function defined by a neural network, it converges for every $\mathbf { x } \in \mathbb { R } ^ { n }$ . Thus, $E ( \mathbf { x } )$ converges, as does $E ( \delta \mathbf { x } ) / \delta ^ { d } =$ $\bar { \sum _ { i = d + 1 } ^ { \infty } \delta ^ { i - d } E _ { i } ( \mathbf { x } ) }$ . By picking $\delta$ sufficiently small, we can make each term $\delta ^ { i - d } E _ { i } ( \mathbf { x } )$ arbitrarily small. Let $\delta$ be small enough that $| E ( \delta \mathbf { x } ) / \delta ^ { d } | < \epsilon$ holds for all $\mathbf { x }$ in $( - R , R ) ^ { n }$ .
+
+Let $\mathbf { A } _ { 0 } ^ { \prime } = \delta \mathbf { A } _ { 0 }$ , ${ \bf A } _ { k } ^ { \prime } = { \bf A } _ { k } / \delta ^ { d }$ , and ${ \bf A } _ { \ell } ^ { \prime } = { \bf A } _ { \ell }$ for $\ell = 1 , 2 , \dots , k - 1$ . Then, for $N _ { \epsilon } ( \mathbf { x } ) \ =$ $\mathbf { A } _ { k } ^ { \prime } \sigma ( \cdot \cdot \cdot \sigma ( \mathbf { A } _ { 1 } ^ { \prime } \sigma ( \mathbf { A } _ { 0 } ^ { \prime } \mathbf { x } ) ) \cdot \cdot \cdot )$ , we observe that $N _ { \epsilon } ( { \bf x } ) = N ( \delta { \bf x } ) / \delta ^ { d }$ , and therefore:
+
+$$
+\begin{array} { r l } & { | N _ { \epsilon } ( \mathbf { x } ) - p ( \mathbf { x } ) | = | N ( \delta \mathbf { x } ) / \delta ^ { d } - p ( \mathbf { x } ) | } \\ & { \qquad = | p ( \delta \mathbf { x } ) / \delta ^ { d } + E ( \delta \mathbf { x } ) / \delta ^ { d } - p ( \mathbf { x } ) | } \\ & { \qquad = | E ( \delta \mathbf { x } ) / \delta ^ { d } | } \\ & { \qquad < \epsilon . } \end{array}
+$$
+
+We conclude that $N _ { \epsilon } ( \mathbf { x } )$ is an $\epsilon$ -approximation of $p ( \mathbf { x } )$ , as desired.
+
+For a fixed nonlinear function $\sigma$ , we consider the total number of neurons (excluding input and output neurons) needed for a network to approximate a given function. Remarkably, it is possible to attain arbitrarily good approximations of a (not necessarily homogeneous) multivariate polynomial by a feedforward neural network, even with a single hidden layer, without increasing the number of neurons past a certain bound. (See also Corollary 1 in Poggio et al. (2017).)
+
+Theorem 3.4. Suppose that $p ( \mathbf { x } )$ is a degree- $d$ multivariate polynomial and that the nonlinearity $\sigma$ has nonzero Taylor coefficients up to degree $d .$ . Let $m _ { k } ^ { \epsilon } ( p )$ be the minimum number of neurons in $a$ depth- $k$ network that -approximates $p$ . Then, the limit $\begin{array} { r } { \operatorname* { l i m } _ { \epsilon \to 0 } m _ { k } ^ { \epsilon } ( p ) } \end{array}$ exists (and is finite). (Once again, this statement holds for $\mathbf { x } \in ( - R , R ) ^ { n }$ for any specified $R .$ )
+
+Proof. We show that $\scriptstyle \operatorname* { l i m } _ { \epsilon \to 0 } m _ { 1 } ^ { \epsilon } ( p )$ exists; it follows immediately that $\scriptstyle \operatorname* { l i m } _ { \epsilon \to 0 } m _ { k } ^ { \epsilon } ( p )$ exists for every $k$ , since an $\epsilon$ -approximation to $p$ with depth $k$ can be constructed from one with depth 1.
+
+Let $p _ { 1 } ( \mathbf { x } ) , p _ { 2 } ( \mathbf { x } ) , \ldots , p _ { s } ( \mathbf { x } )$ be the monomials of $p ( \mathbf { x } )$ , so that $\begin{array} { r } { p ( \mathbf { x } ) = \sum _ { i } p _ { i } ( \mathbf { x } ) } \end{array}$ . We claim that each $p _ { i } ( { \bf x } )$ can be Taylor-approximated by a network $N ^ { i } ( { \mathbf x } )$ with one hidden layer. This follows, for example, from the proof in Lin et al. (2017) that products can be Taylor-approximated by networks with one hidden layer, since each monomial is the product of several inputs (with multiplicity); we prove a far stronger result about $N ^ { i } ( { \mathbf x } )$ later in this paper (see Theorem 4.1).
+
+Suppose now that $N ^ { i } ( { \mathbf x } )$ has $m _ { i }$ hidden neurons. By Proposition 3.3, we conclude that since $p _ { i } ( \mathbf { x } )$ is homogeneous, it may be $\delta$ -approximated by a network $N _ { \delta } ^ { i } ( { \bf x } )$ with $m _ { i }$ hidden neurons, where $\delta = \epsilon / s$ . By combining the networks $N _ { \delta } ^ { i } ( { \bf x } )$ for each $i$ , we can define a network $\begin{array} { r } { N _ { \epsilon } ( { \bf x } ) = \sum _ { i } N _ { \delta } ^ { i } ( { \bf x } ) } \end{array}$ with $\textstyle \sum _ { i } m _ { i }$ neurons. Then, we have:
+
+$$
+\begin{array} { l } { { \displaystyle | N _ { \epsilon } ( { \bf x } ) - p ( { \bf x } ) | \le \sum _ { i } | N _ { \delta } ^ { i } ( { \bf x } ) - p _ { i } ( { \bf x } ) | } } \\ { { \displaystyle \le \sum _ { i } \delta = s \delta = \epsilon } . } \end{array}
+$$
+
+Hence, $N _ { \epsilon } ( \mathbf { x } )$ is an $\epsilon$ -approximation of $p ( \mathbf { x } )$ , implying that $\begin{array} { r } { m _ { 1 } ^ { \epsilon } ( p ) \leq \sum _ { i } m _ { i } } \end{array}$ for every $\epsilon$ . Thus, $\scriptstyle \operatorname* { l i m } _ { \epsilon \to 0 } m _ { 1 } ^ { \epsilon } ( p )$ exists, as desired.
+
+This theorem is perhaps surprising, since it is common for $\epsilon$ -approximations to functions to require ever-greater complexity, approaching infinity as $\epsilon  0$ . For example, the function $\exp ( | - x | )$ may be approximated on the domain $( - \pi , \pi )$ by Fourier sums of the form √ $\scriptstyle \sum _ { k = 0 } ^ { m } a _ { m } \cos ( { \bar { k } } x )$ . However, in order to achieve $\epsilon$ -approximation, we need to take $m \sim 1 / \sqrt { \epsilon }$ terms. By contrast, we have shown that a finite neural network architecture can achieve arbitrarily good approximations merely by altering its weights.
+
+Note also that the assumption of nonzero Taylor coefficients cannot be dropped from Theorem 3.4. For example, the theorem is false for rectified linear units (ReLUs), which are piecewise linear and do not admit a Taylor series. This is because $\epsilon$ -approximating a non-linear polynomial with a piecewise linear function requires an ever-increasing number of pieces as $\epsilon  0$ .
+
+Theorem 3.4 allows us to make the following definition:
+
+Definition 3.5. Suppose that a nonlinear function $\sigma$ is given. For $p$ a multivariate polynomial, let munk $m _ { k } ^ { u n i f o r m } ( p )$ be the minimum number of neurons in a depth- $k$ network that $\epsilon$ -approximates $p$ for all $\epsilon$ arbitrarily small. Set $m ^ { u n i f o r m } ( p ) = \mathrm { m i n } _ { k } m _ { k } ^ { u n i f o r m } ( p )$ . Likewise, let mTaylork (p) be the minimum number of neurons in a depth- $k$ network that Taylor-approximates $p _ { ; }$ , and set $m ^ { T a y l o r } ( p ) =$ $\mathrm { m i n } _ { k } m _ { k } ^ { T a y l o r } ( p )$
+
+In the next section, we will show that there is an exponential gap between $m _ { 1 } ^ { \mathrm { u n i f o r m } } ( p )$ and $m ^ { \mathrm { u n i f o r m } } ( p )$ and between $m _ { 1 } ^ { \mathrm { T a y l o r } } ( p )$ and $m ^ { \mathrm { T a y l o r } } ( p )$ for various classes of polynomials $p$ .
+
+# 4 THE INEFFICIENCY OF SHALLOW NETWORKS
+
+In this section, we compare the efficiency of shallow networks (those with a single hidden layer) and deep networks at approximating multivariate polynomials. Proofs of our main results are included in the Appendix.
+
+# 4.1 MULTIVARIATE POLYNOMIALS
+
+Our first result shows that uniform approximation of monomials requires exponentially more neurons in a shallow than a deep network.
+
+Theorem 4.1. Let $p ( \mathbf { x } )$ denote the monomial $x _ { 1 } ^ { r _ { 1 } } x _ { 2 } ^ { r _ { 2 } } \cdot \cdot \cdot x _ { n } ^ { r _ { n } }$ , with $\begin{array} { r } { d = \sum _ { i = 1 } ^ { n } r _ { i } } \end{array}$ . Suppose that the nonlinearity $\sigma$ has nonzero Taylor coefficients up to degree $2 d$ . Then, we have:
+
+$$
+\begin{array} { r l } & { ( i ) ~ m _ { 1 } ^ { u n i f o r m } ( p ) = \prod _ { i = 1 } ^ { n } ( r _ { i } + 1 ) , } \\ & { ( i i ) ~ m ^ { u n i f o r m } ( p ) \leq \sum _ { i = 1 } ^ { n } ( 7 \lceil \log _ { 2 } ( r _ { i } ) \rceil + 4 ) , } \end{array}
+$$
+
+where $\lceil x \rceil$ denotes the smallest integer that is at least $x$ .
+
+We can prove a comparable result for $m ^ { \mathrm { T a y l o r } }$ under slightly weaker assumptions on $\sigma$ . Note that by setting $r _ { 1 } = r _ { 2 } = . . . = r _ { n } = 1$ , we recover the result of Lin et al. (2017) that the product of $n$ numbers requires $2 ^ { n }$ neurons in a shallow network but can be Taylor-approximated with linearly many neurons in a deep network.
+
+Theorem 4.2. Let $p ( \mathbf { x } )$ denote the monomial $x _ { 1 } ^ { r _ { 1 } } x _ { 2 } ^ { r _ { 2 } } \cdot \cdot \cdot x _ { n } ^ { r _ { n } }$ , with $\begin{array} { r } { d = \sum _ { i = 1 } ^ { n } r _ { i } } \end{array}$ . Suppose that $\sigma$ has nonzero Taylor coefficients up to degree . Then, we have:
+
+$$
+\begin{array} { r l } & { ( i ) ~ m _ { 1 } ^ { T a y l o r } ( p ) = \prod _ { i = 1 } ^ { n } ( r _ { i } + 1 ) , } \\ & { ( i i ) ~ m ^ { T a y l o r } ( p ) \leq \sum _ { i = 1 } ^ { n } ( 7 \lceil \log _ { 2 } ( r _ { i } ) \rceil + 4 ) . } \end{array}
+$$
+
+It is worth noting that neither of Theorems 4.1 and 4.2 implies the other. This is because it is possible for a polynomial to admit a compact uniform approximation without admitting a compact Taylor approximation.
+
+It is natural now to consider the cost of approximating general polynomials. However, without further constraint, this is relatively uninstructive because polynomials of degree $d$ in $n$ variables live within a space of dimension $( \overset { - } { \underset { d } { \cdot } } ^ { + d } )$ , and therefore most require exponentially many neurons for any depth of network. We therefore consider polynomials of sparsity $c$ : that is, those that can be represented as the sum of $c$ monomials. This includes many natural functions.
+
+The following theorem, when combined with Theorems 4.1 and 4.2, shows that general polynomials $p$ with subexponential sparsity have exponentially large $m _ { 1 } ^ { \mathrm { u n i f o r m } } ( p )$ and $m _ { 1 } ^ { \mathrm { T a y l o r } } ( p )$ , but subexponential $m ^ { \mathrm { u n i f o r m } } ( p )$ and $m ^ { \mathrm { T a y l o r } } ( p )$ .
+
+Theorem 4.3. Let $p ( \mathbf { x } )$ be a multivariate polynomial of degree d and sparsity c, having monomials $q _ { 1 } ( \mathbf { x } ) , q _ { 2 } ( \mathbf { x } ) , \ldots , q _ { c } ( \mathbf { x } )$ . Suppose that the nonlinearity $\sigma$ has nonzero Taylor coefficients up to degree $2 d$ . Then, we have:
+
+$$
+\begin{array} { r l } & { ) \ m _ { 1 } ^ { u n i f o r m } ( p ) \geq \frac { 1 } { c } \operatorname* { m a x } _ { j } \ m _ { 1 } ^ { u n i f o r m } ( q _ { j } ) . } \\ & { ) \ m ^ { u n i f o r m } ( p ) \leq \sum _ { j } \ m ^ { u n i f o r m } ( q _ { j } ) . } \end{array}
+$$
+
+These statements also hold if $m ^ { u n i f o r m }$ is replaced with $m ^ { T a y l o r }$
+
+As mentioned above with respect to ReLUs, some assumptions on the Taylor coefficients of the activation function are necessary for the results we present. However, it is possible to loosen the assumptions of Theorem 4.1 and 4.2 while still obtaining exponential lower bounds on $m _ { 1 } ^ { \mathrm { u n i f o r m } } ( p )$ and Taylor1 (p):
+
+Theorem 4.4. Let $p ( \mathbf { x } )$ denote the monomial $x _ { 1 } ^ { r _ { 1 } } x _ { 2 } ^ { r _ { 2 } } \cdot \cdot \cdot x _ { n } ^ { r _ { n } }$ , with $\begin{array} { r } { d = \sum _ { i = 1 } ^ { n } r _ { i } } \end{array}$ . Suppose that the nonlinearity $\sigma$ has nonzero dth Taylor coefficient (other Taylor coefficients are allowed to be zero). Then, $m _ { 1 } ^ { u n i f o r m } ( p )$ and $m _ { 1 } ^ { T a y l o r } ( p )$ are at least $\begin{array} { r } { \frac { 1 } { d } \prod _ { i = 1 } ^ { n } ( r _ { i } + 1 ) } \end{array}$ . (An even better lower bound is the maximum coefficient in the polynomial $\textstyle \prod _ { i } ( 1 + y + \dotsc + y ^ { r _ { i } } )$ .)
+
+# 4.2 UNIVARIATE POLYNOMIALS
+
+As with multivariate polynomials, depth can offer an exponential savings when approximating univariate polynomials. We show below (Proposition 4.5) that a shallow network can approximate any degree- $d$ univariate polynomial with a number of neurons at most linear in $d$ . The monomial $x ^ { \dot { d } }$ requires $d + 1$ neurons in a shallow network (Proposition 4.6), but can be approximated with only logarithmically many neurons in a deep network. Thus, depth allows us to reduce networks from linear to logarithmic size, while for multivariate polynomials the gap was between exponential and linear. The difference here arises because the dimensionality of the space of univariate degree- $d$ polynomials is linear in $d$ , which the dimensionality of the space of multivariate degree- $d$ polynomials is exponential in $d$ .
+
+Proposition 4.5. Suppose that the nonlinearity Then, $m _ { 1 } ^ { T a y l o r } ( p ) \leq \bar { d } + 1$ for every univariate polynomial $\sigma$ has nonzero Taylor coefficients up to degree $p$ of degree $d .$ . $d$ .
+
+Proof. Pick $a _ { 0 } , a _ { 1 } , \ldots , a _ { d }$ to be arbitrary, distinct real numbers. Consider the Vandermonde matrix A with entries $A _ { i j } = a _ { i } ^ { j }$ . It is well-known that $\begin{array} { r } { \operatorname* { d e t } ( \mathbf { A } ) = \prod _ { i < i ^ { \prime } } ( a _ { i ^ { \prime } } - a _ { i } ) \neq 0 } \end{array}$ . Hence, A is invertible, which means that multiplying its columns by nonzero values gives another invertible matrix. Suppose that we multiply the $j$ th column of $\mathbf { A }$ by $\sigma _ { j }$ to get $\mathbf { A } ^ { \prime }$ , where $\begin{array} { r } { \sigma ( x ) = \sum _ { j } \sigma _ { j } x ^ { j } } \end{array}$ is the Taylor expansion of $\sigma ( x )$ .
+
+Now, observe that the $i$ th row of $\mathbf { A } ^ { \prime }$ is exactly the coefficients of $\sigma ( a _ { i } x )$ , up to the degree- $d$ term. Since $\mathbf { A } ^ { \prime }$ is invertible, the rows must be linearly independent, so the polynomials $\sigma ( a _ { i } x )$ , restricted to terms of degree at most $d$ , must themselves be linearly independent. Since the space of degree- $d$ univariate polynomials is $( d + 1 )$ -dimensional, these $d + 1$ linearly independent polynomials must span the space. Hence, $m _ { 1 } ^ { \mathrm { T a y l o r } } ( p ) \leq d + 1$ for any univariate degree- $d$ polynomial $p$ . In fact, we can fix the weights from the input neuron to the hidden layer (to be $a _ { 0 } , a _ { 1 } , \ldots , a _ { d }$ , respectively) and still represent any polynomial $p$ with $d + 1$ hidden neurons. □
+
+Proposition 4.6. Let $p ( x ) = x ^ { d }$ , and suppose that the nonlinearity $\sigma ( x )$ has nonzero Taylor coefficients up to degree $2 d$ . Then, we have:
+
+(i) $m _ { 1 } ^ { u n i f o r m } ( p ) = d + 1 .$ (ii) $m ^ { u n i f o r m } ( p ) \leq 7 \lceil \log _ { 2 } ( d ) \rceil .$
+
+These statements also hold if $m ^ { u n i f o r m }$ is replaced with $m ^ { T a y l o r }$ .
+
+Proof. Part (i) follows from part (i) of Theorems 4.1 and 4.2 by setting $n = 1$ and $r _ { 1 } = d$ .
+
+For part (ii), observe that we can Taylor-approximate the square $x ^ { 2 }$ of an input $x$ with three neurons in a single layer:
+
+$$
+{ \frac { 1 } { 2 \sigma ^ { \prime \prime } ( 0 ) } } \left( \sigma ( x ) + \sigma ( - x ) - 2 \sigma ( 0 ) \right) = x ^ { 2 } + { \mathcal { O } } ( x ^ { 4 } + x ^ { 5 } + . . . ) .
+$$
+
+We refer to this construction as a square gate, and the construction of Lin et al. (2017) as a product gate. We also use identity gate to refer to a neuron that simply preserves the input of a neuron from the preceding layer (this is equivalent to the skip connections in residual nets (He et al., 2016)).
+
+Consider a network in which each layer contains a square gate (3 neurons) and either a product gate or an identity gate (4 or 1 neurons, respectively), according to the following construction: The square gate squares the output of the preceding square gate, yielding inductively a result of the form $x ^ { \hat { 2 } ^ { k } }$ , where $k$ is the depth of the layer. Writing $d$ in binary, we use a product gate if there is a 1 in the $2 ^ { k - 1 }$ -place; if so, the product gate multiplies the output of the preceding product gate by the output of the preceding square gate. If there is a 0 in the $2 ^ { { \dot { k } } - 1 }$ -place, we use an identity gate instead of a product gate. Thus, each layer computes $x ^ { 2 ^ { k } }$ and multiplies $x ^ { 2 ^ { k - 1 } }$ to the computation if the $2 ^ { k - 1 }$ -place in $d$ is 1. The process stops when the product gate outputs $x ^ { d }$ .
+
+This network clearly uses at most $7 \lceil \log _ { 2 } ( d ) \rceil$ neurons, with a worst case scenario where $d + 1$ is a power of 2. Hence $m ^ { \mathrm { T a y l o r } } ( p ) \leq 7 \lceil \log _ { 2 } ( \bar { d } ) \rceil$ , with $m ^ { \mathrm { u n i f o r m } } ( p ) \leq m ^ { \mathrm { T a y l o r } } ( p )$ by Proposition 3.3 since $p$ is homogeneous. □
+
+# 5 HOW EFFICIENCY IMPROVES WITH DEPTH
+
+We now consider how $m _ { k } ^ { \mathrm { u n i f o r m } } ( p )$ scales with $k$ , interpolating between exponential in $n$ (for $k = 1$ and linear in $n$ (for $k = \log n$ ). In practice, networks with modest $k > 1$ are effective at representing natural functions. We explain this theoretically by showing that the cost of approximating the product polynomial drops off rapidly as $k$ increases.
+
+By repeated application of the shallow network construction in Lin et al. (2017), we obtain the following upper bound on $m _ { k } ^ { \mathrm { u n i f o r m } } ( p )$ , which we conjecture to be essentially tight. Our approach leverages the compositionality of polynomials, as discussed e.g. in Mhaskar et al. (2016) and Poggio et al. (2017), using a tree-like neural network architecture.
+
+Theorem 5.1. Let $p ( \mathbf { x } )$ equal the product $x _ { 1 } x _ { 2 } \cdots x _ { n }$ , and suppose $\sigma$ has nonzero Taylor coefficients up to degree $n$ . Then, we have:
+
+$$
+m _ { k } ^ { u n i f o r m } ( p ) = \mathcal { O } \left( n ^ { ( k - 1 ) / k } \cdot 2 ^ { n ^ { 1 / k } } \right) .
+$$
+
+Proof. We construct a network in which groups of the $n$ inputs are recursively multiplied up to Taylor approximation. The $n$ inputs are first divided into groups of size $b _ { 1 }$ , and each group is multiplied in the first hidden layer using $2 ^ { b _ { 1 } }$ neurons (as described in Lin et al. (2017)). Thus, the first hidden layer includes a total of $2 ^ { b _ { 1 } } \bar { n } / b _ { 1 }$ neurons. This gives us $n / b _ { 1 }$ values to multiply, which are in turn divided into groups of size $b _ { 2 }$ . Each group is multiplied in the second hidden layer using $2 ^ { b _ { 2 } }$ neurons. Thus, the second hidden layer includes a total of $2 ^ { b _ { 2 } } n / ( b _ { 1 } b _ { 2 } )$ neurons.
+
+We continue in this fashion for $b _ { 1 } , b _ { 2 } , \dots , b _ { k }$ such that $b _ { 1 } b _ { 2 } \cdot \cdot \cdot b _ { k } = n$ , giving us one neuron which is the product of all of our inputs. By considering the total number of neurons used, we conclude
+
+$$
+m _ { k } ^ { \mathrm { { T a y l o r } } } ( p ) \leq \sum _ { i = 1 } ^ { k } { \frac { n } { \prod _ { j = 1 } ^ { i } b _ { j } } } 2 ^ { b _ { i } } = \sum _ { i = 1 } ^ { k } \left( \prod _ { j = i + 1 } ^ { k } b _ { j } \right) 2 ^ { b _ { i } } .
+$$
+
+By Proposition 3.3, $m _ { k } ^ { \mathrm { u n i f o r m } } ( p ) \leq m _ { k } ^ { \mathrm { T a y l o r } } ( p )$ since $p$ is homogeneous. Setting $b _ { i } = n ^ { 1 / k }$ , for each $i$ gives us the desired bound (1). □
+
+In fact, we can solve for the choice of $b _ { i }$ such that the upper bound in (2) is minimized, under the condition $b _ { 1 } b _ { 2 } \cdot \cdot \cdot b _ { k } = n$ . Using the technique of Lagrange multipliers, we know that the optimum occurs at a minimum of the function
+
+$$
+{ \mathcal { L } } ( b _ { i } , \lambda ) : = \left( n - \prod _ { i = 1 } ^ { k } b _ { i } \right) \lambda + \sum _ { i = 1 } ^ { k } \left( \prod _ { j = i + 1 } ^ { k } b _ { j } \right) 2 ^ { { b } _ { i } } .
+$$
+
+![](images/07bbb97fe45f60e6a917558c529acae091375e1abe61cbdfaefad6a9f333d3c1.jpg)  
+Figure 1: The optimal settings for $\{ b _ { i } \} _ { i = 1 } ^ { k }$ as $n$ varies are shown for $k = 1 , 2 , 3$ . Observe that the $b _ { i }$ converge to $n ^ { 1 / k }$ for large $n$ , as witnessed by a linear fit in the log-log plot. The exact values are given by equations (4) and (5).
+
+![](images/e886f7dd11b00bee14f6a4dc9ff557f97e1a545ca275363c0905b9a7d9e154d2.jpg)  
+Figure 2: Performance of trained networks in approximating the product of 20 input variables, ranging from red (high error) to blue (low error). The error shown here is the expected absolute difference between the predicted and actual product. The curve w = n(k−1)/k · 2n1/k for $n = 2 0$ is shown in black. In the region above and to the right of the curve, it is possible to effectively approximate the product function (Theorem 5.1).
+
+Differentiating $\mathcal { L }$ with respect to $b _ { i }$ , we obtain the conditions
+
+$$
+\begin{array} { l } { { \displaystyle 0 = - \lambda \prod _ { j \neq i } b _ { j } + \sum _ { h = 1 } ^ { i - 1 } \left( \frac { \prod _ { j = h + 1 } ^ { k } b _ { j } } { b _ { i } } \right) 2 ^ { b _ { h } } + ( \log 2 ) \left( \prod _ { j = i + 1 } ^ { k } b _ { j } \right) 2 ^ { b _ { i } } , \mathrm { f o r } 1 \leq i \leq k } } \\ { { \displaystyle 0 = n - \prod _ { j = 1 } ^ { k } b _ { j } } . } \end{array}
+$$
+
+Dividing (3) by $\textstyle \prod _ { j = i + 1 } ^ { k } b _ { j }$ and rearranging gives us the recursion
+
+$$
+b _ { i } = b _ { i - 1 } + \log _ { 2 } ( b _ { i - 1 } - 1 / \log 2 ) .
+$$
+
+Thus, the optimal $b _ { i }$ are not exactly equal but very slowly increasing with $i$ (see Figure 1).
+
+The following conjecture states that the bound given in Theorem 5.1 is (approximately) optimal.
+
+Conjecture 5.2. Let $p ( \mathbf { x } )$ equal to the product $x _ { 1 } x _ { 2 } \cdots x _ { n }$ , and suppose that $\sigma$ has all nonzero Taylor coefficients. Then, we have:
+
+$$
+m _ { k } ^ { u n i f o r m } ( p ) = 2 ^ { \Theta ( n ^ { 1 / k } ) } ,
+$$
+
+i.e., the exponent grows as $n ^ { 1 / k }$ for $n \to \infty$
+
+We empirically tested Conjecture 5.2 by training ANNs to predict the product of input values $x _ { 1 } , \ldots , x _ { n }$ with $n = 2 0$ (see Figure 2). The rapid interpolation from exponential to linear width aligns with our predictions.
+
+In our experiments, we used feedforward networks with dense connections between successive layers. In the figure, we show results for $\sigma ( x ) = \operatorname { t a n h } ( x )$ (note that this behavior is even better than expected, since this function actually has numerous zero Taylor coefficients). Similar results were also obtained for rectified linear units (ReLUs) as the nonlinearity, despite the fact that this function does not even admit a Taylor series. The number of layers was varied, as was the number of neurons within a single layer. The networks were trained using the AdaDelta optimizer (Zeiler, 2012) to minimize the absolute value of the difference between the predicted and actual values. Input variables $x _ { i }$ were drawn uniformly at random from the interval $[ 0 , 2 ]$ , so that the expected value of the output would be of manageable size.
+
+Eq. (6) provides a helpful rule of thumb for how deep is deep enough. Suppose, for instance, that we wish to keep typical layers no wider than about a thousand $( \sim 2 ^ { 1 0 } )$ neurons. Eq. (6) then implies $n ^ { 1 / k } \lesssim 1 0$ , i.e., that the number of layers should be at least
+
+$$
+k \gtrsim \log _ { 1 0 } n .
+$$
+
+It would be very interesting if one could show that general polynomials $p$ in $n$ variables require a superpolynomial number of neurons to approximate for any constant number of hidden layers. The analogous statement for Boolean circuits - whether the complexity classes $T C ^ { 0 }$ and $T C ^ { \bar { 1 } }$ are equal - remains unresolved and is assumed to be quite hard. Note that the formulations for Boolean circuits and deep neural networks are independent statements (neither would imply the other) due to the differences between computation on binary and real values. Indeed, gaps in expressivity have already been proven to exist for real-valued neural networks of different depths, for which the analogous results remain unknown in Boolean circuits (see e.g. Mhaskar (1993); Chui et al. (1994; 1996); Montufar et al. (2014); Cohen et al. (2016); Telgarsky (2016)).
+
+# 6 CONCLUSION
+
+We have shown how the power of deeper ANNs can be quantified even for simple polynomials. We have proved that arbitrarily good approximations of polynomials are possible even with a fixed number of neurons and that there is an exponential gap between the width of shallow and deep networks required for approximating a given sparse polynomial. For $n$ variables, a shallow network requires size exponential in $n$ , while a deep network requires at most linearly many neurons. Networks with a constant number $k > 1$ of hidden layers appear to interpolate between these extremes, following a curve exponential in $n ^ { 1 / k }$ . This suggests a rough heuristic for the number of layers required for approximating simple functions with neural networks. For example, if we want no layers to have more than $2 ^ { 1 0 }$ neurons, say, then the minimum number of layers required grows only as $\log _ { 1 0 } n$ . To further improve efficiency using the ${ \mathcal { O } } ( n )$ constructions we have presented, it suffices to increase the number of layers by a factor of $\log _ { 2 } { 1 0 } \approx 3$ , to $\log _ { 2 } n$ .
+
+The key property we use in our constructions is compositionality, as detailed in Poggio et al. (2017). It is worth noting that as a consequence our networks enjoy the property of locality mentioned in Cohen et al. (2016), which is also a feature of convolutional neural nets. That is, each neuron in a layer is assumed to be connected only to a small subset of neurons from the previous layer, rather than the entirety (or some large fraction). In fact, we showed (e.g. Prop. 4.6) that there exist natural functions computable with linearly many neurons, with each neuron is connected to at most two neurons in the preceding layer, which nonetheless cannot be computed with fewer than exponentially many neurons in a single layer, no matter how may connections are used. Our construction can also be framed with reference to the other properties mentioned in Cohen et al. (2016): those of sharing (in which weights are shared between neural connections) and pooling (in which layers are gradually collapsed, as our construction essentially does with recursive combination of inputs).
+
+This paper has focused exclusively on the resources (neurons and synapses) required to compute a given function for fixed network depth. (Note also results of Lu et al. (2017); Hanin & Sellke (2017); Hanin (2017) for networks of fixed width.) An important complementary challenge is to quantify the resources (e.g. training steps) required to learn the computation, i.e., to converge to appropriate weights using training data — possibly a fixed amount thereof, as suggested in Zhang et al. (2017). There are simple functions that can be computed with polynomial resources but require exponential resources to learn (Shalev-Shwartz et al., 2017). It is quite possible that architectures we have not considered increase the feasibility of learning. For example, residual networks (ResNets) (He et al., 2016) and unitary nets (see e.g. Arjovsky et al. (2016); Jing et al. (2017)) are no more powerful in representational ability than conventional networks of the same size, but by being less susceptible to the “vanishing/exploding gradient” problem, it is far easier to optimize them in practice. We look forward to future work that will help us understand the power of neural networks to learn.
+
+# 7 ACKNOWLEDGMENTS
+
+This work was supported by the Foundational Questions Institute http://fqxi.org/, the Rothberg Family Fund for Cognitive Science and NSF grant 1122374. We would like to thank Tomaso Poggio, Scott Aaronson, Surya Ganguli, David Budden, Henry Lin, and the anonymous referees for helpful suggestions and discussions, and the Center for Brains, Minds, & Machines for an excellent working environment.
+
+# REFERENCES
+
+Martin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary evolution recurrent neural networks. In International Conference on Machine Learning (ICML), pp. 1120–1128, 2016.
+
+Andrew R Barron. Approximation and estimation bounds for artificial neural networks. Machine Learning, 14(1):115–133, 1994.
+
+Monica Bianchini and Franco Scarselli. On the complexity of neural network classifiers: A comparison between shallow and deep architectures. IEEE transactions on neural networks and learning systems, 25(8):1553–1565, 2014.
+
+Charles K Chui, Xin Li, and Hrushikesh Narhar Mhaskar. Limitations of the approximation capabilities of neural networks with one hidden layer. Advances in Computational Mathematics, 5(1): 233–243, 1996.
+
+CK Chui, Xin Li, and HN Mhaskar. Neural networks for localized approximation. Mathematics of Computation, 63(208):607–623, 1994.
+
+Nadav Cohen and Amnon Shashua. Convolutional rectifier networks as generalized tensor decompositions. In International Conference on Machine Learning (ICML), 2016.
+
+Nadav Cohen, Or Sharir, and Amnon Shashua. On the expressive power of deep learning: A tensor analysis. Journal of Machine Learning Research (JMLR), 49, 2016.
+
+George Cybenko. Approximation by superpositions of a sigmoidal function. Mathematics of Control, Signals, and Systems (MCSS), 2(4):303–314, 1989.
+
+Amit Daniely. Depth separation for neural networks. In Conference On Learning Theory (COLT), 2017.
+
+Olivier Delalleau and Yoshua Bengio. Shallow vs. deep sum-product networks. In Advances in Neural Information Processing Systems (NIPS), pp. 666–674, 2011.
+
+Ronen Eldan and Ohad Shamir. The power of depth for feedforward neural networks. In Annual Conference on Learning Theory (COLT), pp. 907–940, 2016.
+
+Ken-Ichi Funahashi. On the approximate realization of continuous mappings by neural networks. Neural networks, 2(3):183–192, 1989.
+
+Boris Hanin. Universal function approximation by deep neural nets with bounded width and ReLU activations. arXiv preprint arXiv:1708.02691, 2017.
+
+Boris Hanin and Mark Sellke. Approximating continuous functions by ReLU nets of minimal width. arXiv preprint arXiv:1710.11278, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Conference on Computer Vision and Pattern Recognition (CVPR), pp. 770–778, 2016.
+
+Kurt Hornik, Maxwell Stinchcombe, and Halbert White. Multilayer feedforward networks are universal approximators. Neural networks, 2(5):359–366, 1989.
+
+Li Jing, Yichen Shen, Tena Dubcek, John Peurifoy, Scott Skirlo, Yann LeCun, Max Tegmark, and Marin Soljaciˇ c. Tunable efficient unitary neural networks (EUNN) and their application to RNNs. ´ In International Conference on Machine Learning (ICML), pp. 1733–1741, 2017.
+
+Henry W Lin, Max Tegmark, and David Rolnick. Why does deep and cheap learning work so well? Journal of Statistical Physics, 168(6):1223–1247, 2017.
+
+Zhou Lu, Hongming Pu, Feicheng Wang, Zhiqiang Hu, and Liwei Wang. The expressive power of neural networks: A view from the width. In Advances in Neural Information Processing Systems (NIPS), pp. 6232–6240, 2017.
+
+James Martens, Arkadev Chattopadhya, Toni Pitassi, and Richard Zemel. On the representational efficiency of restricted Boltzmann machines. In Advances in Neural Information Processing Systems (NIPS), pp. 2877–2885, 2013.
+
+Hrushikesh Mhaskar, Qianli Liao, and Tomaso Poggio. Learning functions: When is deep better than shallow. arXiv:1603.00988v4, 2016.
+
+Hrushikesh Narhar Mhaskar. Approximation properties of a multilayered feedforward artificial neural network. Advances in Computational Mathematics, 1(1):61–80, 1993.
+
+Guido F Montufar, Razvan Pascanu, Kyunghyun Cho, and Yoshua Bengio. On the number of linear regions of deep neural networks. In Advances in Neural Information Processing Systems (NIPS), pp. 2924–2932, 2014.
+
+Allan Pinkus. Approximation theory of the mlp model in neural networks. Acta Numerica, 8: 143–195, 1999.
+
+Tomaso Poggio, Hrushikesh Mhaskar, Lorenzo Rosasco, Brando Miranda, and Qianli Liao. Why and when can deep-but not shallow-networks avoid the curse of dimensionality: A review. International Journal of Automation and Computing, 15(5):503–519, 2017.
+
+Ben Poole, Subhaneil Lahiri, Maithra Raghu, Jascha Sohl-Dickstein, and Surya Ganguli. Exponential expressivity in deep neural networks through transient chaos. In Advances In Neural Information Processing Systems (NIPS), pp. 3360–3368, 2016.
+
+Maithra Raghu, Ben Poole, Jon Kleinberg, Surya Ganguli, and Jascha Sohl-Dickstein. Survey of expressivity in deep neural networks. arXiv:1611.08083, 2016.
+
+Shai Shalev-Shwartz, Ohad Shamir, and Shaked Shammah. Failures of gradient-based deep learning. In International Conference on Machine Learning (ICML), pp. 3067–3075, 2017.
+
+Matus Telgarsky. Benefits of depth in neural networks. Journal of Machine Learning Research (JMLR), 49, 2016.
+
+Matthew D Zeiler. ADADELTA: an adaptive learning rate method. arXiv:1212.5701, 2012.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In International Conference on Learning Representations (ICLR), 2017.
+
+# APPENDIX
+
+# 7.1 PROOF OF THEOREM 4.1.
+
+Without loss of generality, suppose that $r _ { i } > 0$ for $i = 1 , \ldots , n$ . Let $X$ be the multiset in which $x _ { i }$ occurs with multiplicity $r _ { i }$ .
+
+We first show that $\textstyle \prod _ { i = 1 } ^ { n } ( r _ { i } + 1 )$ neurons are sufficient to approximate $p ( \mathbf { x } )$ . Appendix A in Lin et al. (2017) demonstrates that for variables $y _ { 1 } , \ldots , y _ { N }$ , the product $y _ { 1 } \cdots y _ { N }$ can be Taylorapproximated as a linear combination of the $2 ^ { N }$ functions $\sigma ( \pm y _ { 1 } \pm \cdot \cdot \cdot \pm y _ { d } )$ .
+
+Consider setting $y _ { 1 } , \ldots , y _ { d }$ equal to the elements of multiset $X$ . Then, we conclude that we can approximate $p ( \mathbf { x } )$ as a linear combination of the functions $\sigma ( \pm y _ { 1 } \pm \cdot \cdot \pm y _ { d } )$ . However, these functions are not all distinct: there are $r _ { i } + 1$ distinct ways to assign $\pm$ signs to $r _ { i }$ copies of $x _ { i }$ (ignoring permutations of the signs). Therefore, there are $\textstyle \prod _ { i = 1 } ^ { n } ( r _ { i } + { \bar { 1 } } )$ distinct functions $\sigma ( \pm y _ { 1 } \pm$ $\cdots \pm y _ { N } )$ , proving that $\begin{array} { r } { m ^ { \mathrm { { I a y l o r } } } ( p ) \leq \prod _ { i = 1 } ^ { n } ( r _ { i } + 1 ) } \end{array}$ . Proposition 3.3 implies that for homogeneous polynomials $p$ , we have $m _ { 1 } ^ { \mathrm { u n i f o r m } } ( p ) \leq m _ { 1 } ^ { \mathrm { T a y l o r } } ( p )$ .
+
+We now show that this number of neurons is also necessary for approximating $p ( \mathbf { x } )$ . Suppose that $N _ { \epsilon } ( \mathbf { x } )$ is an $\epsilon$ -approximation to $p ( \mathbf { x } )$ with depth 1, and let the Taylor series of $N _ { \epsilon } ( \mathbf { x } )$ be $p ( \mathbf { x } ) + E ( \mathbf { x } )$ . Let $\dot { E } _ { k } ( { \bf x } )$ be the degree- $k$ homogeneous component of $E ( \mathbf { x } )$ , for $0 \leq k \leq 2 d$ . By the definition of $\epsilon$ -approximation, $\operatorname* { s u p } _ { \mathbf { x } } E ( \mathbf { x } )$ goes to 0 as $\epsilon$ does, so by picking $\epsilon$ small enough, we can ensure that the coefficients of each $E _ { k } ( { \bf x } )$ go to 0.
+
+Let ing $m = m _ { 1 } ^ { \mathrm { u n i f o r m } } ( p )$ and suppose that der, we conclude t $\sigma ( x )$ has the Taylor expere exist constants ion an $\scriptstyle \sum _ { k = 0 } ^ { \infty } \sigma _ { k } x ^ { k }$ . Then, by group-at $a _ { i j }$ $w _ { j }$
+
+$$
+\begin{array} { l } { { \displaystyle \sigma _ { d } \sum _ { j = 1 } ^ { m } w _ { j } \left( \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { d } = p ( { \bf x } ) + { \cal E } _ { d } ( { \bf x } ) } } \\ { { \displaystyle \sigma _ { k } \sum _ { j = 1 } ^ { m } w _ { j } \left( \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { k } = { \cal E } _ { k } ( { \bf x } ) \quad \mathrm { f o r ~ } k \ne d . } } \end{array}
+$$
+
+For each $S \subseteq X$ , let us take the derivative of this equation by every variable that occurs in $S$ , where we take multiple derivatives of variables that occur multiple times. This gives
+
+$$
+\begin{array} { l } { { \displaystyle \frac { \sigma _ { d } \cdot d ! } { | S | ! } \sum _ { j = 1 } ^ { m } w _ { j } \prod _ { h \in S } a _ { h j } \left( \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { d - | S | } = \frac { \partial } { \partial S } p ( { \bf x } ) + \frac { \partial } { \partial S } E _ { d } ( { \bf x } ) } , } \\ { { \displaystyle \frac { \sigma _ { k } \cdot k ! } { | S | ! } \sum _ { j = 1 } ^ { m } w _ { j } \prod _ { h \in S } a _ { h j } \left( \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { k - | S | } = \frac { \partial } { \partial S } E _ { k } ( { \bf x } ) } . } \end{array}
+$$
+
+Observe that there are $\begin{array} { r } { r \equiv \prod _ { i = 1 } ^ { n } ( r _ { i } + 1 ) } \end{array}$ choices for $S$ , since each variable $x _ { i }$ can be included anywhere from 0 to $r _ { i }$ times. Define A to be the $r \times m$ matrix with entries $\begin{array} { r } { A _ { S , j } = \prod _ { h \in S } a _ { h j } } \end{array}$ . We claim that A has full row rank. This would show that the number of columns $m$ is at least the number of rows $\begin{array} { r } { r = \prod _ { i = 1 } ^ { n } ( r _ { i } + 1 ) } \end{array}$ , proving the desired lower bound on $m$ .
+
+Suppose towards contradiction that the rows $A _ { S _ { \ell } }$ ,• admit a linear dependence:
+
+$$
+\sum _ { \ell = 1 } ^ { r } c _ { \ell } A _ { S _ { \ell } , \bullet } = \mathbf { 0 } ,
+$$
+
+where the coefficients $c _ { \ell }$ are all nonzero and the $S _ { \ell }$ denote distinct subsets of $X$ . Let $S _ { * }$ be such that $\left| c _ { * } \right|$ is maximized. Then, take the dot product of each side of the above equation by the vector with entries (indexed by $j$ ) equal to $\scriptstyle w _ { j } \left( \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { d - | S _ { * } | }$ :
+
+$$
+\begin{array} { l } { \displaystyle 0 = \sum _ { \ell = 1 } ^ { r } c _ { \ell } \sum _ { j = 1 } ^ { m } w _ { j } \prod _ { h \in S _ { \ell } } a _ { h j } \left( \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { d - | S _ { * } | } } \\ { = \sum _ { \ell | ( | S _ { \ell } | = | S _ { * } | ) } c _ { \ell } \sum _ { j = 1 } ^ { m } w _ { j } \prod _ { h \in S _ { \ell } } a _ { h j } \left( \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { d - | S _ { \ell } | } } \\ { + \displaystyle \sum _ { \ell | ( | S _ { \ell } | \neq | S _ { * } | ) } c _ { \ell } \sum _ { j = 1 } ^ { m } w _ { j } \prod _ { h \in S _ { \ell } } a _ { h j } \left( \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { ( d + | S _ { \ell } | - | S _ { * } | ) - | S _ { \ell } | } . } \end{array}
+$$
+
+We can use (7) to simplify the first term and (8) (with $k = d + | S _ { \ell } | - | S _ { * } | )$ to simplify the second term, giving us:
+
+$$
+\begin{array} { l } { { \displaystyle 0 = \sum _ { \ell | ( | S _ { \ell } | = | S _ { * } | ) } c _ { \ell } \cdot \frac { | S _ { \ell } | ! } { \sigma _ { d } \cdot d ! } \cdot \left( \frac { \partial } { \partial S _ { \ell } } p ( { \bf x } ) + \frac { \partial } { \partial S _ { \ell } } E _ { d } ( { \bf x } ) \right) } } \\ { { \displaystyle + \sum _ { \ell | ( | S _ { \ell } | \neq | S _ { * } | ) } c _ { \ell } \cdot \frac { | S _ { \ell } | ! } { \sigma _ { d + | S _ { \ell } | - | S _ { * } | } \cdot ( d + | S _ { \ell } | - | S _ { * } | ) ! } \cdot \frac { \partial } { \partial S _ { \ell } } E _ { d + | S _ { \ell } | - | S _ { * } | } ( { \bf x } ) } } \end{array}
+$$
+
+Consider the coefficient of the monomia l ∂∂S p(x), which appears in the first summand with coefficient $c _ { * } \cdot \frac { | S _ { * } | ! } { \sigma _ { d } \cdot d ! }$ . Since the $S _ { \ell }$ are distinct, this monomial does not appear in any other term $\begin{array} { r } { \frac { \partial } { \partial S _ { \ell } } p ( \mathbf { x } ) } \end{array}$ , but it could appear in some of the terms $\frac { \partial } { \partial S _ { \ell } } E _ { k } ( { \bf x } )$ .
+
+By definition, $\left| c _ { * } \right|$ is the largest of the values $\left| c _ { \ell } \right|$ , and by setting $\epsilon$ small enough, all coefficients of $\frac { \partial } { \partial S _ { \ell } } E _ { k } ( { \bf x } )$ can be made negligibly small for every $k$ . This implies that the coefficient of the monomial $\begin{array} { r } { \frac { \partial } { \partial S _ { * } } p ( \mathbf { x } ) } \end{array}$ can be made arbitrarily close to $c _ { * } \cdot \frac { | S _ { * } | ! } { \sigma _ { d } \cdot d ! }$ , which is nonzero since $c _ { * }$ is nonzero.
+
+However, the left-hand side of equation (9) tells us that this coefficient should be zero - a contradiction. We conclude that A has full row rank, and therefore that $\begin{array} { r } { m _ { 1 } ^ { \mathrm { u n i f o r m } } ( p ) = m \geq \prod _ { i = 1 } ^ { n } ( r _ { i } + 1 ) } \end{array}$ . This completes the proof of part (i).
+
+We now consider part (ii) of the theorem. It follows from Proposition 4.6, part (ii) that, for each $i$ , we can Taylor-approximate $\boldsymbol { x } _ { i } ^ { r _ { i } }$ using $7 \lceil \log _ { 2 } ( r _ { i } ) \rceil$ neurons arranged in a deep network. Therefore, we can Taylor-approximate all of the $\boldsymbol { x } _ { i } ^ { r _ { i } }$ using a total of $\textstyle \sum _ { i } 7 \lceil { \bar { \log _ { 2 } } } ( r _ { i } ) \rceil$ neurons. From Lin et al. (2017), we know that these $n$ terms can be multiplied using $4 n$ additional neurons, giving us a total of $\begin{array} { r } { \sum _ { i } ( 7 \lceil \log _ { 2 } ( r _ { i } ) \rceil + 4 ) } \end{array}$ . Proposition 3.3 implies again that $m _ { 1 } ^ { \mathrm { u n i f o r m } } ( p ) \leq m _ { 1 } ^ { \mathrm { T a y l o r } } ( p )$ . This completes the proof.
+
+# 7.2 PROOF OF THEOREM 4.2.
+
+As above, suppose that $r _ { i } > 0$ for $i = 1 , \ldots , n$ , and let $X$ be the multiset in which $x _ { i }$ occurs with multiplicity $r _ { i }$ .
+
+It is shown in the proof of Theorem 4.1 that $\textstyle \prod _ { i = 1 } ^ { n } ( r _ { i } + 1 )$ neurons are sufficient to Taylorapproximate $p ( x )$ . We now show that this number of neurons is also necessary for approximating $p ( \mathbf { x } )$ . Let $m = m _ { 1 } ^ { \mathrm { T a y l o r } } ( p )$ and suppose that $\sigma ( x )$ has the Taylor expansion $\scriptstyle \sum _ { k = 0 } ^ { \infty } \sigma _ { k } x ^ { k }$ . Then, by grouping terms of each order, we conclude that there exist constants $a _ { i j }$ and $w _ { j }$ such that
+
+$$
+\begin{array} { l } { { \displaystyle \sigma _ { d } \sum _ { j = 1 } ^ { m } w _ { j } \left( \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { d } = p ( { \bf x } ) } } \\ { { \displaystyle \sigma _ { k } \sum _ { j = 1 } ^ { m } w _ { j } \left( \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { k } = 0 \quad \mathrm { f o r } 0 \le k \le N - 1 . } } \end{array}
+$$
+
+For each $S \subseteq X$ , let us take the derivative of equations (10) and (11) by every variable that occurs in $S$ , where we take multiple derivatives of variables that occur multiple times. This gives
+
+$$
+\begin{array} { l } { \displaystyle \frac { \sigma _ { d } \cdot d ! } { | S | ! } \sum _ { j = 1 } ^ { m } w _ { j } \prod _ { h \in S } a _ { h j } \left( \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { d - | S | } = \frac { \partial } { \partial S } p ( { \bf x } ) , } \\ { \displaystyle \frac { \sigma _ { k } \cdot k ! } { | S | ! } \sum _ { j = 1 } ^ { m } w _ { j } \prod _ { h \in S } a _ { h j } \left( \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { k - | S | } = 0 } \end{array}
+$$
+
+for $| S | \le k \le d - 1$ . Observe that there are $\begin{array} { r } { r = \prod _ { i = 1 } ^ { n } ( r _ { i } + 1 ) } \end{array}$ choices for $S$ , since each variable $x _ { i }$ can be included anywhere from 0 to $r _ { i }$ times. Define A to be the $r \times m$ matrix with entries $\begin{array} { r } { A _ { S , j } \ = \ \prod _ { h \in S } a _ { h j } } \end{array}$ . We claim that A has full row rank. This would show that the number of columns $m$ is at least the number of rows $\begin{array} { r } { r = \prod _ { i = 1 } ^ { n } ( r _ { i } + 1 ) } \end{array}$ , proving the desired lower bound on $m$ .
+
+Suppose towards contradiction that the rows $A _ { S _ { \ell } }$ ,• admit a linear dependence:
+
+$$
+\sum _ { \ell = 1 } ^ { r } c _ { \ell } A _ { S _ { \ell } , \bullet } = \mathbf { 0 } ,
+$$
+
+where the coefficients $c _ { \ell }$ are nonzero and the $S _ { \ell }$ denote distinct subsets of $X$ . Set $s = \operatorname* { m a x } _ { \ell } | S _ { \ell } |$ . Then, take the dot product of each side of the above equation by the vector with entries (indexed by
+
+$j$ ) equal to $\scriptstyle w _ { j } \left( \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { d - s }$
+
+$$
+\begin{array} { l } { \displaystyle 0 = \sum _ { \ell = 1 } ^ { r } c _ { \ell } \sum _ { j = 1 } ^ { m } w _ { j } \prod _ { \hbar \in S _ { \ell } } a _ { \hbar j } \left( \displaystyle \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { d - s } } \\ { = \displaystyle \sum _ { \ell | ( | S _ { \ell } | = s ) } c _ { \ell } \sum _ { j = 1 } ^ { m } w _ { j } \prod _ { \hbar \in S _ { \ell } } a _ { \hbar j } \left( \displaystyle \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { d - | S _ { \ell } | } } \\ { + \displaystyle \sum _ { \ell | ( | S _ { \ell } | < s ) } c _ { \ell } \sum _ { j = 1 } ^ { m } w _ { j } \prod _ { \hbar \in S _ { \ell } } a _ { \hbar j } \left( \displaystyle \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { ( d + | S _ { \ell } | - s ) - | S _ { \ell } | } . } \end{array}
+$$
+
+We can use (12) to simplify the first term and (13) (with $k = d + | S _ { \ell } | - s )$ to simplify the second term, giving us:
+
+$$
+\begin{array} { l } { { \displaystyle 0 = \sum _ { \ell | ( | S _ { \ell } | = s ) } c _ { \ell } \cdot \frac { | S _ { \ell } | ! } { \sigma _ { d } \cdot d ! } \cdot \frac { \partial } { \partial S _ { \ell } } p ( { \bf x } ) + \sum _ { \ell | ( | S _ { \ell } | < s ) } c _ { \ell } \cdot \frac { | S _ { \ell } | ! } { \sigma _ { d + | S _ { \ell } | - s } \cdot ( d + | S _ { \ell } | - s ) ! } \cdot 0 } } \\ { { \displaystyle = \sum _ { \ell | ( | S _ { \ell } | = s ) } c _ { \ell } \cdot \frac { | S _ { \ell } | ! } { \sigma _ { d } \cdot d ! } \cdot \frac { \partial } { \partial S _ { \ell } } p ( { \bf x } ) } . } \end{array}
+$$
+
+Since the distinct monomials $\begin{array} { r } { \frac { \partial } { \partial S _ { \ell } } p ( \mathbf { x } ) } \end{array}$ are linearly independent, this contradicts our assumption that the $c _ { \ell }$ are nonzero. We conclude that A has full row rank, and therefore that $m _ { 1 } ^ { \mathrm { T a y l o r } } ( p ) = m \geq$ $\textstyle \prod _ { i = 1 } ^ { n } ( r _ { i } + 1 )$ . This completes the proof of part (i).
+
+Part (ii) of the theorem was demonstrated in the proof of Theorem 4.1. This completes the proof.
+
+# 7.3 PROOF OF THEOREM 4.3.
+
+Our proof in Theorem 4.1 relied upon the fact that all nonzero partial derivatives of a monomial are linearly independent. This fact is not true for general polynomials $p$ ; however, an exactly similar argument shows that $m _ { 1 } ^ { \mathrm { u n i f o r m } } ( p )$ is at least the number of linearly independent partial derivatives of $p$ , taken with respect to multisets of the input variables.
+
+Consider the monomial of such that $m _ { 1 } ^ { \mathrm { u n i f o r m } } ( q )$ is maximized, and suppose that $q ( \mathbf { x } ) \mathbf { \Psi } = \mathbf { \tilde { \Gamma } }$ $x _ { 1 } ^ { r _ { 1 } } x _ { 2 } ^ { r _ { 2 } } \cdot \cdot \cdot x _ { n } ^ { r _ { n } }$ . By Theorem 4.1, $m _ { 1 } ^ { \mathrm { u n i f o r m } } ( q )$ 1is equal to the number $\textstyle \prod _ { i = 1 } ^ { n } ( r _ { i } + { \bar { 1 } } )$ of distinct monomials that can be obtained by taking partial derivatives of $q$ . Let $Q$ be the set of such monomials, and let $D$ be the set of (iterated) partial derivatives corresponding to them, so that for $d \in D$ , we have $d ( q ) \in Q$ .
+
+Consider the set of polynomials $P = \{ d ( p ) \mid d \in D \}$ . We claim that there exists a linearly independent subset of $P$ with size at least $| D | / c$ . Suppose to the contrary that $P ^ { \prime }$ is a maximal linearly independent subset of $P$ with $| P ^ { \prime } | < | D | / c$ .
+
+Since $p$ has $c$ monomials, every element of $P$ has at most $c$ monomials. Therefore, the total number of distinct monomials in elements of $P ^ { \prime }$ is less than $| D |$ . However, there are at least $| D |$ distinct monomials contained in elements of $P$ , since for $d \in D$ , the polynomial $d ( p )$ contains the monomial $d ( q )$ , and by definition all $d ( q )$ are distinct as $d$ varies. We conclude that there is some polynomial $p ^ { \prime } \in P \backslash P ^ { \prime }$ containing a monomial that does not appear in any element of $P ^ { \prime }$ . But then $p ^ { \prime }$ is linearly independent of $P ^ { \prime }$ , a contradiction since we assumed that $P ^ { \prime }$ was maximal.
+
+We conclude that some linearly independent subset of $P$ has size at least $| D | / c ,$ and therefore that the space of partial derivatives of $p$ has rank at least $| D | / c = m _ { 1 } ^ { \mathrm { u n i f o r m } } ( q ) / c$ . This proves part (i) of the theorem. Part (ii) follows immediately from the definition of $m ^ { \mathrm { u n i f o r m } } ( p )$ .
+
+Similar logic holds for $m ^ { \mathrm { T a y l o r } }$ .
+
+# 7.4 PROOF OF THEOREM 4.4.
+
+We will prove the desired lower bounds for $m _ { 1 } ^ { \mathrm { u n i f o r m } } ( p )$ ; a very similar argument holds for Taylor1 (p). As above, suppose that $r _ { i } > 0$ for $i = 1 , \ldots , n$ . Let $X$ be the multiset in which $x _ { i }$ occurs with multiplicity $r _ { i }$ .
+
+Suppose that $N _ { \epsilon } ( \mathbf { x } )$ is an $\epsilon$ -approximation to $p ( \mathbf { x } )$ with depth 1, and let the degree- $d$ Taylor polynomial of $N _ { \epsilon } ( \mathbf { x } )$ be $p ( \mathbf { x } ) + E ( \mathbf { x } )$ . Let $E _ { d } ( \mathbf { x } )$ be the degree- $d$ homogeneous component of $E ( \mathbf { x } )$ . Observe that the coefficients of the error polynomial $E _ { d } ( \mathbf { x } )$ can be made arbitrarily small by setting $\epsilon$ sufficiently small.
+
+Let ing $m = m _ { 1 } ^ { \mathrm { u n i f o r m } } ( p )$ and suppose that der, we conclude t $\sigma ( x )$ has the Taylor expere exist constants ion an $\scriptstyle \sum _ { k = 0 } ^ { \infty } \sigma _ { k } x ^ { k }$ . Then, by group-at $a _ { i j }$ $w _ { j }$
+
+$$
+\sigma _ { d } \sum _ { j = 1 } ^ { m } w _ { j } \left( \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { d } = p ( \mathbf { x } ) + E _ { d } ( \mathbf { x } )
+$$
+
+For each $S \subseteq X$ , let us take the derivative of this equation by every variable that occurs in $S$ , where we take multiple derivatives of variables that occur multiple times. This gives
+
+$$
+\frac { \sigma _ { d } \cdot d ! } { | S | ! } \sum _ { j = 1 } ^ { m } w _ { j } \prod _ { h \in S } a _ { h j } \left( \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { d - | S | } = \frac { \partial } { \partial S } p ( { \bf x } ) + \frac { \partial } { \partial S } E _ { d } ( { \bf x } ) .
+$$
+
+Consider this equation as $S \subseteq X$ varies over all $C _ { s }$ multisets of fixed size $s$ . The left-hand side represents a linear combination of the $m$ terms $\scriptstyle \left( \sum _ { i = 1 } ^ { n } a _ { i j } x _ { i } \right) ^ { d - s }$ . The polynomials $\begin{array} { r } { \frac { \partial } { \partial S } p ( { \bf x } ) + \frac { \partial } { \partial S } E _ { d } ( { \bf x } ) } \end{array}$ on the right-hand side must be linearly independent as $S$ varies, since the distinct monomials $\begin{array} { r } { \frac { \partial } { \partial S } p ( { \bf x } ) } \end{array}$ are linearly independent and the coefficients of $\frac { \partial } { \partial S } E _ { d } ( { \bf x } )$ can be made arbitrarily small.
+
+This means that the number $m$ of linearly combined terms on the left-hand side must be at least the number $C _ { s }$ of choices for $S$ . Observe that $C _ { s }$ is the coefficient of the term $y ^ { s }$ in the polynomial $\begin{array} { r } { g ( y ) = \prod _ { i } ( 1 + y + . . . + y ^ { r _ { i } } ) } \end{array}$ . A simple (and not very good) lower bound for $C _ { s }$ is $\textstyle { \frac { 1 } { d } } \prod _ { i = 1 } ^ { \dot { n } } { \big ( } r _ { i } + 1 { \big ) }$ , since there are $\textstyle \prod _ { i = 1 } ^ { n } ( r _ { i } + 1 )$ distinct sub-multisets of $X$ , and their cardinalities range from 0 to $d$ .

parse/train/luGQiBeRMxd/luGQiBeRMxd.md

@@ -0,0 +1,543 @@
+# CORRATTACK: BLACK-BOX ADVERSARIAL ATTACKWITH STRUCTURED SEARCH
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We present a new method for score-based adversarial attack, where the attacker queries the loss-oracle of the target model. Our method employs a parameterized search space with a structure that captures the relationship of the gradient of the loss function. We show that searching over the structured space can be approximated by a time-varying contextual bandits problem, where the attacker takes feature of the associated arm to make modifications of the input, and receives an immediate reward as the reduction of the loss function. The time-varying contextual bandits problem can then be solved by a Bayesian optimization procedure, which can take advantage of the features of the structured action space. The experiments on ImageNet and the Google Cloud Vision API demonstrate that the proposed method achieves the state of the art success rates and query efficiencies for both undefended and defended models.
+
+# 1 INTRODUCTION
+
+Although deep learning has many applications, it is known that neural networks are vulnerable to adversarial examples, which are small perturbations of inputs that can fool neural networks into making wrong predictions (Szegedy et al., 2014). While adversarial noise can easily be found when the neural models are known (referred to as white-box attack) (Kurakin et al., 2016). However, in real world scenarios models are often unknown, this situation is referred to as black-box attack.
+
+Some methods (Liu et al., 2016; Papernot et al., 2016) use the transfer-based attack, which generates adversarial examples on a substitute model and transfer the adversarial noise to the target model. However, the transferability is limited and its effectiveness relies highly on the similarity between the networks (Huang & Zhang, 2020). If two networks are very different, transfer-based methods will have low success rates.
+
+In practice, most computer vision API such as the Google Cloud Vision API allow users to access the scores or probabilities of the classification results. Therefore, the attacker may query the black-box model and perform zeroth order optimization to find an adversarial example without the knowledge of the target model. Due to the availability of scores, this scenario is called score-based attack.
+
+There have been a line of studies on black-box attack which directly estimate the gradient direction of the underlying model, and apply (stochastic) gradient descent to the input image (Ilyas et al., 2018; 2019; Chen et al., 2017; Huang & Zhang, 2020; Tu et al., 2018; Li et al., 2019). In this paper, we take another approach and formulate score-based attack as a time-varying contextual bandits problem. At each state, the attacker may change the adversarial perturbation and get the reward as the reduction of the loss. And the attacker would receive some features about the arms before making the decision. By limiting the action space to image blocks, the associated bandits problem exhibits local correlation structures and the slow varying property suitable for learning. Therefore, we may use the location and other features of the blocks to estimate the reward for the future selection of the actions.
+
+Using the above insights, we propose a new method called CorrAttack, which utilizes the local correlation structure and the slow varying property of the underlying bandits problem. CorrAttack uses Bayesian optimization with Gaussian process regression (Rasmussen, 2003) to model the correlation and select optimal actions. A forgetting strategy is added to the algorithm so that the Gaussian process regression can handle the time-varying changes. CorrAttack can effectively find blocks with the largest rewards. The resulting method achieves much lower numbers of average queries and higher success rates than prior methods with a similar action space (Moon et al., 2019).
+
+It is worth noting that BayesOpt (Ru et al., 2020) and Bayes-Attack (Shukla et al., 2019) also employ Bayesian optimization for score-based attack. However, their Gaussian process regression directly models the loss as a function of the image, whose dimension can be more than one thousand. Therefore, their speed is slow especially for BayesOpt, which uses slow additive kernel. CorrAttack, on the other hand, searches over a much limited action space and models the reward as a function of the low dimensional feature. Therefore, the optimization of CorrAttack is more efficient, and the method is significantly faster than BayesOpt.
+
+We summarize the contributions of this work as follows:
+
+1. We formulate the score-based adversarial attack as a time-varying contextual bandits, and show that the reward function has slow varying properties. In our new formulation, the attacker could take advantage of the features to model the reward of the arms with learning techniques. Compared to the traditional approach, the use of learning in the proposed framework greatly improves the efficiency of searching over optimal actions. 2. We propose a new method, CorrAttack, which uses Bayesian optimization with Gaussian process regression to learn the reward of each action, by using the feature of the arms. 3. The experiments show that CorrAttack achieves the state of the art performance on ImageNet and Google Cloud Vision API for both defended and undefended models.
+
+# 2 RELATED WORK
+
+There have been a line of works focusing on black-box adversarial attack. Here, we give a brief review of various existing methods.
+
+Transfer-Based Attack Transfer-based attack assumes the transferability of adversarial examples across different neural networks. It starts with a substitute model that is in the same domain as the target model. The adversaries can be easily generated on the white-box substitute model, and be transferred to attack the target model (Papernot et al., 2016). The approach, however, depends highly on the similarity of the networks. If two networks are distinct, the success rate of transferred attack would rapidly decrease (Huang & Zhang, 2020). Besides, we may not access the data for training the substitute model in practice.
+
+Score-based Attack Many approaches estimate the gradient with the output scores of the target network. However, the high dimensionality of input images makes naive coordinate-wise search impossible as it requires millions of queries. ZOO (Chen et al., 2017) is an early work of gradient estimation, which estimates the gradient of an image block and perform block-wise gradient descent. NES (Wierstra et al., 2008) and CMA-ES (Hansen, 2016) are two evolution strategies that can perform query efficient score-based attack Ilyas et al. (2018); Meunier et al. (2019). Instead of the gradient itself, SignHunter (Al-Dujaili & O’Reilly, 2020a) just estimates the sign of gradient to reduce the complexity. AutoZOOM (Tu et al., 2018) uses bilinear transformation or autoencoder to reduce the sampling space and accelerate the optimization process. In the same spirit, data prior can be used to improve query efficiency (Ilyas et al., 2019). Besides, MetaAttack (Du et al., 2020) takes a meta learning approach to learn gradient patterns from prior information, which reduces queries for attacking targeted model.
+
+Many zeroth order optimization methods for black-box attacks rely on gradient estimation. However, there are some research works using gradient free methods to perform black-box attack. BayesOpt and Bayes-Attack (Ru et al., 2020; Shukla et al., 2019) employ Bayesian optimization to find the adversarial examples. They use Gaussian process regression on the embedding and apply bilinear transformation to resize the embedding to the size of image. Although the bilinear transformation could alleviate the high dimensionality of images, the dimension of their embeddings are still in the thousands, which makes Bayesian optimization very ineffective and computationally expensive. A different method, PARSI, poses the attack on $\ell _ { \infty }$ norm as a discrete optimization problem over $\{ - \varepsilon , \varepsilon \} ^ { d }$ (Moon et al., 2019). It uses a Lazy-Greedy algorithm to search over the space $\{ - \varepsilon , \varepsilon \} ^ { d }$ to find an adversarial example. SimBA (Guo et al., 2018) also employs a discrete search space targeted at $\ell _ { 2 }$ norm.
+
+Decision-based Attack Decision-based attack assumes the attacker could only get the output label of the model. Boundary Attack and its variants (Brendel et al., 2017; Chen et al., 2020; Li et al., 2020) are designed for the setting. However, the information received by the attacker is much smaller than score-based attack, and it would take many more queries than score-based attack to successfully attack an image.
+
+# 3 PRELIMINARIES
+
+A Gaussian process (Rasmussen, 2003) is a prior distribution defined on some bounded set $\mathcal { Z }$ , and is determined by a mean function $\mu : \mathcal { Z } \to \mathbb { R }$ and a covariance kernel $\kappa : \mathcal { Z } \times \mathcal { Z } \to \mathbb { R }$ . Given $n$ observations $\mathcal { D } _ { n } = \{ ( z _ { i } , f ( z _ { i } ) ) \} _ { i = 1 } ^ { n }$ , the prior distribution on $f ( z _ { 1 : n } )$ is
+
+$$
+f ( z _ { 1 : n } ) \sim \mathrm { N o r m a l } ( \mu _ { 0 } ( z _ { 1 : n } ) , \kappa _ { 0 } ( z _ { 1 : n } , z _ { 1 : n } ) ) ,
+$$
+
+where we use compact notation for functions applied to collections of input points: $z _ { 1 : n }$ indicates the sequence $z _ { 1 } , \cdots , z _ { n }$ $z _ { n } , f ( z _ { 1 : n } ) = [ f ( z _ { 1 } ) , \cdot \cdot \cdot , f ( z _ { n } ) ] ,$ , $\mu _ { 0 } ( z _ { 1 : n } ) = \bar { [ \mu _ { 0 } ( z _ { 1 } ) , \cdot \cdot \cdot , \mu _ { 0 } ( z _ { n } ) ] }$ , $\kappa _ { 0 } ( z _ { 1 : n } , z _ { 1 : n } ) = [ \kappa _ { 0 } ( z _ { 1 } , z _ { 1 } ) , \cdot \cdot \cdot , \kappa _ { 0 } ( z _ { 1 } , z _ { n } ) ; \cdot \cdot \cdot ; \kappa _ { 0 } ( z _ { n } , z _ { 1 } ) , \cdot \cdot \cdot , \kappa _ { 0 } ( z _ { n } , z _ { n } ) ; ] .$
+
+Gaussian process (GP) with mean Now we wish to infer the value of $f ( z )$ $\mu _ { n }$ and covariance at some new point $\sigma _ { n } ^ { 2 }$ : $z$ , the posterior process $f ( z ) | \mathcal { D } _ { n }$ is also a
+
+$$
+\begin{array} { r l } & { f ( z ) \lvert \mathcal { D } _ { n } \sim \mathrm { N o r m a l } ( \mu _ { n } ( z ) , \sigma _ { n } ^ { 2 } ( z ) ) , } \\ & { \quad \mu _ { n } ( z ) = \kappa _ { 0 } ( z , z _ { 1 : n } ) \kappa _ { 0 } ( z _ { 1 : n } , z _ { 1 : n } ) ^ { - 1 } ( f ( z _ { 1 : n } ) - \mu _ { 0 } ( z _ { 1 : n } ) ) + \mu _ { 0 } ( z ) , } \\ & { \quad \sigma _ { n } ^ { 2 } ( z ) = \kappa _ { 0 } ( z , z ) - \kappa _ { 0 } ( z , z _ { 1 : n } ) \kappa _ { 0 } ( z _ { 1 : n } , z _ { 1 : n } ) ^ { - 1 } \kappa _ { 0 } ( z _ { 1 : n } , z ) . } \end{array}
+$$
+
+As a optimization method to maximize a function $f$ , Bayesian optimization models the function to make decisions about where to evaluate the next point $z$ . Assuming we already obtained observations $\mathcal { D } _ { t - 1 } = \{ ( z _ { i } , f ( z _ { i } ) ) \} _ { i = 1 } ^ { t - 1 }$ , to determine the next point $z _ { t }$ for evaluation, we first use the posterior GP to define an acquisition function $\varphi _ { t } : \mathcal { Z }  \mathbb { R }$ , which models the utility of evaluating $f ( z )$ for any $z \in { \mathcal { Z } }$ . We then evaluate $f ( z _ { t } )$ with
+
+$$
+z _ { t } = \arg \operatorname* { m a x } _ { \mathcal { Z } } \varphi _ { t } ( z ) .
+$$
+
+In this work, we use the expected improvement (EI) acquisition function (Mockus et al., 1978)
+
+$$
+\varphi _ { t } ( z ) = \sqrt { \sigma _ { n } ^ { 2 } ( z ) } ( \gamma ( z ) \Phi ( \gamma ( z ) ) + \phi ( \gamma ( z ) ) ) \qquad \mathrm { w i t h } \qquad \gamma ( z ) = \frac { \mu _ { n } ( z ) - f ( z _ { b e s t } ) } { \sqrt { \sigma _ { n } ^ { 2 } ( z ) } } ,
+$$
+
+which measures the expected improvement over the current best value $z _ { b e s t . } = \arg \operatorname* { m a x } _ { z _ { i } } f ( z _ { i } )$ according to the posterior GP. Here $\Phi ( \cdot )$ and $\phi ( \cdot )$ are the cdf and pdf of $\mathcal { N } ( 0 , I )$ respectively.
+
+# 4 SCORE-BASED BLACK-BOX ATTACK
+
+Suppose a classifier $F ( x )$ has input $x$ and label $y$ . An un-targeted adversarial example $x _ { a d v }$ satisfies:
+
+$$
+\underset { j \in \{ 1 , \cdots C \} } { \arg \operatorname* { m a x } } F ( x _ { a d v } ) _ { j } \neq y \qquad \mathrm { a n d } \qquad \| x _ { a d v } - x \| _ { p } \leq \varepsilon ,
+$$
+
+where $C$ is the number of classes. While an adversarial example for targeted attack means the maximum position of $F ( x )$ should be the targeted class $q$ : arg $\mathrm { m a \bar { x } } _ { j \in \{ 1 , \cdots C \} } \mathbf { \bar { F } } ( x _ { a d v } ) _ { j } = q$ . In order to find $x _ { a d v }$ , we may optimize a surrogate loss function $\ell ( x , y )$ (e.g hinge loss).
+
+In this work, we consider adversarial attack as a time-varying contextual bandits problem. At each time $t$ , we observe a state $x _ { t }$ which is a modification of the original input $x _ { 0 }$ . Before taking arm $a _ { t } \in \mathcal { A } \subset \mathbb { R } ^ { d }$ , we could observe the feature $z$ of arms. And $a _ { t }$ would modify state $x _ { t }$ to $x _ { t + 1 }$ according to
+
+$$
+x _ { t + 1 } = \underset { s \in \{ x _ { t } + a _ { t } , x _ { t } \} } { \arg \operatorname* { m i n } } \ell \left( \Pi _ { B _ { p } \left( x , \varepsilon \right) } \left( s \right) , y \right)
+$$
+
+with reward function $r ( x _ { t } , a _ { t } ) = \ell ( x _ { t + 1 } , y ) - \ell ( x _ { t } , y )$ and the checking step tries to remove negative reward. In this frame, we would like to estimate the reward $r ( x _ { t } , a _ { t } )$ with feature $z _ { t }$ using learning, and then pick $a _ { t }$ to maximize the reward. Observe that
+
+$$
+\boldsymbol { r } ( x _ { t } , a _ { t } ) \approx \nabla _ { x } \ell ( x _ { t } , y ) ^ { \top } ( x _ { t + 1 } - x _ { t } ) ,
+$$
+
+where the gradient $\nabla _ { x _ { t } } \ell ( x _ { t } , y )$ is unknown. It follows from the formulation that we may rewrite $r ( x _ { t } , a _ { t } )$ as a function
+
+$$
+r ( x _ { t } , a _ { t } ) \approx f ( x _ { t } , x _ { t + 1 } - x _ { t } ) .
+$$
+
+Since in general, we make small steps from one iteration to the next iteration, $\delta _ { t } ( a _ { t } ) = x _ { t + 1 } - x _ { t }$ is small. We may approximate the reward with fixed gradient locally with
+
+$$
+f ( x _ { t } , \delta _ { t } ) = \tilde { f } _ { t } ( a _ { t } ) ,
+$$
+
+We may consider the learning of reward as a time-varying contextual bandits problem with reward function $\tilde { f } _ { t } ( \boldsymbol a _ { t } )$ for arm $a _ { t }$ at time $t$ . Since $x _ { t + 1 } - x _ { t }$ is small, this time-varying bandits has slowvarying property: the function $\tilde { f } _ { t }$ changes slowly from time $t$ to time $t + 1$ .
+
+In the proposed framework, our goal is to learn the time-varying bandits reward $\tilde { f } _ { t } ( \boldsymbol a _ { t } )$ with feature $z _ { t }$ . We use Gaussian process regression to model the reward function using recent historic data since the reward function is slow-varying, and describe the details in the subsequent sections.
+
+We note that the most general action space contains all $a _ { t } \in \mathbb { R } ^ { d }$ , where $d$ is the number of image pixels. However, it is impossible to explore the arms in such a large space. In this work, we choose a specific class of actions $\mathcal { A } = \{ a _ { i } \} _ { i = 1 } ^ { n }$ , $n$ is the image blocks of different sizes. It covers the space of the adversarial perturbations while maintaining good complexity. We also find the location and the PCA of the blocks a good component of the feature $z$ associated with the arm. Besides, modifying a block only affects the state locally. Therefore the reward function remains similar after state changes.
+
+# 4.1 STRUCTURED SEARCH WITH GAUSSIAN PROCESS REGRESSION AND BAYESIAN OPTIMIZATION
+
+Define the block size as $b$ , we divide the image into several blocks $E = \{ e _ { 0 0 0 } , e _ { 0 0 1 } , \cdot \cdot \cdot , e _ { h w c } \}$ , where the block is $b \times b$ square of pixels and $( \bar { h } , w , c ) = ( \mathrm { h e i g h t } / b$ , width/ $\mathit { b }$ , channel). Each block $e _ { i j k }$ is associated with the feature $z _ { e _ { i j k } }$ such as the location of the block.
+
+Suppose we have time-varying bandits with state $x _ { t }$ and unknown reward function $\tilde { f } _ { t }$ at time $t$ . By taking the action $a _ { e _ { i j k } }$ , we change the individual block $e _ { i j k }$ of $x _ { t }$ and get $x _ { t + 1 }$ with reward $\tilde { f } _ { t } \big ( a _ { e _ { i j k } } \big )$ . We consider two ways of taking action $a _ { e _ { i j k } }$ on block $e _ { i j k }$ : CorrAttackDiff and CorrAttackFlip.
+
+Finite Difference CorrAttackDiff: For action $a _ { e _ { i j k } }$ , the attacker will query $\ell ( x _ { t } + \eta e _ { i j k } , y )$ and $\ell ( x _ { t } - \eta e _ { i j k } , y )$ , and choose
+
+$$
+a _ { e _ { i j k } } = \underset { s \in \{ \eta e _ { i j k } , - \eta e _ { i j k } \} } { \arg \operatorname* { m i n } } \ell ( x _ { t } + s , y ) .
+$$
+
+The action space $\mathcal { A } = \{ a _ { e _ { i j k } } | e _ { i j k } \in E \}$ .
+
+In our framework, the bandits problem can also be regarded as learning the conditional gradient over actions. That is, when $\eta$ is small, we try to choose action $a _ { t }$ with
+
+$$
+a _ { t } = \underset { e _ { i j k } \in E } { \arg \operatorname* { m i n } } e _ { i j k } ^ { \top } \nabla _ { x _ { t } } \ell ( x _ { t } , y )
+$$
+
+which is the conditional gradient over the set of blocks.
+
+Discrete Approximation CorrAttackFlip: In general, adversarial attack with $\ell _ { \infty }$ budget can be formulated as constrained optimization with $\| x _ { a d v } - x \| _ { \infty } \leq \epsilon .$ . However, PARSI (Moon et al., 2019) limits the space to $\{ - \varepsilon , + \varepsilon \} _ { \mathrm { ~ . ~ } } ^ { d }$ , which leads to better performance for black-box attack (Moon et al., 2019). The continuous optimization problem becomes a discrete optimization problems as follows:
+
+$$
+\begin{array} { l } { \mathrm { m a x i m i z e } ~ \ell ( x _ { a d v } , y ) \Longrightarrow \quad \mathrm { m a x i m i z e } ~ \ell ( x _ { a d v } , y ) } \\ { \mathrm { s u b j e c t } \mathrm { t o } ~ \| x _ { a d v } - x \| _ { \infty } \leq \epsilon \qquad \mathrm { s u b j e c t } \mathrm { t o } ~ x _ { a d v } - x \in \{ \epsilon , - \epsilon \} ^ { d } . } \end{array}
+$$
+
+Following PARSI, we consider two stages to perform structured search. When flipping $\varepsilon$ to $- \varepsilon$ , $a _ { e _ { i j k } }$ changes the block to $- \varepsilon$ and $\mathcal { A } \bar { = } \{ - 2 \varepsilon e _ { i j k } | e _ { i j k } \in E \}$ . When changing $- \varepsilon$ to $\varepsilon$ , ${ \mathcal { A } } =$ $\{ 2 \bar { \varepsilon } e _ { i j k } | e _ { i j k } \in E \}$ instead.
+
+Gaussian Process (GP) Regression: We model the difference function
+
+$$
+\begin{array} { r } { g _ { t } ( a _ { t } ) = \ell ( \Pi _ { B _ { p } ( x , \varepsilon ) } \left( x _ { t } + a _ { t } \right) , y ) - \ell ( x _ { t } , y ) } \end{array}
+$$
+
+instead of the reward function $\tilde { f } _ { t } ( a _ { t } ) \geq 0$ , as the difference function could be negative, providing more information about the negative arms in $\mathcal { A }$ . We would collect historic actions with feature and difference $\{ z _ { k } , g _ { k } ( a _ { k } ) ) \} _ { k = 1 } ^ { t }$ and learn the difference to make choices at a later stage. At each time $t$ we use the Gaussian process regression to model the correlation between the features $z _ { e _ { i j k } }$ and use Bayesian optimization to select the next action. More specifically, the same as eq. (2), we let
+
+$$
+g _ { t } \big ( a _ { e _ { i j k } } \big ) | \mathcal { D } _ { t } \sim \mathrm { N o r m a l } ( \mu _ { t } \big ( z _ { e _ { i j k } } \big ) , \sigma _ { t } ^ { 2 } \big ( z _ { e _ { i j k } } \big ) \big ) ,
+$$
+
+where $\mathcal { D } _ { t } = \{ z _ { k } , g _ { k } ( a _ { k } ) ) \} _ { k = t - \tau } ^ { t }$ is the difference of evaluated blocks $e _ { t - \tau : t }$ with feature $z _ { e _ { t - \tau : t } }$ and $\tau$ is a parameter to forget old samples. Then we use EI acquisition function to pick up the next action $a _ { t + 1 }$ in $\mathcal { A }$ . More specifically, the same as eq. (4), we let
+
+$$
+a _ { t + 1 } = \underset { \mathcal { A } } { \arg \operatorname* { m a x } } \big ( \sqrt { \sigma _ { t } ^ { 2 } \big ( z _ { e _ { i j k } } \big ) } \big ( \gamma \big ( z _ { e _ { i j k } } \big ) \Phi \big ( \gamma \big ( z _ { e _ { i j k } } \big ) \big ) + \phi \big ( \gamma \big ( z _ { e _ { i j k } } \big ) \big ) \big ) \big )
+$$
+
+As the difference function $g _ { t }$ is varying, we take two strategies in Algorithm 2 to update the previous samples to make sure GP regression learns the current difference function well. The first strategy is to remove old samples in $\mathcal { D } _ { t }$ . Even if the bandits are slowly varying, the difference function will change significantly after a significant number of rounds. Therefore, we need to forget samples before $t - \tau$ . The second strategy is to remove samples near the last block $e _ { i _ { t } j _ { t } k _ { t } }$ in $\mathcal { D } _ { t }$ . As we discuss later, the difference function may change significantly in a local region near the last selected block. Therefore previous samples in this local region will be inaccurate. The resulting algorithm for CorrAttack is shown in Algorithm 1, which mainly follows standard procedure of Bayesian optimization.
+
+# Algorithm 1 CorrAttack
+
+Require: Loss function $\ell ( \cdot , \cdot )$ , Input $x _ { 0 }$ and its label $_ y$ , Action space $\mathcal { A } = \{ a _ { e _ { i j k } } \vert e _ { i j k } \in E \}$ , Parameter c, $\tau$ $\alpha$   
+1: Build set $\mathcal { D } _ { 0 } = \{ ( z _ { e _ { i _ { p } j _ { p } k _ { p } } } , g _ { 0 } ( a _ { e _ { i _ { p } j _ { p } k _ { p } } } ) ) \} _ { p = 1 } ^ { m }$ using latin hypercube sampling from $\boldsymbol { A }$   
+2: repeat   
+3: Fit the parameter of Normal $( \mu _ { t } ( z _ { e _ { i j k } } ) , \sigma _ { t } ^ { 2 } ( z _ { e _ { i j k } } ) )$ on $\mathcal { D } _ { t }$ according to Equation (12)   
+4: Calculate acquisition function $\varphi _ { t } \big ( z _ { e _ { i j k } } \big )$ and according to Equation (13)   
+5: Select $a _ { e _ { i _ { t } j _ { t } k _ { t } } } = \arg \operatorname* { m a x } _ { A } \varphi _ { t } ( z _ { e _ { i j k } } )$ according to Equation (13)   
+6: $\begin{array} { r } { x _ { t + 1 } = \arg \operatorname* { m i n } _ { s \in \{ x _ { t } + a _ { e _ { i _ { t } j _ { t } k _ { t } } } , x _ { t } \} } \ell ( \Pi _ { B _ { p } \left( x , \varepsilon \right) } \left( s \right) , y ) } \end{array}$   
+7: Update sample set $\mathcal { D } _ { t }$ with Algorithm 2 Dt+1 = UPDATESAMPLES(Dt, xt, xt+1, eitjtkt , gt+1(aeitjtkt ), τ, α)
+
+# Algorithm 2 Update Samples
+
+Require: Sample set $\mathcal { D } _ { t }$ , State $x _ { t } , x _ { t + 1 }$ , Block $e _ { i { t j t } } k _ { t }$ , Difference $g _ { t + 1 } { \left( a _ { e _ { i _ { t } j _ { t } k _ { t } } } \right) }$ , Paramter $\tau$ , $\alpha$   
+1: if $\boldsymbol { x } _ { t + 1 } \neq \boldsymbol { x } _ { t }$ then   
+2: $\mathcal { D } _ { t + 1 } = \mathcal { D } _ { t } \setminus \{ ( z _ { e _ { i j k } } , g ) \in \mathcal { D } _ { t } | | i - i _ { t } | + | j - j _ { t } | \leq \alpha \}$   
+3: else   
+4: $\mathcal { D } _ { t + 1 } = \mathcal { D } _ { t } \cup \{ ( z _ { e _ { i _ { t } j _ { t } k _ { t } } } , g _ { t + 1 } ( a _ { e _ { i _ { t } j _ { t } k _ { t } } } ) ) \}$   
+5: end if   
+6: Remove the earliest sample from $\mathcal { D }$ if the cardinality $| \mathcal { D } | > \tau$   
+7: return $\mathcal { D } _ { t + 1 }$
+
+# 4.2 FEATURES AND SLOW VARYING PROPERTY
+
+Features of Contextual Bandits: We use a four dimensional vector as the feature $z _ { e _ { i j k } }$
+
+$$
+z _ { e _ { i j k } } = ( i , j , k , p c a )
+$$
+
+where $i , j , k$ is the location of the block. And pca is the first component of PCA decomposition of $[ x _ { 0 } ( e _ { 0 0 0 } ) , x _ { 0 } ( e _ { 0 0 1 } ) , \cdot \cdot \cdot x _ { 0 } ( e _ { h w c } ) ]$ . $x _ { 0 } ( e _ { i j k } )$ means the block of natural image at the given position.
+
+The reward function depends on the gradient in Equation (7). It has been shown that the gradient $\nabla _ { x } \ell ( x , y )$ has local dependencies (Ilyas et al., 2019). Suppose two coordinates $e _ { i j k }$ and $e _ { l p q }$ are close, then $\nabla _ { x } \ell ( x , y ) _ { i j k } \approx \nabla _ { x } \ell ( x , y ) _ { l p q }$ . We consider the finite difference of the block $e _ { i j k }$
+
+$$
+\Delta _ { t } ( e _ { i j k } ) = \ell \left( x _ { t } + \eta e _ { i j k } , y \right) - \ell \left( x _ { t } - \eta e _ { i j k } , y \right) \approx 2 \eta e _ { i j k } ^ { \top } \nabla _ { x _ { t } } \ell \left( x _ { t } , y \right)
+$$
+
+where $\eta$ is a small step size. When $\eta$ is small, the reward can be approximated by the average of the gradients around a small region, which also has local dependencies. In fact, the local structure of the reward will also be persevered when the block size and $\eta$ is large. Figure 1 shows one example of the finite difference $\bar { \Delta } _ { t } ( e _ { i j k } )$ obtained on ImageNet dataset with ResNet50. This shows blocks with closer locations are more likely to have similar reward. Therefore, we add the location of the block as the feature so that it uses historic data to find the arm with the largest reward.
+
+![](images/02f73ef7126e8d0ac54b869e2d778211f45e7e82644b3049bc0665f0bcde27e3.jpg)  
+Figure 1: Finite difference of the perturbation for three channels on one image from ImageNet with ResNet50. $h = w = 2 8$ , $b = 8$ and $\eta = 0 . 0 5$ . Lighter block means larger finite difference.
+
+In addition to the location of the difference, we may add other features. The block of the image itself forms a strong feature for the regression, but the dimension of the block is too high for GP regression. Therefore, we use PCA to lower the dimension and add the first component into the feature vector.
+
+Slow Varying Property In addition to the local dependencies of finite difference, the difference would also be slow varying if we just change a small region of $x _ { t }$ . Let $x _ { t + 1 } = x _ { t } - \eta e _ { i _ { t } j _ { t } k _ { t } }$ , Figure 2 shows the difference of $\Delta _ { t } ( e _ { i j k } )$ and $\Delta _ { t + 1 } ( e _ { i j k } )$ , which is centralized in a small region near $e _ { i _ { t } j _ { t } k _ { t } }$ Reward function is based on the finite difference, which also has the slow varying property. It could be explained by the local property of convolution. When $\eta$ is small, the finite difference can be approximated with gradient and the local Hessian:
+
+$$
+\Delta _ { t + 1 } ( e _ { i j k } ) - \Delta _ { t } ( e _ { i j k } ) \approx \eta ^ { 2 } e _ { i j k } ^ { \top } \nabla _ { x _ { t } } ^ { 2 } \ell ( x _ { t } , y ) e _ { i _ { t } j _ { t } k _ { t } }
+$$
+
+The difference is much smaller than $\Delta _ { t } ( e _ { i j k } )$ . Today’s neural networks are built with stacks of convolutions and non-linear operations. Since these operations are localized in a small region, the Hessian of a neural network is also localized and the reward function only changes near $e _ { i _ { t } j _ { t } k _ { t } }$ .
+
+![](images/d72ed1414577c3723d59734b022355d0e25f9dc8821c3a4d2f918a1569bda44d.jpg)  
+Figure 2: Difference of finite difference on each block after changing block $e _ { 1 5 , 1 8 , 1 }$ of Figure 1, which is the lightest pixel in the picture. Darker blocks imply smaller difference in finite difference, which is almost zero in the majority of the image except the part near the changed block.
+
+# 4.3 HIERARCHICAL BAYESIAN OPTIMIZATION SEARCH
+
+Recent black-box approaches (Chen et al., 2017; Moon et al., 2019) exploit the hierarchical image structure for query efficiency. Following these approaches, we take a hierarchical approach and perform the accelerated local search in Algorithm 1 from a coarse grid (large blocks) to a fine grid (smaller blocks). The algorithm for hierarchical attack iteratively performs Algorithm 1 at one block size, and then divides the blocks into smaller sizes. At each block size, we build a Gaussian process to model the difference function, and perform structured search with the blocks until $\mathrm { m a x } _ { \boldsymbol { A } } \bar { \varphi } _ { t } ( z _ { e _ { i j k } } ) < c$ . When dividing the blocks into smaller sizes, we will build a new block set $E$ with action $a _ { e _ { i j k } }$ and new feature $z _ { e _ { i j k } }$ , but keep the $x _ { t }$ in last block size as $x _ { 0 }$ in new block size. Define the stage as $\mathcal { S } = \{ 0 , 1 , \cdots , s \}$ and initial block size as $b$ . The block at stage $s$ is ${ \frac { b } { 2 ^ { s } } } \times { \frac { b } { 2 ^ { s } } }$ square of pixels and $( h , w , c ) = ( 2 ^ { s } * \mathrm { h e i g h t } / b , 2 ^ { s } * \mathrm { w i d t h } / b$ , channel).
+
+The overall hierarchical accelerated local search algorithm is shown in Appendix A. It is important to note that most of the attacks terminate in the early stages and rarely need to run on fine scales.
+
+Table 1: Success rate and average queries of un-targeted attack on 1000 samples of ImageNet. $\varepsilon = 0 . 0 5$ . Since BayesOpt and Bayes-Attack needs thousands of hours to run all samples, we only test 20 samples, which are marked as \*, the complexity and running time could be referred to C.6.   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">VGG16</td><td colspan="2">Resnet50</td><td colspan="2">Densenet121</td></tr><tr><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>ZOO</td><td>81.93%</td><td>2003</td><td>63.68%</td><td>1795</td><td>76.73%</td><td>1864</td></tr><tr><td>NES</td><td>99.72%</td><td>700</td><td>99.19%</td><td>1178</td><td>99.72%</td><td>1074</td></tr><tr><td>NAttack</td><td>100%</td><td>293</td><td>99.73%</td><td>401</td><td>100%</td><td>375</td></tr><tr><td>Bandits</td><td>94.75%</td><td>389</td><td>96.92%</td><td>433</td><td>98.09%</td><td>635</td></tr><tr><td>PARSI</td><td>100%</td><td>365</td><td>99.73%</td><td>432</td><td>100%</td><td>387</td></tr><tr><td>Square Attack</td><td>100%</td><td>79</td><td>100%</td><td>112</td><td>100%</td><td>86</td></tr><tr><td>SignHunter</td><td>100%</td><td>104</td><td>100%</td><td>145</td><td>100%</td><td>118</td></tr><tr><td>CorrAttackDiff</td><td>100%</td><td>389</td><td>99.86%</td><td>419</td><td>99.86%</td><td>334</td></tr><tr><td>CorrAttackFlip</td><td>100%</td><td>130</td><td>100%</td><td>150</td><td>100%</td><td>113</td></tr><tr><td>BayesOpt*</td><td>100%</td><td>182</td><td>100%</td><td>214</td><td>100%</td><td>223</td></tr><tr><td>Bayes-Attack*</td><td>100%</td><td>244</td><td>100%</td><td>254</td><td>100%</td><td>213</td></tr><tr><td>CorrAttackFlip*</td><td>100%</td><td>110</td><td>100%</td><td>96</td><td>100%</td><td>87</td></tr></table>
+
+Table 2: Success rate and average queries of targeted attack on ImageNet. $\varepsilon = 0 . 0 5$ and query limit is 10000. As BayesOpt and Bayes-Attack run very slow, we do not include them for the targeted attack.   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">VGG16</td><td colspan="2">Resnet50</td><td colspan="2">Densenet121</td></tr><tr><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>ZOO</td><td>1.1%</td><td>2884</td><td>0.8%</td><td>3018</td><td>1.1%</td><td>3309</td></tr><tr><td>NES</td><td>80.82%</td><td>4582</td><td>52.73%</td><td>5762</td><td>64.21%</td><td>5427</td></tr><tr><td>NAttack</td><td>91.86%</td><td>4045</td><td>89.05%</td><td>3799</td><td>91.97%</td><td>4389</td></tr><tr><td>Bandits</td><td>50.62%</td><td>5379</td><td>40.18%</td><td>5672</td><td>43.53%</td><td>5434</td></tr><tr><td>PARSI</td><td>76.28%</td><td>3229</td><td>64.88%</td><td>3403</td><td>75.09%</td><td>3246</td></tr><tr><td>Square Attack</td><td>96.69%</td><td>2060</td><td>89.52%</td><td>2807</td><td>95.38%</td><td>2280</td></tr><tr><td>SignHunter</td><td>93.52%</td><td>2999</td><td>83.71%</td><td>3905</td><td>90.75%</td><td>3632</td></tr><tr><td>CorrAttackDiff</td><td>88.41%</td><td>3826</td><td>81.84%</td><td>4064</td><td>91.29%</td><td>3513</td></tr><tr><td>CorrAttackFlip</td><td>98.07 %</td><td>2191</td><td>96.39%</td><td>2531</td><td>99.41%</td><td>2019</td></tr></table>
+
+# 5 EXPERIMENTS
+
+We evaluated the number of queries versus the success rates of CorrAttack on both undefended and defended network on ImageNet (Russakovsky et al., 2015). Moreover, we attacked Google Cloud Vision API to show that CorrAttack can generalize to a true black-box model.
+
+We used the common hinge loss proposed in the CW attack (Carlini & Wagner, 2017). We compared two versions of CorrAttack : CorrAttackDiff and CorrAttackFlip, to ZOO (Chen et al., 2017), NES (Ilyas et al., 2018), NAttack (Li et al., 2019), Bandits (Ilyas et al., 2019), PARSI (Moon et al., 2019), Square Attack (Andriushchenko et al., 2020), SignHunter(Al-Dujaili & O’Reilly, 2020b), BayesOpt (Ru et al., 2020) and Bayes-Attack (Shukla et al., 2019). We only test adversarial attack on $\ell _ { \infty }$ norm. The details of the Gaussian processes regression and the hyperparameters of CorrAttack are given in the Appendix B. We shall mention that CorrAttack is not sensitive to the hyperparameters. The hyperparameters of other methods follow those suggested by the original papers.
+
+# 5.1 UNDEFENDED NETWORK
+
+We randomly select 1000 images from the validation set of ImageNet and only attack correctly classified images. The query efficiency of CorrAttack is tested on VGG16 (Simonyan & Zisserman, 2014), Resnet50 (He et al., 2016) and Densenet121 (Huang et al., 2017), which are the most commonly used network structures. We set $\varepsilon = 0 . 0 5$ and the query limit to be 10000 except for BayesOpt and Bayes-Attack. For targeted attacks, we randomly choose the target class for each image and the target classes are maintained the same for the evaluation of different algorithms. The results are shown in Table 1 and 2. CorrAttackFlip outperforms other methods by a large margin.
+
+Table 3: Success rate and average queries of un-targeted attack on defended model. Since BayesOpt and Bayes-Attack take thousands of hours to run, we only tested on 10 samples from ImageNet with $\varepsilon = 0 . 0 5$ and 1000 query limit, which are marked as \*.   
+
+<table><tr><td>Method</td><td>ZOO</td><td>NES</td><td>NAttack</td><td>Bandits</td><td>PARSI</td></tr><tr><td>Success Queries</td><td>28.57% 1954</td><td>24.13% 3740</td><td>74.38% 1078</td><td>55.82%</td><td>73.40%</td></tr><tr><td>Method</td><td>SignHunter</td><td>Square Attack</td><td></td><td>1873 CorrAttackDiff</td><td>1529 CorrAttackFlip</td></tr><tr><td>Success Queries</td><td>68.97%</td><td>73.89%</td><td></td><td>64.86%</td><td>79.15%</td></tr><tr><td>Method</td><td>1392 BayesAttack*</td><td>1086</td><td>BayesOpt*</td><td>1599</td><td>1036 CorrAttackFlip*</td></tr><tr><td>Success</td><td>50.00%</td><td></td><td>50.00%</td><td></td><td>60.00%</td></tr><tr><td>Queries</td><td>129</td><td></td><td>406</td><td></td><td>206</td></tr></table>
+
+Table 4: Success rate and average queries of un-targeted attack on Google Cloud Vision API. $\varepsilon = 0 . 0 5$   
+
+<table><tr><td>Method</td><td>NAttack</td><td>BayesOpt</td><td>PARSI</td><td>CorrAttackFlip</td></tr><tr><td>Success</td><td>70.00%</td><td>30.00%</td><td>70.00%</td><td>80.00%</td></tr><tr><td>Queries</td><td>142</td><td>129</td><td>235</td><td>155</td></tr></table>
+
+As BayesOpt and Bayes-Attack takes tens of thousands of hours to attack 1000 images, we compare them with CorrAttack $\mathrm { F l i p }$ only on 20 images and un-targeted attack. The query limit is also reduced to 1000 as the time for BayesOpt and Bayes-Attack quickly increases as more samples add into the Gaussian distribution. The time comparison between three models is shown in Appendix C.6.
+
+Optimality of Bayesian optimization Appendix C.1 shows the rank the actions found by CorrAttack.   
+The attacker could find the action with large reward quickly.
+
+Varying $\varepsilon$ We also test the algorithms at different budget of adversarial perturbations at $\varepsilon = 0 . 0 4$ and $\varepsilon = 0 . 0 6$ on Resnet50. As it is shown in Appendix C.2, CorrAttack shows a consistently better performance at different $\varepsilon$ .
+
+Ablation study on random choices Appendix C.3 shows the ablation study of random version of CorrAttackDiff and CorrAttackFlip. In both cases, Bayesian optimization helps to gain better query efficiency.
+
+Ablation study on hierarchical attack We perform ablation study on the hierarchical attack and the result is shown in Appendix C.4. Hierarchical structure accelerates the CorrAttack and eliminates the sensitivity of choosing initial block size.
+
+Ablation study on features Appendix C.5 demonstrates how the feature of the contextual bandits affects the performance of attack. PCA would help to improve the efficiency of attack.
+
+# 5.2 DEFENDED NETWORK
+
+To evaluate the effectiveness of CorrAttack on adversarially defended networks, we tested our method on one of the SOTA robust model (Xie et al., 2018) on ImageNet. The weight is downloaded from Github1. "ResneXt DenoiseAll" is chosen as the target model as it achieves the best performance. We set $\varepsilon = 0 . 0 5$ and the maximum number of queries is 10000. As BayesOpt runs very slowly, the attack is also performed on 10 images and the query limit is 1000. The result is shown in Table 3. CorrAttackFlip still outperforms other methods.
+
+# 5.3 GOOGLE CLOUD VISION API
+
+We also attacked Google Cloud Vision API, a real world black-box model for classification. The target is to remove the top-1 label out of the classification output. We choose 10 images for the ImageNet dataset and set the query limit to be 500 due to high cost to use the API. We compare CorrAttackFlip with NAttack, BayesOpt and PARSI. The result is shown in Table 4. We also show one example of the classification output in Appendix C.9
+
+# 6 CONCLUSION AND FUTURE WORK
+
+We formulate the score-based adversarial attack as a time-varying contextual bandits and propose a new method CorrAttack. By performing structured search on the blocks of the image, the bandits has the slow varying property. CorrAttack takes advantage of the the features of the arm, and uses Bayesian optimization with Gaussian process regression to learn the reward function. The experiment shows that CorrAttack can quickly find the action with large reward and CorrAttack achieves superior query efficiency and success rate on ImageNet and Google Cloud Vision API.
+
+We only include basic features for learning the bandits. Other features like embedding from the transfer-based attack Huang & Zhang (2020) may be taken into account in the future work. While our work only focuses on adversarial attack on $\ell _ { \infty }$ norm, the same contextual bandits formulation could be generalized to other $\ell _ { p }$ norm to improve query efficiency. Besides, defense against CorrAttack may be achieved with adversarial training on CorrAttack , but it may not be able to defend other attacks in the meantime.
+
+# REFERENCES
+
+Abdullah Al-Dujaili and Una-May O’Reilly. Sign bits are all you need for black-box attacks. In International Conference on Learning Representations, 2020a. URL https://openreview. net/forum?id ${ . } = { }$ SygW0TEFwH.   
+Abdullah Al-Dujaili and Una-May O’Reilly. Sign bits are all you need for black-box attacks. In International Conference on Learning Representations, 2020b. URL https://openreview. net/forum?id ${ . } = { }$ SygW0TEFwH.   
+Maksym Andriushchenko, Francesco Croce, Nicolas Flammarion, and Matthias Hein. Square attack: a query-efficient black-box adversarial attack via random search. 2020.   
+Wieland Brendel, Jonas Rauber, and Matthias Bethge. Decision-based adversarial attacks: Reliable attacks against black-box machine learning models. arXiv preprint arXiv:1712.04248, 2017.   
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 IEEE Symposium on Security and Privacy (SP), pp. 39–57. IEEE, 2017.   
+Jianbo Chen, Michael I Jordan, and Martin J Wainwright. Hopskipjumpattack: A query-efficient decision-based attack. In 2020 IEEE Symposium on Security and Privacy (SP), pp. 1277–1294. IEEE, 2020.   
+Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security, pp. 15–26. ACM, 2017.   
+Kun Dong, David Eriksson, Hannes Nickisch, David Bindel, and Andrew G Wilson. Scalable log determinants for gaussian process kernel learning. In Advances in Neural Information Processing Systems, pp. 6327–6337, 2017.   
+Jiawei Du, Hu Zhang, Joey Tianyi Zhou, Yi Yang, and Jiashi Feng. Query-efficient meta attack to deep neural networks. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ Skxd6gSYDS.   
+Jacob Gardner, Geoff Pleiss, Kilian Q Weinberger, David Bindel, and Andrew G Wilson. Gpytorch: Blackbox matrix-matrix gaussian process inference with gpu acceleration. In Advances in Neural Information Processing Systems, pp. 7576–7586, 2018.   
+Chuan Guo, Mayank Rana, Moustapha Cisse, and Laurens van der Maaten. Countering adversarial images using input transformations. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id ${ . } = { }$ SyJ7ClWCb.
+
+Nikolaus Hansen. The cma evolution strategy: A tutorial. arXiv preprint arXiv:1604.00772, 2016.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4700–4708, 2017.
+
+Zhichao Huang and Tong Zhang. Black-box adversarial attack with transferable model-based embedding. In International Conference on Learning Representations, 2020. URL https: //openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ SJxhNTNYwB.
+
+Andrew Ilyas, Logan Engstrom, Anish Athalye, and Jessy Lin. Black-box adversarial attacks with limited queries and information. 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. 2137–2146, Stockholmsmässan, Stockholm Sweden, 10–15 Jul 2018. PMLR.
+
+Andrew Ilyas, Logan Engstrom, and Aleksander Madry. Prior convictions: Black-box adversarial attacks with bandits and priors. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $=$ BkMiWhR5K7.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016.
+
+Huichen Li, Xiaojun Xu, Xiaolu Zhang, Shuang Yang, and Bo Li. Qeba: Query-efficient boundarybased blackbox attack. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 1221–1230, 2020.
+
+Yandong Li, Lijun Li, Liqiang Wang, Tong Zhang, and Boqing Gong. Nattack: Learning the distributions of adversarial examples for an improved black-box attack on deep neural networks. arXiv preprint arXiv:1905.00441, 2019.
+
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. arXiv preprint arXiv:1611.02770, 2016.
+
+Laurent Meunier, Jamal Atif, and Olivier Teytaud. Yet another but more efficient black-box adversarial attack: tiling and evolution strategies. arXiv preprint arXiv:1910.02244, 2019.
+
+Jonas Mockus, Vytautas Tiesis, and Antanas Zilinskas. The application of bayesian methods for seeking the extremum. Towards global optimization, 2(117-129):2, 1978.
+
+Seungyong Moon, Gaon An, and Hyun Oh Song. Parsimonious black-box adversarial attacks via efficient combinatorial optimization. arXiv preprint arXiv:1905.06635, 2019.
+
+Nicolas Papernot, Patrick McDaniel, and Ian Goodfellow. Transferability in machine learning: from phenomena to black-box attacks using adversarial samples. arXiv preprint arXiv:1605.07277, 2016.
+
+Carl Edward Rasmussen. Gaussian processes in machine learning. In Summer School on Machine Learning, pp. 63–71. Springer, 2003.
+
+Binxin Ru, Adam Cobb, Arno Blaas, and Yarin Gal. Bayesopt adversarial attack. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum? id $=$ Hkem-lrtvH.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International journal of computer vision, 115(3):211–252, 2015.
+
+Satya Narayan Shukla, Anit Kumar Sahu, Devin Willmott, and J Zico Kolter. Black-box adversarial attacks with bayesian optimization. arXiv preprint arXiv:1909.13857, 2019.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations, 2014. URL http://arxiv.org/abs/1312.6199.
+
+Chun-Chen Tu, Paishun Ting, Pin-Yu Chen, Sijia Liu, Huan Zhang, Jinfeng Yi, Cho-Jui Hsieh, and Shin-Ming Cheng. Autozoom: Autoencoder-based zeroth order optimization method for attacking black-box neural networks. arXiv preprint arXiv:1805.11770, 2018.
+
+Daan Wierstra, Tom Schaul, Jan Peters, and Jürgen Schmidhuber. Natural evolution strategies. 2008 IEEE Congress on Evolutionary Computation (IEEE World Congress on Computational Intelligence), pp. 3381–3387, 2008.
+
+Cihang Xie, Yuxin Wu, Laurens van der Maaten, Alan Yuille, and Kaiming He. Feature denoising for improving adversarial robustness. arXiv preprint arXiv:1812.03411, 2018.
+
+A ALGORITHM
+
+# Algorithm 3 Split Block
+
+Require: Set of blocks $E$ , Block size $^ { b }$ , $E ^ { \prime } = \emptyset$   
+1: for each block $e \in E$ do   
+2: Split the block $e$ into 4 blocks $\{ e _ { 1 } , e _ { 2 } , e _ { 3 } , e _ { 4 } \}$ with size b/2   
+3: $\bar { E ^ { \prime } }  E ^ { \prime } \cup \{ e _ { 1 } , e _ { 2 } , e _ { 3 } , e _ { 4 } \}$   
+4: end for   
+5: return $E ^ { \prime }$ ;
+
+# Algorithm 4 Hierarchical CorrAttackDiff
+
+Require: Loss function $\ell ( \cdot , \cdot )$ , Input image $_ x$ and its label $y$ , Initial Block size $b$ , Set of blocks $E$ containing all blocks of the image, Threshold $c , \tau , \alpha$ , Step size $\eta$ , Adversarial budget $\varepsilon$   
+1: $x _ { 0 } = x$   
+2: repeat   
+3: Choose $A = \{ a _ { e _ { i j k } } | e _ { i j k } \in E \}$ with Equation (8)   
+4: Run CorrAttack on current block size $x =$ CORRATTACK $( \ell ( \cdot , \cdot ) , x , y , A , c , \tau , \alpha )$   
+5: if $b > 1$ then   
+6: Split the blocks into finer blocks using Algorithm 3 $\bar { E } = \mathrm { S P L I T B L O C K } ( E , b )$   
+7: $b \gets b / 2$   
+8: end if   
+9: until $\ell$ converges   
+10: return $x _ { K }$ ;
+
+# Algorithm 5 Hierarchical CorrAttackFlip
+
+Require: Loss function $\ell ( \cdot , \cdot )$ , Input image $x$ and its label $_ y$ , Block size $b$ , Set of blocks $E$ containing all blocks   
+of the image, Threshold $c , \tau , \alpha$ , Adversarial budget $\varepsilon$   
+1: $x _ { 0 } = x$   
+2: for $e _ { i j k } \in E$ do   
+3: Randomly draw $v$ from $\{ - \varepsilon , \varepsilon \}$   
+4: $x _ { 0 } [ e _ { i j k } ] = v + x _ { 0 } [ e _ { i j k } ]$   
+5: end for   
+6: repeat   
+7: $\begin{array} { r l } & { \mathbf { \Phi } _ { A _ { n } } ^ { \mathrm { \bf { k } } } = \{ 2 \varepsilon e _ { i j k } \in E | e _ { i j k } ^ { \top } ( x _ { k } - x ) < 0 \} } \\ & { \mathbf { \Phi } _ { \mathrm { { R u n } } } ^ { \mathrm { \bf { R u n } } } \mathrm { C o r r A t t a c k ~ f i j p i n g - } \varepsilon \tan \varepsilon } \\ & { \tilde { x } _ { k } = \mathrm { { C O R R A T A C K } } \left( \ell ( \cdot , \cdot ) , x _ { k } , y , A _ { n } , c , \tau , \alpha \right) } \\ & { A _ { p } = \{ - 2 \varepsilon e _ { i j k } \in E | e _ { i j k } ^ { \top } ( \tilde { x } _ { k } - x ) > 0 \} } \\ & { \mathbf { \Phi } _ { \mathrm { { R u n } } } ^ { \mathrm { \bf { R u n } } } { \mathrm { C o r r A t t a c k ~ f i i p p i n g ~ } } \varepsilon \tan - \varepsilon } \\ & { x _ { k + 1 } = { \mathrm { C O R R A T T A C K } } \left( \ell ( \cdot , \cdot ) , \tilde { x } _ { k } , y , A _ { p } , c , \tau , \alpha \right) } \\ & { \mathbf { \Phi } _ { \ast e _ { i } } ^ { \mathrm { \bf { \alpha } } } \quad \mathbf { \Phi } _ { \ast } ^ { \mathrm { \bf { 1 } } } \mathbf { \Phi } _ { \ast } \mathbf { \Phi } _ { \ast } \mathbf { \Phi } _ { \ast } \mathbf { \Phi } _ { \ast } \mathbf { \Phi } _ { \ast } } \end{array}$   
+8:   
+9:   
+10:   
+11: if $b > 1$ then   
+12: Split the blocks into finer blocks using Algorithm 3   
+E = SPLITBLOCK(E, b)   
+13: b ← b/2   
+14: end if   
+15: until $\ell$ converges   
+16: return xK;
+
+# B DETAILS OF EXPERIMENT SETTING
+
+We use the hinge loss for all the experiments. For un-targeted attacks,
+
+$$
+\ell _ { \mathrm { u n t a r g e t } } ( x , y ) = \operatorname* { m a x } \left\{ F ( x ) _ { y } - \operatorname* { m a x } _ { j \neq y } F ( x ) _ { j } , - \omega \right\}
+$$
+
+and for targeted attacks,
+
+$$
+\ell _ { \mathrm { t a r g e t } } ( x , y ) = \operatorname* { m a x } \left\{ \operatorname* { m a x } _ { j } F ( x ) _ { j } - F ( x ) _ { t } , - \omega \right\} .
+$$
+
+Here $F$ represents the logits of the network outputs, $t$ is the target class, and $\omega$ denotes the margin. The image will be projected into the $\varepsilon$ -ball. Besides, the value of the image will be clipped to range $[ 0 , 1 ]$ .
+
+# B.1 GAUSSIAN PROCESS REGRESSION AND BYAESIAN OPTIMIZATION
+
+We further provide details on both the computational scaling and modeling setup for the GP regression.
+
+To address computational issues, we use GPyTorch (Gardner et al., 2018) for scalable GP regression. GPyTorch follows (Dong et al., 2017) to solve linear systems using the conjugate gradient (CG) method and approximates the log-determinant via the Lanczos process. Without GPyTorch, running BO with a GP regression for more than a few thousand evaluations would be infeasible as classical approaches to GP regression scale cubically in the number of data points.
+
+On the modeling side, the GP is parameterized using a Matérn- $5 / 2$ kernel with ARD and a constant mean function for all experiments. The GP hyperparameters are fitted before proposing a new batch by optimizing the log-marginal likelihood. The domain is rescaled to $[ 0 , 1 ] ^ { d }$ and the function values are standardized before fitting the GP regression. We use a Matérn- ${ \cdot 5 / 2 }$ kernel with ARD for CorrAttack and use the following bounds for the hyperparameters: (length scale) $\lambda _ { i } \in [ 0 . 0 0 5 , 2 . 0 ]$ (output scale) $\lambda _ { i } ^ { \prime } \in [ 0 . 0 5 , 2 0 . 0 ]$ , (noise variance) $\sigma ^ { \tilde { 2 } } \stackrel { . } { \in } [ \stackrel { . } { 0 } . 0 0 0 5 , 0 . 1 \stackrel { . } { }$ ].
+
+# B.2 HYPERPARAMETERS
+
+For CorrAttack in Algorithm 4 and Algorithm 5, we set the initial block size $b$ to be 32 and the step size $\eta$ for CorrAttackDiff is 0.03. In Algorithm 1, we use the initial sampling ratio $m = 0 . 0 3 n$ at the start point for Gaussian process regression, the threshold $c = 1 0 ^ { - 4 }$ to decide when to stop the search of current block size. In Algorithm 2, the threshold is different for different block size. For CorrAttackFlip, $\alpha = 1 , 1 , 2 , 2 , 3$ for block size 32, 16, 8, 4, 2 and for CorrAttackDiff, $\alpha = 0 , 0 , 1 , 1 , 2$ for block size 32, 16, 8, 4, 2. We set $\tau = 3 m = 0 . 0 9 n$ to remove the earliest samples from $D$ once $| D | > \alpha$ . The Adam optimizer is used to optimize the mean $\mu$ and covariance $\kappa$ of Gaussian process, where the iteration is 1 and the learning rate is 0.1.
+
+For PARSI, the block size is set to 32 as CorrAttack , other hyperparameters are the same as the original paper.
+
+For Bandits, Bayes-Attack and BayesOpt, the hyperparameters are the same as the original paper.
+
+We optimize the hyperparameters for ZOO, NES. For un-targeted attack on NES, we set the sample size to be 50, learning rate to be 0.1. For targeted attack on NES, the sample size is also 50 and the learning rate is 0.05. The learning is decay by $50 \%$ if the loss doesn’t decrease for 20 iterations.
+
+For NAttack, we set the hyperparameters the same as NES and add momentum and learning rate decay, which are not mentioned in the original paper.
+
+For ZOO, we set the learning rate to 1.0 and sample size to be 50. Other setting follows the original paper.
+
+# C ADDITIONAL EXPERIMENTS
+
+# C.1 OPTIMALITY OF BAYESIAN OPTIMIZATION
+
+Figure 3 shows the reward function that the Bayesian optimization could find in the action set. CorrAttack could find the action with high reward within just a few queries. It shows that the Gaussian process regression could model the correlation of the reward function and the Bayesian optimization could use it to optimize the time-varying contextual bandits.
+
+# C.2 VARYING THE ADVERSARIAL BUDGET
+
+We test CorrAttack on different adversarial budget on ImageNet for both un-targeted attack and targeted attack. Table 5 and Table 6 show the success rate and average queries for $\varepsilon = 0 . 0 4 , 0 . 0 5 , 0 . 0 6$ CorrAttackFlip achieves the best performance among all methods.
+
+![](images/48ebc11c9c65c775e9c8f2c15879126a79155b58338ea44787dddae44a92d84b.jpg)  
+Figure 3: The rank of the reward function that the Bayesian optimization could find in the action set for different block size. The rank and query are normalized by the cardinality of the action set.
+
+Table 5: Success rate and average queries of un-targeted attack on different $\varepsilon$ . Query limit is 10000   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">ε = 0.04</td><td colspan="2">ε= 0.05</td><td colspan="2">ε= 0.06</td></tr><tr><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>Z00</td><td>63.28%</td><td>1915</td><td>63.68%</td><td>1794</td><td>64.88%</td><td>1507</td></tr><tr><td>NES</td><td>99.06%</td><td>1230</td><td>99.19%</td><td>1178</td><td>99.19%</td><td>1160</td></tr><tr><td>NAttack</td><td>99.73%</td><td>529</td><td>99.73%</td><td>401</td><td>99.73%</td><td>369</td></tr><tr><td>Bandits</td><td>95.86%</td><td>898</td><td>96.92%</td><td>694</td><td>97.06%</td><td>567</td></tr><tr><td>PARSI</td><td>99.73%</td><td>508</td><td>99.73%</td><td>432</td><td>100%</td><td>387</td></tr><tr><td>CorrAttackDiff</td><td>99.86%</td><td>479</td><td>99.86%</td><td>419</td><td>99.78%</td><td>373</td></tr><tr><td>CorrAttackFlip</td><td>100%</td><td>203</td><td>100%</td><td>150</td><td>100%</td><td>107</td></tr></table>
+
+Table 6: Success rate and average queries of targeted attack on different $\varepsilon$ . Query limit is 10000   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">ε=0.04</td><td colspan="2">ε=0.05</td><td colspan="2">ε = 0.06</td></tr><tr><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>ZOO</td><td>0.80%</td><td>3514</td><td>0.80%</td><td>3018</td><td>0.93%</td><td>1938</td></tr><tr><td>NES</td><td>49.13%</td><td>5901</td><td>52.73%</td><td>5762</td><td>56.48%</td><td>5884</td></tr><tr><td>NAttack</td><td>78.24%</td><td>5019</td><td>89.05%</td><td>3799</td><td>90.25%</td><td>4321</td></tr><tr><td>Bandits</td><td>31.78%</td><td>5721</td><td>40.19%</td><td>5672</td><td>43.39%</td><td>5609</td></tr><tr><td>PARSI</td><td>57.00%</td><td>3599</td><td>64.88%</td><td>3403</td><td>68.75%</td><td>3250</td></tr><tr><td>CorrAttackDiff</td><td>78.70%</td><td>4472</td><td>81.84%</td><td>4064</td><td>85.31%</td><td>3837</td></tr><tr><td>CorrAttackFlip</td><td>93.44%</td><td>2689</td><td>96.39 %</td><td>2531</td><td>97.50%</td><td>2194</td></tr></table>
+
+# C.3 ABLATION STUDY ON RANDOM CHOICES
+
+Table 7 and Table 8 show the ablation study on the strategy to choose action $x _ { t + 1 }$ in the line 6 of Algorithm 1. The process of Bayesian optimization helps to accelerate the optimization. As targeted attack is more complicated and requires larger number of queries, CorrAttack has more advantage in this scenario.
+
+# C.4 ABLATION STUDY ON HIERARCHICAL ATTACK
+
+We perform un-targeted attack on Resnet50 as shown in Table 10. Hierarchical attack lowers the average queries and improves the query efficiency. Besides, hierarchical attack avoids the problem of choosing block size. As shown in Table 10, block size for non-hierarchical is essential for the performance.
+
+# C.5 ABLATION STUDY ON FEATURES
+
+Table 11 shows the success rate and average queries for CorrAttackwith different features. We perform ablation study on the features of the contextual bandits. One contains just the location of the
+
+Table 7: Ablation study on random choices with success rate and average queries of un-targeted attack on ImageNet. $\varepsilon = 0 . 0 5$ and query limit is 10000   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">VGG16</td><td colspan="2">Resnet50</td><td colspan="2">Densenet121</td></tr><tr><td>Success</td><td>Queries</td><td> Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>CorrAttackDiff Random</td><td>100%</td><td>456</td><td>99.86%</td><td>491</td><td>100%</td><td>375</td></tr><tr><td>CorrAttackDiff Bayes</td><td>100%</td><td>389</td><td>99.86%</td><td>419</td><td>100%</td><td>334</td></tr><tr><td>CorrAttackFlip Random</td><td>100%</td><td>143</td><td>100%</td><td>176</td><td>100%</td><td>132</td></tr><tr><td>CorrAttackFlip Baye s</td><td>100%</td><td>130</td><td>100%</td><td>150</td><td>100%</td><td>113</td></tr></table>
+
+Table 8: Ablation study on random choices with success rate and average queries of targeted attack on ImageNet. $\varepsilon = 0 . 0 5$ and query limit is 10000   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">VGG16</td><td colspan="2">Resnet50</td><td colspan="2">Densenet121</td></tr><tr><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>CorrAttackDiff Random</td><td>83.72%</td><td>4388</td><td>74.76%</td><td>4644</td><td>85.30%</td><td>4113</td></tr><tr><td>CorrAttackDiff Bayes</td><td>88.41%</td><td>3826</td><td>81.84%</td><td>4064</td><td>91.29 %</td><td>3513</td></tr><tr><td>CorrAttackFlip Random</td><td>96.42%</td><td>2545</td><td>92.92%</td><td>3066</td><td>96.87%</td><td>2556</td></tr><tr><td>CorrAttackFlip Baye s</td><td>98.07%</td><td>2191</td><td>96.39%</td><td>2531</td><td>99.41%</td><td>2019</td></tr></table>
+
+Table 9: Ablation study on random choices with success rate and average queries of un-targeted attack on defended model ImageNet. $\varepsilon = 0 . 0 5$ and query limit is 10000   
+
+<table><tr><td>Method</td><td>CorrAttackDif Random</td><td>CorrAttackDiff Bayes</td><td>CorrAttackFlip Random</td><td>CorrAttackFlip Bayes</td></tr><tr><td>Success</td><td>57.47%</td><td>64.86%</td><td>71.42%</td><td>79.15%</td></tr><tr><td>Queries</td><td>1645</td><td>1599</td><td>1159</td><td>1036</td></tr></table>
+
+Table 10: Success rate and average queries of un-targeted attack on Resnet50 for Hierarchical Strategy.   
+
+<table><tr><td>Method</td><td>Fixed Size 4</td><td>Fixed Size 8</td><td>Fixed Size 16</td><td>Fixed Size 32</td><td>Hierarchical</td></tr><tr><td>Success</td><td>100%</td><td>100.0%</td><td>99.47%</td><td>89.32%</td><td>100%</td></tr><tr><td>Queries</td><td>763</td><td>351</td><td>168</td><td>96</td><td>150</td></tr></table>
+
+block and the other contains both the location and the PCA feature. PCA helps the learning process of the reward and achieve higher success rate and lower number of queries. PCA feature achieves significant improvement on CorrAttack $\mathrm { F l i p }$ . We may find more useful features in the future.
+
+# C.6 COMPARISON BETWEEN CORRATTACKFLIP, BAYESOPT AND BAYES-ATTACK
+
+The main difference between BayesOpt and Bayes-Attack is using different types of GP regression (Standard GP for Bayes-Attack and Additive GP for BayesOpt), so we will consider these two models as a group when comparing with our model CorrAttack.
+
+Difference between CorrAttack, BayesOpt and Bayes-Attack: For $l _ { \infty }$ attacks, assume there are no hierarchical structure, we have blocks $E = \left\{ e _ { 0 0 0 } , e _ { 0 0 1 } , \cdot \cdot \cdot , e _ { h w c } \right\}$ , where the block is $b \times b$ square of pixels and $( h , w , c ) = ( \mathrm { h e i g h t } / b$ , width/ $b$ , channel). CorrAttack, BayesOpt (Ru et al., 2020) and k (Shuwhere ) all try to search the adv, the perturbation of block rial noise oat time t is $E$ with perturbation. $\pmb { \delta } \in [ - \epsilon , \epsilon ] ^ { d }$ $d = h \times w \times c$ $e _ { i j k }$ $\delta _ { e _ { i j k } } ^ { t }$
+
+BayesOpt and Bayes-Attack use a GP regression directly on $\pmb { \delta } \in [ - \epsilon , \epsilon ] ^ { d }$ (all blocks),
+
+$$
+f ( \delta ) | \mathcal { D } _ { n } \sim \mathrm { N o r m a l } ( \mu _ { n } ( \delta ) , \sigma _ { n } ^ { 2 } ( \delta ) ) .
+$$
+
+CorrAttack define an action space $A$ and use a standard GP regression on features $z _ { e _ { i j k } } = ( i , j , k , p c a )$ (single block),
+
+$$
+g _ { t } \big ( a _ { e _ { i j k } } \big ) | \mathcal { D } _ { t } \sim \operatorname { N o r m a l } ( \mu _ { t } \big ( z _ { e _ { i j k } } \big ) , \sigma _ { t } ^ { 2 } \big ( z _ { e _ { i j k } } \big ) \big ) .
+$$
+
+Table 11: Ablation study on features with success rate and average queries of targeted attack on ImageNet. $\varepsilon ~ = ~ 0 . 0 5$ and query limit is 10000. We use feature $\bar { z } _ { e _ { i j k } } ~ = ~ ( i , \bar { j } , k , p c a )$ for CorrAttackDiffw pca and CorrAttackFlipw $p c a$ , use $z _ { e _ { i j k } } ~ = ~ ( i , j , k )$ for CorrAttackDiffw/o pca and CorrAttackFlipw/o pca.   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">VGG16</td><td colspan="2">Resnet50</td><td colspan="2">Densenet121</td></tr><tr><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>CorrAttackDiffw /o pca</td><td>88.69%</td><td>3892</td><td>81.71%</td><td>4066</td><td>90.88%</td><td>3540</td></tr><tr><td>CorrAttackDiffw pca</td><td>88.41%</td><td>3826</td><td>81.84%</td><td>4064</td><td>91.29%</td><td>3513</td></tr><tr><td>CorrAttackFlipw /o pca</td><td>98.11%</td><td>2233</td><td>95.86%</td><td>2682</td><td>98.10%</td><td>2195</td></tr><tr><td>CorrAttackFlipw pca</td><td>98.07%</td><td>2191</td><td>96.39%</td><td>2531</td><td>99.41%</td><td>2019</td></tr></table>
+
+At each iteration, in BayesOpt and Bayes-Attack, the changes of overall perturbation is
+
+$$
+\begin{array} { r } { \delta _ { t } - \delta _ { t - 1 } = \{ \delta _ { e _ { 0 0 0 } } ^ { t } \cup \delta _ { e _ { 0 0 1 } } ^ { t } \cup \cdot \cdot \cdot \cup \delta _ { e _ { h w c } } ^ { t } \} - \{ \delta _ { e _ { 0 0 0 } } ^ { t - 1 } \cup \delta _ { e _ { 0 0 1 } } ^ { t - 1 } \cup \cdot \cdot \cdot \cup \delta _ { e _ { h w c } } ^ { t - 1 } \} . } \end{array}
+$$
+
+However, in CorrAttack,
+
+$$
+\delta _ { t } - \delta _ { t - 1 } = \delta _ { e _ { i j k } } ^ { t } - \delta _ { e _ { i j k } } ^ { t - 1 } .
+$$
+
+In conclusion, BayesOpt and Bayes-Attack view each block as a dimension, try to search the overall perturbation directly. CorrAttack defines a low dimension feature space, keep an overall perturbation and try to search an action on single block.
+
+Time complexity and running time: The time complexity of fitting GP regression is $O ( d n ^ { 2 } )$ where $d$ is the dimension of input and $n$ is the number of samples. And the dimension for CorrAttack $Q = 4$ for $z _ { e _ { i j k } } = ( i , j , k , p c a ) )$ is much smaller than BayesOpt and Bayes-Attack ( $d = 6 9 1 2$ if $h = w = 4 8 , c = 3 )$ . Moreover, we can convert the continuous search space of BayesOpt and Bayes-Attack from $[ - \epsilon , \epsilon ] ^ { 6 9 1 2 }$ to discrete search space $E = \left\{ e _ { 0 0 0 } , e _ { 0 0 1 } , \cdot \cdot \cdot , e _ { h w c } \right\}$ , whose number is only 6912, smaller search space could save the computation time of acquisition function.
+
+We compare the running time for CorrAttackFlip with BayesOpt and Bayes-Attack on 20 images from ImageNet. Table 12 shows the running time for the un-targeted attack. We use PyTorch2 to develop these two models. All experiments were conducted on a personal workstation with 28 Intel(R) Xeon(R) Gold 5120 2.20GHz CPUs, an NVIDIA GeForce RTX2080Ti 11GB GPU and 252G memory.
+
+BayesOpt models the loss function with a very high dimensional Gaussian process. The decomposition of additive kernel also needs to be restarted several times. Even though we try to optimize the speed of BayesOpt with GPU acceleration, it is still very slow and takes hundreds of times more computational resources than CorrAttack .
+
+Bayes-Attack could be regarded as a simpler version of BayesOpt, which does not add additive kernel. We do not evaluate it on targeted task (when query>1000) since GP inference time grows fast as evaluated query increases, e.g. For Bayes-Attack, when 150 <query $< 2 0 0$ , Time $= 1 . 6 s$ /query; $8 0 0 < \mathrm { q u e r y < 1 0 0 0 }$ , Time $= 1 0 . 5 s ,$ /query. CorrAttack solves this problem with Time ${ = } 0 . 1 s$ /query even when query reaches 10000. Since we forget the previous samples before $t - \tau$ , our input sample $n$ will be smaller than $\tau$ . The forgetting technique can not be applied into the Bayes-Attack and BayesOpt since they are searching the perturbation of all blocks so each sample needs to be remembered.
+
+# C.7 GROWING CURVE OF SUCCESS RATE
+
+The number of average queries is sometimes misleading due to the the heavy tail distribution of queries. Therefore in Figure 4, we plot the success rates at different query levels to show the detailed behaviors of different attacks. It shows that CorrAttack is much more efficient than other methods at all query levels.
+
+Table 12: Comparsion of running time between CorrAttackFlipand BayesOpt on un-targeted attack. "Per Query" means the average time needed to perform one query to the loss-oracle and "Per Image" denotes the average time to successfully attack an image. Since BayesOpt needs thousands of hours to run all samples, we only tested on 20 samples from ImageNet, which will be marked as \*.   
+
+<table><tr><td rowspan="2">Time</td><td colspan="2">VGG16</td><td colspan="2">Resnet50</td><td colspan="2">Densenet121</td></tr><tr><td>Per Query</td><td>Per Image</td><td>Per Query</td><td>Per Image</td><td>Per Query</td><td>Per Image</td></tr><tr><td>BayesOpt*</td><td>28.94s</td><td>5268s</td><td>40.53s</td><td>8673s</td><td>39.57s</td><td>8825s</td></tr><tr><td>Bayes-Attack*</td><td>3.03s</td><td>739s</td><td>3.42s</td><td>869s</td><td>2.96s</td><td>630s</td></tr><tr><td>CorrAttackFlip*</td><td>0.12s</td><td>19s</td><td>0.11s</td><td>15s</td><td>0.15s</td><td>20s</td></tr></table>
+
+![](images/45b1c002ab7780cdef98a0cf4ae60f2109bdab4f3ce05e6cd9058d22c253feb4.jpg)  
+Figure 4: Success rate of black-box attack at different query levels for undefended ImageNet models.
+
+C.8 VISUALIZATION OF LOCAL PROPERTY AND SLOW VARYING PROPERTY
+
+Figure 5 shows more examples of finite difference for different network architectures and different dataset. They all have local correlation structure as shown in Figure 1. And Figure 6 shows more examples like Figure 2, the slow varying properties exist for different architectures and different datasets.
+
+# C.9 GOOGLE CLOUD VISION API
+
+Figure 7 shows the example of attacking the Google Cloud Vision API. CorrAttackFlip and PARSI successfully change the classification result. BeyesOpt, however, can not remove the top 1 classification result out of the output.
+
+![](images/f8bba458b58e78d3c9f58d04194ff2f85d79eddc79e3c8087a4de6d12813ad40.jpg)  
+Figure 5: Finite difference of perturbation like Figure 1. $h = w = 2 8$ . For Imagenet, $b = 8$ and $\eta = 0 . 0 5$ . For MNIST, $b = 1$ and $\eta = 0 . 2$
+
+![](images/3266e853dfec2e662e6c750a59d9d17e2fe577c7acec4321702c652fad866d6a.jpg)  
+Figure 6: Difference of finite difference of perturbation like Figure 2. $h = w = 2 8$ . For Imagenet, $b = 8$ and $\eta = 0 . 0 5$ . For MNIST, $b = 1$ and $\eta = 0 . 2$
+
+![](images/79e5cae0b3d4c448beb199980e19dab35ee876060d5ac924128507010836457d.jpg)  
+Figure 7: Example result of attacking Google Cloud Vision API
+
+![](images/d16ca93ba30e83550a74d15dc3b136612991f89d8ce8e4c66695b0cd927fe30b.jpg)  
+Figure 8: Visualization of adversarial examples for targeted attack on Densenet121. $\varepsilon = 0 . 0 5$

parse/train/rkmtTJZCb/rkmtTJZCb.md

@@ -0,0 +1,314 @@
+# UNSUPERVISED HIERARCHICAL VIDEO PREDICTION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Much recent research has been devoted to video prediction and generation, yet a lot of previous work has been focused on short-scale time horizons. The hierarchical video prediction method by Villegas et al. (2017) is an example of a state of the art method for long term video prediction. However, their method has limited applicability in practical settings as it requires a ground truth pose (e.g., poses of joints of a human) at training time. This paper presents a long term hierarchical video prediction model that does not have such a restriction. We show that the network learns its own higher level structure (e.g., pose-equivalent hidden variables) that works better in cases where the ground truth pose does not fully capture all of the information needed to predict the next frame. This method gives sharper results than other video prediction methods which do not require a ground truth pose, and its efficiency is shown on the Humans 3.6M and Robot Pushing datasets.
+
+# 1 INTRODUCTION
+
+It is hypothesized that learning to predict the future and the effect of their actions is an important quality for intelligent agents that interact with their environment. This is a complicated task, as typical use cases require predicting the outcome of interactions between the agent and objects over multiple timesteps.
+
+In this work we are looking at the task of predicting the pixels of future video frames given the first few observed frames. We also consider the action conditional setting, in which we are given the action that the agent is taking and are tasked to predict the pixel level outcome of that action in the future.
+
+The method of Villegas et al. (2017) is a novel way to generate long term video predictions, but requires ground truth human pose annotations. In this work we explore ways to generate videos using a hierarchical model without requiring a ground truth pose or other high level structure annotations for each frame. The method is hierarchical in the sense that it learns to generate a high level structure, then makes next frame predictions based on that structure.
+
+# 2 RELATED WORK
+
+Patch level prediction The video prediction problem was initially studied at the patch level (Sutskever et al., 2009; Michalski et al., 2014; Mittelman et al., 2014; Srivastava et al., 2015). This work showed promising results on synthetic data (e.g. bouncing balls), but did not scale to predicting higher resolution videos.
+
+Frame level prediction on realistic videos. More recently, the video prediction problem has been formulated at the entire frame level. Most of the recent work is based on the convolutional encoder/decoder framework. Finn et al. (2016) proposed a network that can perform next level video frame prediction by explicitly predicting movement. For each pixel in the previous frame, the network outputs a distribution over locations that pixel is predicted to move. The movements are averaged to get the final prediction. The network is trained end to end to minimize L2 loss. Mathieu et al. (2016) proposed adversarial training with multiscale convolutional networks to generate sharper pixel level predictions in comparison to conventional L2 loss. Villegas et al. (2017) proposed a network that decomposes motion and content in video prediction and showed improved performance over Mathieu et al. (2016). Lotter et al. (2017) proposed a deep predictive coding network in which each layer learns to predict the lower-level difference between the future frame and current frame. As an alternative approach to convolutional encoder/decoder networks, Kalchbrenner et al. (2016) proposed an autoregressive generation scheme for improved prediction performance. Despite their promise, these work have not been demonstrated for long term prediction on high resolution natural videos beyond $\approx 2 0$ frames.
+
+Long-term prediction. Oh et al. (2015) proposed action conditional convolutional encoderdecoder architecture that has demonstrated impressive long-term prediction performance on video games (e.g., Atari games), but it has not been applied for predicting challenging real-world videos.
+
+# 2.1 HIERARCHICAL VIDEO PREDICTION (VILLEGAS ET AL., 2017)
+
+Villegas et al. (2017) demonstrated a long-term prediction method using hierarchical prediction where the ground truth human pose is assumed to be given as supervision. Our method is based off of that work, so we describe it in detail in the following section.
+
+# 2.1.1 INFERENCE AND ARCHITECTURE
+
+To generate the image at timestep $t$ , the following procedure is used. First, a convolutional neural network encoder generates an embedding vector from the previous ground truth image: $e _ { t - 1 } =$ $C N N ( i m g _ { t - 1 } )$ . This encoding represents the pose of a person.
+
+Next, a multilayer LSTM predictor network predicts what the encoding will be in a future timestep. For some number of context frames, the predictor makes its prediction based off of the encoding from the ground truth image. After the predictor network has enough context, it makes its predictions based off of its previous predictions (Fig. 1 provides a helpful visual). For example, if there are $\textrm { C }$ context frames, the following is used to generate the encoding at step $t$ .
+
+$$
+\begin{array} { r } { \left\{ \left[ p _ { t } , H _ { t } \right] = L S T M ( e _ { t - 1 } , H _ { t - 1 } ) \quad i f t < = C \right. } \\ { \left[ p _ { t } , H _ { t } \right] = L S T M ( p _ { t - 1 } , H _ { t - 1 } ) \quad i f t > C } \end{array}
+$$
+
+$H _ { t }$ is the hidden state of the LSTM at timestep $t$ . Note that only the encoding of the context frames are used, not the subsequent frames. Similar to $e _ { t }$ in the above, $p _ { t }$ represents the predicted pose.
+
+Once $p _ { t }$ is obtained, a visual analogy network (VAN) (Reed et al., 2015) is used to generate the corresponding image at time $t$ . The VAN applies the transformation that occurred between two images to a given query image. In this case the first frame of the video should be transformed in the same way as the encoding was transformed from the first to $t$ -th timestep. The VAN does this by mapping images to a space where analogies can be represented by additions and subtractions, and then mapping the result back to image space. To obtain the predicted image at timestep $t$ using the VAN one needs to use $\widehat { i m g } _ { t } = V A \bar { N } ( e _ { 1 } , p _ { t } , i m g _ { 1 } )$ , where the VAN is defined as
+
+$$
+V A N ( e _ { 1 } , p _ { t } , i m g _ { 1 } ) = f _ { d e c } ( f _ { e n c } ( g ( p _ { t } ) ) - f _ { e n c } ( g ( e _ { 1 } ) ) + f _ { i m g } ( i m g _ { 1 } ) )
+$$
+
+Where $g$ is a hardcoded function to transform the pose into a 2 dimensional representation of the pose. The weights of $f _ { e n c }$ and $f _ { i m g }$ are shared.
+
+# 2.1.2 TRAINING
+
+The disadvantage of this method is that the training relies on ground truth pose annotations. The encoder is trained to produce the pose given the image, the predictor is trained to predict that pose into the future and the VAN is trained to generate the image given the pose.
+
+# 3 PROPOSED METHOD
+
+Our method uses a similar network architecture to Villegas et al. (2017) but we present ways of training the network that do not require a ground truth pose. In our method, $e _ { t }$ and $p _ { t }$ have the same dimensionality and represent the network’s own higher level structure (e.g., pose equivalent hidden variables) which the network learns as it is trained.
+
+In our case, there is no straightforward way to transform the encoding into a 2 dimensional representation of the pose. Therefore, the part of the VAN that maps the encoding is a fully connected network instead of a convolutional neural network. As a result, the weights are not shared between the fully connected network which processes the encoding, and the ConvNet which processes the image.
+
+The equation for the VAN becomes:
+
+$$
+V A N ( e _ { 1 } , p _ { t } , i m g _ { 1 } ) = f _ { d e c } ( f _ { e n c } ( p _ { t } ) - f _ { e n c } ( e _ { 1 } ) + f _ { i m g } ( i m g _ { 1 } ) )
+$$
+
+Note that $f _ { e n c }$ is a fully connected network, and $f _ { i m g }$ is a conv net. $f _ { d e c }$ is a deconv network.
+
+# 3.1 TRAINING
+
+There are several ways these networks can be trained. In Villegas et al. (2017), they are each trained separately with the ground truth human pose. In this work, we explore alternative ways of training these networks in the absence of any ground truth pose or other high level structure annotations. We use the same procedure as Villegas et al. (2017) at inference time.
+
+# 3.1.1 END TO END
+
+One option is to connect the networks the same way as in inference time and train them end to end (E2E). In this method, the L2 loss of of the predicted image is optimized: $\begin{array} { r } { \operatorname* { m i n } ( \sum _ { t = 1 } ^ { T } L _ { 2 } ( \widehat { i m g } _ { t } , i m g _ { t } ) ) } \end{array}$ .
+
+There are no constraints on what kind of encoding the encoder produces, or what kind of predictions the predictor makes. Because of how the networks are connected, the encoder will produce an encoding whose future state is easily predicted by the predictor. Likewise, the predictor will make predictions which the VAN can use to produce images which are similar to the ground truth. The encoder and predictor will not have to represent information that is present in the first ground truth frame, since the VAN will have access to the first frame. The size of $e _ { t }$ and $p _ { t }$ is a hyper parameter of this approach. Figure 1 represents a diagram of this method.
+
+![](images/05fbe57307c09b6410f38782fe038ae2033494d97f2ecb73a895d1046c248c04.jpg)  
+Figure 1: The E2E method. The first few frames are encoded and fed into the predictor as context. The predictor predicts the subsequent encodings, which the VAN uses to produce the pixel level predictions. The average of the losses is minimized. This is also the configuration of every method at inference time, even if the predictor and VAN are trained separately.
+
+# 3.1.2 ENCODER PREDICTOR WITH ENCODER VAN
+
+An alternative way to train the combined network is to explicitly train the encoder so that $e _ { t }$ is easy to predict into the future, and so that the VAN can use $e _ { t }$ to produce the next frame. We call this method Encoder Predictor with Encoder VAN, or EPEV. The encoder and predictor are trained together so the $e _ { t }$ is easy to predict and the predictor predicts that encoding into the future. To accomplish this, the difference between $e _ { t }$ and $p _ { t }$ , $L _ { 2 } ( \boldsymbol { e } _ { t } , \boldsymbol { p } _ { t } )$ is minimized. The encoder is also trained with the VAN so the VAN can use $e _ { t }$ to produce the image and so that the encoder generates an informative encoding. This is done by minimizing the loss of the VAN given the encoder output: $L _ { 2 } ( \widehat { i m g } _ { e _ { t } } , i m g _ { t } )$ where $\widehat { i m g } _ { e _ { t } } = V A N ( e _ { 1 } , e _ { t } , i m g _ { 1 } )$ . The network is trained to minimize the sum of these two losses: $\begin{array} { r } { \operatorname* { m i n } ( \sum _ { t = 1 } ^ { T } L _ { 2 } ( \widehat { i m g } _ { e _ { t } } , i m g _ { t } ) + \alpha L _ { 2 } ( e _ { t } , p _ { t } ) ) } \end{array}$ , where $\alpha$ is a hyper-parameter that controls the degree to which the $e _ { t }$ will be easy to predict vs. informative enough so the VAN can produce a good image.
+
+See figure 2 for a diagram of the encoder and predictor trained together, and figure 3 for the encoder and VAN trained together.
+
+![](images/ad8b9c0e7c083528e83426eef847cc3a04a705c7dfed0b8db9f6ac26b31b9434.jpg)  
+Figure 2: The segment of the EPEV method in which the encoder and predictor are trained together. The encoder is trained to produce an encoding that is easy to predict, and the predictor is trained to predict that encoding into the future. The average of the losses is minimized.
+
+![](images/8b431a06125a4c52bc439f217847a3f4e3d5b00ec8635c4b9e45b164957506ab.jpg)  
+Figure 3: The segment of the EPEV method in which the encoder and VAN are trained together. The encoder is trained to produce an encoding that is informative to the VAN, while the VAN is trained to output the image given the encoding. The average of the losses is minimized. This method is similar to an autoencoder.
+
+Separate gradient descent procedures (or optimizers, in TensorFlow parlance) could be used to minimize $L _ { 2 } ( \widehat { i m g } _ { e _ { t } } , i m g _ { t } )$ and $L _ { 2 } ( e _ { t } , p _ { t } )$ , but we find that minimizing the sum works better experimentally.
+
+With this method, the predictor will predict the encoder outputs in future timesteps, and the VAN will use the encoder output to produce the frame.
+
+# 3.1.3 E2E WITH POSE
+
+The end to end approach can also be augmented if the dataset has information about the ground truth pose or any other high level frame annotations. In this method, the $e _ { t }$ and $p _ { t }$ vectors would be split into two: the first path is optimized to represent the pose, and the rest of $e _ { t }$ and $p _ { t }$ is trained the same way as the E2E approach. At each training step a separate optimizer minimizes each loss. In this method, we can think of $e _ { t }$ and $p _ { t }$ as the concatenation of two vectors, one representing the pose, and the other containing additional information the network can represent. If $\boldsymbol { e _ { t } } ^ { \top } = [ e _ { p o s e _ { t } } , e _ { r e m a i n i n g _ { t } } ]$ and $p _ { t } = [ p _ { p o s e _ { t } } , p _ { r e m a i n i n g _ { t } } ]$ , the following losses are minimized:
+
+The loss representing how well the encoder infers the pose: $\begin{array} { r } { \operatorname* { m i n } ( \sum _ { t = 1 } ^ { T } L _ { 2 } ( e _ { p o s e _ { t } } , p o s e _ { t } ) ) } \end{array}$ . The loss representing how well the predictor predicts the pose: $\begin{array} { r } { \operatorname* { m i n } ( \sum _ { t = 1 } ^ { T } L _ { 2 } ( p _ { p o s e _ { t } } , p o s e _ { t } ) ) } \end{array}$ . The end to end loss: $\begin{array} { r } { \operatorname* { m i n } ( \sum _ { t = 1 } ^ { T } L _ { 2 } ( \widehat { i m g } _ { t } , i m g _ { t } ) ) } \end{array}$ .
+
+These losses are minimized with separate optimizers in this method. Minimizing the end to end loss ensures that the VAN will learn to use the pose provided by the predictor network, and that the encoder and predictor will learn to produce additional information besides the pose that is useful to the VAN.
+
+# 3.1.4 INDIVIDUAL
+
+In order to compare to a baseline, we also implemented the method where each of the networks are trained individually, as in Villegas et al. (2017). The main difference between this method and Villegas et al. (2017) is that we do not use an adversarial loss (Goodfellow et al., 2014). See section 5 for a discussion of how an adversarial loss could be added to our method.
+
+# 4 EXPERIMENTS
+
+These methods were tested on two different datasets, the Robot Push dataset (Finn et al., 2016) and the Humans 3.6M dataset (Ionescu et al., 2014; Catalin Ionescu, 2011). Videos of the results of our method are available by visiting the following URL: https://goo.gl/WA8uxc.
+
+The EPEV method works best experimentally if $\alpha$ starts small, around 1e-7, and is gradually increased to around .1 during training. As a result, the encoder will first be optimized to produce an informative encoding, then gradually optimized to also make that encoding easy to predict.
+
+# 4.1 ROBOT PUSH DATASET
+
+This dataset contains videos of a robot arm pushing objects on a table. The current joint angles and the location of the end effector are given, and we use these as the pose for the methods which require it. The action the robot arm is taking is fed into the predictor.
+
+Each of the methods considered was given two frames of context, and then trained to predict 17 subsequent frames. An encoding size of 16 was used for the E2E method. The size of the pose is 12, so the encoding size of the INDIVIDUAL method is 12. The other methods used an encoding size of 32.
+
+Additionaly, we randomly split the dataset into training, validation and test. We used 64x64 images, and the same frame rate as the original dataset. Results from our test set are shown in this section. Note that our experimental protocol is different from Finn et al. (2016), where the test set is composed of novel objects.
+
+We hypothesized that the methods where the network could learn its own pose equivalent would predict the movement of the objects the robot arm pushes more accurately than the INDIVIDUAL method. To test this, we manually compared the E2E and EPEV methods to the INDIVIDUAL method and evaluated where the movement of predicted objects most closely matched the ground truth. We evaluated 40 videos in which objects move. The results are in Table 1.
+
+Table 1: Results from manual comparison of object predictions in 40 videos. The methods perform similarly in the remaining videos.
+
+<table><tr><td>Comparison</td><td>Numberofvideos</td></tr><tr><td></td><td></td></tr><tr><td>EPEVbetter than INDIVIDUAL</td><td>6</td></tr><tr><td>INDIVIDUALbetter thanEPEV</td><td>3</td></tr><tr><td>E2Ebetter than INDIVIDUAL</td><td>6</td></tr><tr><td>INDIVIDUAL better than E2E</td><td>6</td></tr></table>
+
+In the INDIVIDUAL method, the predictor network can only produce the pose, so the VAN has to infer how the objects will move based on the start and end state of the arm. We were surprised by how well the VAN could infer this. However, from examining the videos, the EPEV method had better object predictions than the INDIVIDUAL method, which supports our hypothesis. The magnified part of ground truth frame 19 in figure 4 shows that the robot arm pushed the yellow object. The EPEV and E2E methods correctly predict this, but in the INDIVIDUAL method, the robot arm covers up the yellow object instead of moving it. Additional analysis is in appendix section F.
+
+![](images/3be0f5512e34fea098d94f20ebb50f50db916ed6fe4929df111d9a9102431678.jpg)  
+Figure 4: A visual comparison of the different methods on the robot push dataset. In the E2E and EPEV methods, the yellow object moves, but it does not in the INDIVIDUAL method.
+
+The average Peak Signal to Noise Ratio (PSNR) of the different methods we introduce are similar on this dataset. In this data set, the model from Finn et al. (2016) gets a better PSNR than our model. The movement in this dataset can easily be represented by the movement of pixels, and it is relatively deterministic. So the model from Finn et al. (2016) which explicitly predicts the movement of objects and directly minimizes the L2 loss works well here.
+
+# 4.2 LONG TERM PREDICTION ON A TOY DATASET
+
+To confirm our claim that our method works well for long term predictions, we trained our method on a toy task with known factors of variation. We used a dataset with a generated shape that bounces around the image and changes size deterministically. We trained the EPEV method and the CDNA method in Finn et al. (2016) to predict 16 frames, given the first 3 frames as context. We do not show the E2E method since it usually predicts blurrier images than the EPEV method. Both methods are evaluated on predicting approximately 1k frames. We added noise to the LSTM states of the predictor network during training to help predict reasonable motion further into the future. Results form a held out test set are described in the following.
+
+After visually inspecting the results of both methods, we found that when the CDNA fails, the shape disappears entirely, however when the EPEV method fails, the shape changes color. To quantitatively evaluate both methods, we used a script to measure whether a shape was present frames 1012 to 1022, and if that shape has the appropriate color. See table 2 for the results averaged over 1k runs. The CDNA method predicts a shape with the correct color about $2 5 \%$ of the time, and the EPEV method predicts a shape with the correct color about $9 7 \%$ of the time. The EPEV method sometimes fails by predicting the shape in the same location from frame to frame. This does not happen very often, as the reader can confirm by examining the randomly sampled predictions in appendix section E. It is unrealistic to expect the methods to predict the location of the shape accurately in frame 1000, since small errors propagate in each prediction step.
+
+![](images/861769e6d188899e4304167b540d3e4e694180dee9cada22f2d46f8d8ce45d97.jpg)  
+Figure 5: A visual comparison of the EPEV method and CDNA from Finn et al. (2016) as the baseline. This example is cherry picked to show the typical quality of predictions from both methods. See appendix section E for non-cherry picked results.
+
+Table 2: Results on shapes dataset   
+
+<table><tr><td>Method</td><td>Shape has correct color</td><td> Shape has wrong color</td><td>Shape disappeared</td></tr><tr><td>EPEV</td><td>96.9%</td><td>3.1%</td><td>0%</td></tr><tr><td>CDNA Baseline</td><td>24.6%</td><td>5.7%</td><td>69.7%</td></tr></table>
+
+# 4.3 HUMANS 3.6M
+
+Our method was also tested on the Humans 3.6M Dataset. Only the E2E and EPEV methods were tested here, since Villegas et al. (2017) has already shown the results using the ground truth pose.
+
+We used subjects 1, 5, 6, 7 and 8 for training, subject 9 for validation. Subject 11 results are reported in this paper for testing. We used 64 by 64 images. We subsampled the dataset to 6.25 frames per second. We trained the methods to predict 32 frames and the results in this paper show predicting 64 frames. Each method is given the first 5 frames as context frames. So the in these images, the model predicts about 10 seconds into the future from .8 seconds of context. We used an encoding size of 32 for the E2E method and a encoding size of 64 for the EPEV method on this dataset. We compare our method to the CDNA method in Finn et al. (2016) in Fig. 6.
+
+![](images/70d8a53c74b20473aeb579651cf0f04dcaba9dc932e8fe229c530554b1f3581d.jpg)  
+Figure 6: A visual comparison of the EPEV method and CDNA from Finn et al. (2016) as the baseline. This example is cherry picked to show results when there is significant movement in the ground truth. See appendix section G for non cherry picked results. The contrast of these images was increased to make the humans easier to see. In CDNA from Finn et al. (2016), the person disappeared part way through the prediction. The EPEV method, produced relatively sharp predictions up until frame 42, and a blurry human prediction at frame 63.
+
+From visually inspecting the images we found that in images where there is not significant movement in the first 5 frames of the ground truth it is hard to tell the difference between our method and CDNA since both methods predict an image similar to the early ground truth frames. However, when there is significant movement in the first 5 ground truth frames, the predictions from EPEV are sharper further into the future than CDNA. See the appendix section G for images where there is significant movement in the first 5 ground truth frames so the methods can be compared. We also collected results from the E2E method, but those blur out very quickly and are shown in appendix section G.
+
+The CDNA method from Finn et al. (2016) produces blurry images since it is trained to minimize L2 loss directly (Finn et al., 2016). In the EPEV method, the predictor and VAN are trained separately. This prevents the VAN from learning to produce blurry images when the predictor is not confident. The predictions will be sharp as long as the predictor network predicts a valid encoding.
+
+We also compare our method to Villegas et al. (2017). This method gives sharper results than ours. We think that this is because Villegas et al. (2017) uses a adversarial loss (Goodfellow et al., 2014) and since nothing besides the human is moving in this dataset, the pose works well as a high level structure.
+
+# 4.3.1 PERSON DETECTOR EVALUATION
+
+We propose to compare the methods quantitatively by considering whether the generated videos contain a recognizable person. To do this in an automated fashion, for each of the generated frames, we ran a MobileNet (Howard et al., 2017) object detection model pretrained on the MS-COCO (Lin et al., 2014) dataset. We recorded how confident the detector was that a person (one of the MSCOCO labels) is in the image. We call this the “person score” (its value ranges from 0 to 1, with a higher score corresponding to a higher confidence level). The results on each frame averaged over 1k runs are shown in Figure 7.
+
+![](images/4ddcaff68fa0a899ee634e88ea4e1c83fe00be23da0f93833f5c1609fa6c6d3b.jpg)  
+Figure 7: Confidence of the person detector that a person is in the image (“person score”). The baseline method is CDNA from Finn et al. (2016).
+
+The person score on the ground truth frames is about 0.4. This is likely due to the mismatch between the training set images of the model (the MS-COCO dataset images are very different in terms of image statistics compared to the Humans 3.6M data). The person score is 0.26 on average for the images generated by the EPEV method, and 0.18 for CDNA from Finn et al. (2016). The person score degrades very rapidly in the first 8 frames of CDNA, but degrades more slowly in the EPEV method. The person score of the EPEV method on frame 63 is about the same as on frame 8 of CDNA. This confirms our visual analysis that the EPEV method produces clearer predictions further into the future. The EPEV method was only trained to predict 32 frames into the future but there is no significant drop in the person score at frame 32, showing that the EPEV method generalizes well to predicting longer sequences.
+
+# 4.3.2 HUMAN EVALUATION
+
+We also used a service similar to Mechanical Turk to collect comparisons of 1,000 generated videos from our EPEV method and the CDNA baseline. The task showed videos generated by the two methods side by side and asked raters to confirm whether one of the videos is more realistic. The workers rated the EPEV method as more realistic $5 3 . 6 \%$ of the time, the CDNA method as more realistic $1 1 . 1 \%$ of the time and the videos as being about the same $3 5 . 3 \%$ of the time. The high number of “same” responses could be because of it being difficult to tell the difference between the methods when there is little movement.
+
+# 5 CONCLUSION AND FUTURE WORK
+
+On datasets where the pose does not capture all of the information needed to predict future frames, letting the network define its own high level structure in addition to the pose is an improvement upon a Villegas et al. (2017). The EPEV method generates sharper images than Finn et al. (2016) on non deterministic datasets, and can generate further into the future on a toy dataset that we introduced. We posit an adversarial loss between the predictor and encoder would likely help with potentially uncertain scenarios and would fix the problem of the EPEV method sometimes generating blurry images,
+
+# REFERENCES
+
+Konstantinos Bousmalis, George Trigeorgis, Nathan Silberman, Dilip Krishnan, and Dumitru Erhan. Domain separation networks. In Advances in Neural Information Processing Systems, pp. 343– 351, 2016.
+
+Cristian Sminchisescu Catalin Ionescu, Fuxin Li. Latent structured models for human pose estimation. In International Conference on Computer Vision, 2011.
+
+J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR09, 2009.
+
+Chelsea Finn, Ian Goodfellow, and Sergey Levine. Unsupervised learning for physical interaction through video prediction. In Advances in Neural Information Processing Systems, pp. 64–72, 2016.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.
+
+Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. CoRR, abs/1704.04861, 2017. URL http://arxiv.org/abs/ 1704.04861.
+
+Catalin Ionescu, Dragos Papava, Vlad Olaru, and Cristian Sminchisescu. Human3.6m: Large scale datasets and predictive methods for 3d human sensing in natural environments. IEEE Transactions on Pattern Analysis and Machine Intelligence, 36(7):1325–1339, jul 2014.
+
+Nal Kalchbrenner, Aaron van den Oord, Karen Simonyan, Ivo Danihelka, Oriol Vinyals, Alex Graves, and Koray Kavukcuoglu. Video pixel networks. arXiv preprint arXiv:1610.00527, 2016.
+
+J. Lei Ba, J. R. Kiros, and G. E. Hinton. Layer Normalization. ArXiv e-prints, July 2016.
+
+Tsung-Yi Lin, Michael Maire, Serge J. Belongie, Lubomir D. Bourdev, Ross B. Girshick, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C. Lawrence Zitnick. Microsoft COCO:´ common objects in context. CoRR, abs/1405.0312, 2014. URL http://arxiv.org/abs/ 1405.0312.
+
+William Lotter, Gabriel Kreiman, and David Cox. Deep predictive coding networks for video prediction and unsupervised learning. In ICLR. 2017.
+
+Michael Mathieu, Camille Couprie, and Yann LeCun. Deep multi-scale video prediction beyond ¨ mean square error. In ICLR. 2016.
+
+V. Michalski, R. Memisevic, and Kishore Konda. Modeling deep temporal dependencies with recurrent ”grammar cells”. In NIPS, 2014.
+
+Roni Mittelman, Benjamin Kuipers, Silvio Savarese, and Honglak Lee. Structured recurrent temporal restricted boltzmann machines. In ICML. 2014.
+
+Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-conditional video prediction using deep networks in atari games. In NIPS. 2015.
+
+Scott E Reed, Yi Zhang, Yuting Zhang, and Honglak Lee. Deep visual analogy-making. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 1252–1260. Curran Associates, Inc., 2015. URL http://papers. nips.cc/paper/5845-deep-visual-analogy-making.pdf.
+
+K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. J. Mach. Learn. Res., 15 (1):1929–1958, January 2014. ISSN 1532-4435. URL http://dl.acm.org/citation. cfm?id=2627435.2670313.
+
+Nitish Srivastava, Elman Mansimov, and Ruslan Salakhudinov. Unsupervised learning of video representations using lstms. In ICML. 2015.
+
+Ilya Sutskever, Geoffrey E. Hinton, and Graham W. Taylor. The recurrent temporal restricted boltzmann machine. In NIPS. 2009.
+
+Ruben Villegas, Jimei Yang, Yuliang Zou, Sungryull Sohn, Xunyu Lin, and Honglak Lee. Learning to generate long-term future via hierarchical prediction. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 3560–3569, 2017.
+
+# Appendices
+
+# A IMPLEMENTATION DETAILS
+
+The convolutional neural net encoder is a VGG-16 network (Simonyan & Zisserman, 2014). In the EPEV method, the encoder needs to be pre-trained on Imagenet (Deng et al., 2009). If that is not done, the VAN will ignore the output from the encoder. All other configurations are run without pretraining.
+
+The predictor network is a 20 layer LSTM, while the analogy network uses the deep analogy transformation described in Reed et al. (2015). The VAN outputs a mask which controls whether to use its own output, or the pixels of the first frame. This allows the network to focus on learning the changing parts of the image instead of the background.
+
+The end effector orientation is converted to quaternions (Bousmalis et al., 2016) in order to calculate the loss if the pose is used. Layer normalization (Lei Ba et al., 2016) is used between every other layer in the VAN and predictor networks. We used dropout (Srivastava et al., 2014) on the encoder and VAN to prevent overfitting. The network overfits less in the INDIVIDUAL method, so we used less dropout.
+
+# B HUMAN EVALUATION DETAILS
+
+Each video in the comparison is generated from the same starting sequence. The side that the EPEV method and the CDNA method are displayed on is changed randomly.
+
+![](images/9c033459791c3201393e2345e6c37ffa0ec78887b7da0d24a9960c07dbec1502.jpg)  
+Figure 8: The screen shown to workers in the human evaluation
+
+# C EPEV METHOD WITH ENCODER OUTPUT FED TO VAN
+
+To see what the encoder has learned in the EPEV method, we can obtain results from the visual analogy network given the input from the encoder. The encoder is given the ground truth image. The results are shown in figure 9. The results show that the encoder encodes where the person is
+
+![](images/776dbff016b5360c4dc96a4e83e8c805d42fd71dbe49f53771b93d174063b065.jpg)  
+Figure 9: Results from the EPEV approach when the VAN is given the output of the encoder on the ground truth frame.
+
+in the image, as well as the orientation of the arms, legs and head to some extent. The results are not as good as one would expect from an autoencoder, since the encoder has the constraint that the encoding also has to be easy to predict.
+
+# D TRAINING DETAILS
+
+We trained all of the methods including Finn et al. (2016) for 3 million steps using async SGD, across 32 worker machines. We used a minibatch size of 8 sequences in each step. The minibatch size could be so small because there were multiple frames per sequence. In methods with multiple optimizers, a step is defined as running each optimizer once. The hyperparameters are optimized separately for both datasets on a validation set. We used the best learning rates for each method.
+
+E MORE RESULTS ON SHAPES DATAEST.
+
+![](images/cc5cf7cb9c24e8c0bcb69b19c23d489efb7ec1f6eb6beef1b7431889c0e37b0b.jpg)
+
+![](images/484d8ed40c1fc527d45532ad5d675a478bf8fbf7757a507dae9d4598027f690a.jpg)
+
+F MORE RESULTS ON ROBOT PUSH DATASET.
+
+F.1 FRAMES WHERE EPEV PREDICTS OBJECTS BETTER THAN INDIVIDUAL.
+
+![](images/700bdf567e5a7755b2737cc9a60de4260e40f27fc33237022c6b7af86194b6f6.jpg)
+
+![](images/569239391074089931ab41e82157136e1063632322800b768f9cca809c294c53.jpg)
+
+![](images/c024a2529b5965bd3d6d861063e16cd760cc6debe486d03dc4c7e482f004cc71.jpg)
+
+![](images/3483e43a37e54f6332b272d53f561a1a8e32cf007ad8771783e8d62bab2291f4.jpg)
+
+![](images/ea5024d0885488f784b503e50e32f603265710c311c3c8b6c2a350d1b58193a8.jpg)
+
+![](images/ff40a9c300db449e5b6996428001db43b9b80928881bce55bd97052b64bcb886.jpg)
+
+F.2 FRAMES WHERE INDIVIDUAL PREDICTS OBJECTS BETTER THAN EPEV.
+
+![](images/0f6764c4aa5eff479d4496a9c69ef5af01ee96782233a21fc0c6a6b05e43a573.jpg)
+
+![](images/858538105bc480abdb6611d81168abcea6bae6b29723330973d8f29504547302.jpg)
+
+![](images/069f759e6c0939d33a8aa97ab731e7dae958b9c08feb5b63a64916e4a23bfc1b.jpg)
+
+![](images/482e41031d658d6156cb1346339a781beb0226725316621703d5d6d0b2fc560e.jpg)
+
+![](images/3e400c9219a1ea4a6f35b662abafbff5c50475712a606c8b53bee0fbf2d85a6c.jpg)
+
+![](images/0199201311f2f6b5867ec8dc472497b48bbceb67102b2ec09ef7c2df3e3aa465.jpg)
+
+G MORE RESULTS ON HUMANS DATAEST.
+
+G.1 SIGNIFICANT MOVEMENT IN THE FIRST 5 GROUND TRUTH FRAMES.
+
+![](images/71a86dacb30e778632502ba5c498258f228c96f34c54e85b4da45523946b3fdc.jpg)
+
+![](images/91d39a703f3126868a2073a26f966761f3b3143b12e363644c35443f64f2d2f9.jpg)
+
+![](images/be39494cb6101b6bfb82d9be3cbdb48a43c256ad9bd1604c1bc78eff9649accf.jpg)
+
+![](images/a833a5c7eff72401117ef34ca5f72eada8e15b4f0d7fb81acfc305094cd93261.jpg)
+
+G.2 NO SIGNIFICANT MOVEMENT IN THE FIRST 5 GROUND TRUTH FRAMES.
+
+![](images/d6a4f6ba16e13fe6e3348f24e1a09f7d1a104087c3129b9a69b367c65f7cf79f.jpg)
+
+![](images/ab989f92d1e95a0891cee8413381bd6a82ca5e8649c4195d3a9d1cd765b00bb0.jpg)
+
+![](images/58dffff8198f4dca0be893d2ae2963b42404f3858854cc9e66182fbaee122c05.jpg)
+
+![](images/97b0b5884eabe20fdeb62342892834496bf5e3484241d70e79bc7ceb3a0f6f51.jpg)
+
+![](images/ad747ba62f54115aad4c9c9d7a2aceefeb2a112b3c2c93bc9cb290ded9971d60.jpg)
+
+![](images/09de9001ce9572ea1cb93f126645c16837b4cae908473a4c65f88cee65cb999e.jpg)

parse/train/rkmtTJZCb/rkmtTJZCb_content_list.json

@@ -0,0 +1,1820 @@
+[
+    {
+        "type": "text",
+        "text": "UNSUPERVISED HIERARCHICAL VIDEO PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            98,
+            803,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            400,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            209,
+            544,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Much recent research has been devoted to video prediction and generation, yet a lot of previous work has been focused on short-scale time horizons. The hierarchical video prediction method by Villegas et al. (2017) is an example of a state of the art method for long term video prediction. However, their method has limited applicability in practical settings as it requires a ground truth pose (e.g., poses of joints of a human) at training time. This paper presents a long term hierarchical video prediction model that does not have such a restriction. We show that the network learns its own higher level structure (e.g., pose-equivalent hidden variables) that works better in cases where the ground truth pose does not fully capture all of the information needed to predict the next frame. This method gives sharper results than other video prediction methods which do not require a ground truth pose, and its efficiency is shown on the Humans 3.6M and Robot Pushing datasets. ",
+        "bbox": [
+            233,
+            242,
+            764,
+            409
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            440,
+            336,
+            455
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "It is hypothesized that learning to predict the future and the effect of their actions is an important quality for intelligent agents that interact with their environment. This is a complicated task, as typical use cases require predicting the outcome of interactions between the agent and objects over multiple timesteps. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            529
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work we are looking at the task of predicting the pixels of future video frames given the first few observed frames. We also consider the action conditional setting, in which we are given the action that the agent is taking and are tasked to predict the pixel level outcome of that action in the future. ",
+        "bbox": [
+            174,
+            536,
+            823,
+            592
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The method of Villegas et al. (2017) is a novel way to generate long term video predictions, but requires ground truth human pose annotations. In this work we explore ways to generate videos using a hierarchical model without requiring a ground truth pose or other high level structure annotations for each frame. The method is hierarchical in the sense that it learns to generate a high level structure, then makes next frame predictions based on that structure. ",
+        "bbox": [
+            174,
+            598,
+            825,
+            669
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            691,
+            341,
+            707
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Patch level prediction The video prediction problem was initially studied at the patch level (Sutskever et al., 2009; Michalski et al., 2014; Mittelman et al., 2014; Srivastava et al., 2015). This work showed promising results on synthetic data (e.g. bouncing balls), but did not scale to predicting higher resolution videos. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            780
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Frame level prediction on realistic videos. More recently, the video prediction problem has been formulated at the entire frame level. Most of the recent work is based on the convolutional encoder/decoder framework. Finn et al. (2016) proposed a network that can perform next level video frame prediction by explicitly predicting movement. For each pixel in the previous frame, the network outputs a distribution over locations that pixel is predicted to move. The movements are averaged to get the final prediction. The network is trained end to end to minimize L2 loss. Mathieu et al. (2016) proposed adversarial training with multiscale convolutional networks to generate sharper pixel level predictions in comparison to conventional L2 loss. Villegas et al. (2017) proposed a network that decomposes motion and content in video prediction and showed improved performance over Mathieu et al. (2016). Lotter et al. (2017) proposed a deep predictive coding network in which each layer learns to predict the lower-level difference between the future frame and current frame. As an alternative approach to convolutional encoder/decoder networks, Kalchbrenner et al. (2016) proposed an autoregressive generation scheme for improved prediction performance. Despite their promise, these work have not been demonstrated for long term prediction on high resolution natural videos beyond $\\approx 2 0$ frames. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Long-term prediction. Oh et al. (2015) proposed action conditional convolutional encoderdecoder architecture that has demonstrated impressive long-term prediction performance on video games (e.g., Atari games), but it has not been applied for predicting challenging real-world videos. ",
+        "bbox": [
+            174,
+            202,
+            823,
+            246
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 HIERARCHICAL VIDEO PREDICTION (VILLEGAS ET AL., 2017) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            261,
+            647,
+            276
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Villegas et al. (2017) demonstrated a long-term prediction method using hierarchical prediction where the ground truth human pose is assumed to be given as supervision. Our method is based off of that work, so we describe it in detail in the following section. ",
+        "bbox": [
+            174,
+            287,
+            825,
+            330
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1.1 INFERENCE AND ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            344,
+            455,
+            359
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To generate the image at timestep $t$ , the following procedure is used. First, a convolutional neural network encoder generates an embedding vector from the previous ground truth image: $e _ { t - 1 } =$ $C N N ( i m g _ { t - 1 } )$ . This encoding represents the pose of a person. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            411
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Next, a multilayer LSTM predictor network predicts what the encoding will be in a future timestep. For some number of context frames, the predictor makes its prediction based off of the encoding from the ground truth image. After the predictor network has enough context, it makes its predictions based off of its previous predictions (Fig. 1 provides a helpful visual). For example, if there are $\\textrm { C }$ context frames, the following is used to generate the encoding at step $t$ . ",
+        "bbox": [
+            174,
+            417,
+            825,
+            488
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2485e8da996325faab95fa7186689b8884420365124f6e0bbb3e4ec9870ae9fc.jpg",
+        "text": "$$\n\\begin{array} { r } { \\left\\{ \\left[ p _ { t } , H _ { t } \\right] = L S T M ( e _ { t - 1 } , H _ { t - 1 } ) \\quad i f t < = C \\right. } \\\\ { \\left[ p _ { t } , H _ { t } \\right] = L S T M ( p _ { t - 1 } , H _ { t - 1 } ) \\quad i f t > C } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            506,
+            655,
+            541
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "$H _ { t }$ is the hidden state of the LSTM at timestep $t$ . Note that only the encoding of the context frames are used, not the subsequent frames. Similar to $e _ { t }$ in the above, $p _ { t }$ represents the predicted pose. ",
+        "bbox": [
+            171,
+            551,
+            823,
+            580
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Once $p _ { t }$ is obtained, a visual analogy network (VAN) (Reed et al., 2015) is used to generate the corresponding image at time $t$ . The VAN applies the transformation that occurred between two images to a given query image. In this case the first frame of the video should be transformed in the same way as the encoding was transformed from the first to $t$ -th timestep. The VAN does this by mapping images to a space where analogies can be represented by additions and subtractions, and then mapping the result back to image space. To obtain the predicted image at timestep $t$ using the VAN one needs to use $\\widehat { i m g } _ { t } = V A \\bar { N } ( e _ { 1 } , p _ { t } , i m g _ { 1 } )$ , where the VAN is defined as ",
+        "bbox": [
+            174,
+            585,
+            825,
+            688
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf0db4b93383deee3fd1194a65c895a3a59e0abb4568a1f694abdcf683783f44.jpg",
+        "text": "$$\nV A N ( e _ { 1 } , p _ { t } , i m g _ { 1 } ) = f _ { d e c } ( f _ { e n c } ( g ( p _ { t } ) ) - f _ { e n c } ( g ( e _ { 1 } ) ) + f _ { i m g } ( i m g _ { 1 } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            263,
+            705,
+            733,
+            724
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Where $g$ is a hardcoded function to transform the pose into a 2 dimensional representation of the pose. The weights of $f _ { e n c }$ and $f _ { i m g }$ are shared. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            762
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1.2 TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            776,
+            300,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The disadvantage of this method is that the training relies on ground truth pose annotations. The encoder is trained to produce the pose given the image, the predictor is trained to predict that pose into the future and the VAN is trained to generate the image given the pose. ",
+        "bbox": [
+            173,
+            801,
+            825,
+            844
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 PROPOSED METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            863,
+            372,
+            880
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our method uses a similar network architecture to Villegas et al. (2017) but we present ways of training the network that do not require a ground truth pose. In our method, $e _ { t }$ and $p _ { t }$ have the same dimensionality and represent the network’s own higher level structure (e.g., pose equivalent hidden variables) which the network learns as it is trained. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In our case, there is no straightforward way to transform the encoding into a 2 dimensional representation of the pose. Therefore, the part of the VAN that maps the encoding is a fully connected network instead of a convolutional neural network. As a result, the weights are not shared between the fully connected network which processes the encoding, and the ConvNet which processes the image. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            209
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The equation for the VAN becomes: ",
+        "bbox": [
+            176,
+            215,
+            411,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6a27c9c6005117ab2dc3038f47cdf4312bcb287a78c4aa8313cdd0d3782f8972.jpg",
+        "text": "$$\nV A N ( e _ { 1 } , p _ { t } , i m g _ { 1 } ) = f _ { d e c } ( f _ { e n c } ( p _ { t } ) - f _ { e n c } ( e _ { 1 } ) + f _ { i m g } ( i m g _ { 1 } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            256,
+            714,
+            273
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that $f _ { e n c }$ is a fully connected network, and $f _ { i m g }$ is a conv net. $f _ { d e c }$ is a deconv network. ",
+        "bbox": [
+            173,
+            290,
+            785,
+            306
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            327,
+            287,
+            342
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There are several ways these networks can be trained. In Villegas et al. (2017), they are each trained separately with the ground truth human pose. In this work, we explore alternative ways of training these networks in the absence of any ground truth pose or other high level structure annotations. We use the same procedure as Villegas et al. (2017) at inference time. ",
+        "bbox": [
+            174,
+            356,
+            825,
+            411
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 END TO END ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            431,
+            318,
+            445
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One option is to connect the networks the same way as in inference time and train them end to end (E2E). In this method, the L2 loss of of the predicted image is optimized: $\\begin{array} { r } { \\operatorname* { m i n } ( \\sum _ { t = 1 } ^ { T } L _ { 2 } ( \\widehat { i m g } _ { t } , i m g _ { t } ) ) } \\end{array}$ . ",
+        "bbox": [
+            174,
+            458,
+            825,
+            505
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There are no constraints on what kind of encoding the encoder produces, or what kind of predictions the predictor makes. Because of how the networks are connected, the encoder will produce an encoding whose future state is easily predicted by the predictor. Likewise, the predictor will make predictions which the VAN can use to produce images which are similar to the ground truth. The encoder and predictor will not have to represent information that is present in the first ground truth frame, since the VAN will have access to the first frame. The size of $e _ { t }$ and $p _ { t }$ is a hyper parameter of this approach. Figure 1 represents a diagram of this method. ",
+        "bbox": [
+            173,
+            510,
+            825,
+            608
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/05fbe57307c09b6410f38782fe038ae2033494d97f2ecb73a895d1046c248c04.jpg",
+        "image_caption": [
+            "Figure 1: The E2E method. The first few frames are encoded and fed into the predictor as context. The predictor predicts the subsequent encodings, which the VAN uses to produce the pixel level predictions. The average of the losses is minimized. This is also the configuration of every method at inference time, even if the predictor and VAN are trained separately. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            312,
+            631,
+            681,
+            829
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 ENCODER PREDICTOR WITH ENCODER VAN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            537,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "An alternative way to train the combined network is to explicitly train the encoder so that $e _ { t }$ is easy to predict into the future, and so that the VAN can use $e _ { t }$ to produce the next frame. We call this method Encoder Predictor with Encoder VAN, or EPEV. The encoder and predictor are trained together so the $e _ { t }$ is easy to predict and the predictor predicts that encoding into the future. To accomplish this, the difference between $e _ { t }$ and $p _ { t }$ , $L _ { 2 } ( \\boldsymbol { e } _ { t } , \\boldsymbol { p } _ { t } )$ is minimized. The encoder is also trained with the VAN so the VAN can use $e _ { t }$ to produce the image and so that the encoder generates an informative encoding. This is done by minimizing the loss of the VAN given the encoder output: $L _ { 2 } ( \\widehat { i m g } _ { e _ { t } } , i m g _ { t } )$ where $\\widehat { i m g } _ { e _ { t } } = V A N ( e _ { 1 } , e _ { t } , i m g _ { 1 } )$ . The network is trained to minimize the sum of these two losses: $\\begin{array} { r } { \\operatorname* { m i n } ( \\sum _ { t = 1 } ^ { T } L _ { 2 } ( \\widehat { i m g } _ { e _ { t } } , i m g _ { t } ) + \\alpha L _ { 2 } ( e _ { t } , p _ { t } ) ) } \\end{array}$ , where $\\alpha$ is a hyper-parameter that controls the degree to which the $e _ { t }$ will be easy to predict vs. informative enough so the VAN can produce a good image. ",
+        "bbox": [
+            173,
+            127,
+            825,
+            287
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "See figure 2 for a diagram of the encoder and predictor trained together, and figure 3 for the encoder and VAN trained together. ",
+        "bbox": [
+            174,
+            294,
+            823,
+            323
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/ad8b9c0e7c083528e83426eef847cc3a04a705c7dfed0b8db9f6ac26b31b9434.jpg",
+        "image_caption": [
+            "Figure 2: The segment of the EPEV method in which the encoder and predictor are trained together. The encoder is trained to produce an encoding that is easy to predict, and the predictor is trained to predict that encoding into the future. The average of the losses is minimized. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            339,
+            426,
+            560
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/8b431a06125a4c52bc439f217847a3f4e3d5b00ec8635c4b9e45b164957506ab.jpg",
+        "image_caption": [
+            "Figure 3: The segment of the EPEV method in which the encoder and VAN are trained together. The encoder is trained to produce an encoding that is informative to the VAN, while the VAN is trained to output the image given the encoding. The average of the losses is minimized. This method is similar to an autoencoder. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            537,
+            404,
+            810,
+            560
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Separate gradient descent procedures (or optimizers, in TensorFlow parlance) could be used to minimize $L _ { 2 } ( \\widehat { i m g } _ { e _ { t } } , i m g _ { t } )$ and $L _ { 2 } ( e _ { t } , p _ { t } )$ , but we find that minimizing the sum works better experimentally. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            753
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "With this method, the predictor will predict the encoder outputs in future timesteps, and the VAN will use the encoder output to produce the frame. ",
+        "bbox": [
+            174,
+            758,
+            823,
+            787
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.3 E2E WITH POSE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            801,
+            339,
+            815
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The end to end approach can also be augmented if the dataset has information about the ground truth pose or any other high level frame annotations. In this method, the $e _ { t }$ and $p _ { t }$ vectors would be split into two: the first path is optimized to represent the pose, and the rest of $e _ { t }$ and $p _ { t }$ is trained the same way as the E2E approach. At each training step a separate optimizer minimizes each loss. In this method, we can think of $e _ { t }$ and $p _ { t }$ as the concatenation of two vectors, one representing the pose, and the other containing additional information the network can represent. If $\\boldsymbol { e _ { t } } ^ { \\top } = [ e _ { p o s e _ { t } } , e _ { r e m a i n i n g _ { t } } ]$ and $p _ { t } = [ p _ { p o s e _ { t } } , p _ { r e m a i n i n g _ { t } } ]$ , the following losses are minimized: ",
+        "bbox": [
+            174,
+            825,
+            825,
+            925
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The loss representing how well the encoder infers the pose: $\\begin{array} { r } { \\operatorname* { m i n } ( \\sum _ { t = 1 } ^ { T } L _ { 2 } ( e _ { p o s e _ { t } } , p o s e _ { t } ) ) } \\end{array}$ . The loss representing how well the predictor predicts the pose: $\\begin{array} { r } { \\operatorname* { m i n } ( \\sum _ { t = 1 } ^ { T } L _ { 2 } ( p _ { p o s e _ { t } } , p o s e _ { t } ) ) } \\end{array}$ . The end to end loss: $\\begin{array} { r } { \\operatorname* { m i n } ( \\sum _ { t = 1 } ^ { T } L _ { 2 } ( \\widehat { i m g } _ { t } , i m g _ { t } ) ) } \\end{array}$ . ",
+        "bbox": [
+            174,
+            102,
+            825,
+            155
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "These losses are minimized with separate optimizers in this method. Minimizing the end to end loss ensures that the VAN will learn to use the pose provided by the predictor network, and that the encoder and predictor will learn to produce additional information besides the pose that is useful to the VAN. ",
+        "bbox": [
+            174,
+            160,
+            825,
+            215
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1.4 INDIVIDUAL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            229,
+            313,
+            244
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to compare to a baseline, we also implemented the method where each of the networks are trained individually, as in Villegas et al. (2017). The main difference between this method and Villegas et al. (2017) is that we do not use an adversarial loss (Goodfellow et al., 2014). See section 5 for a discussion of how an adversarial loss could be added to our method. ",
+        "bbox": [
+            174,
+            255,
+            825,
+            310
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            330,
+            326,
+            347
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "These methods were tested on two different datasets, the Robot Push dataset (Finn et al., 2016) and the Humans 3.6M dataset (Ionescu et al., 2014; Catalin Ionescu, 2011). Videos of the results of our method are available by visiting the following URL: https://goo.gl/WA8uxc. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            404
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The EPEV method works best experimentally if $\\alpha$ starts small, around 1e-7, and is gradually increased to around .1 during training. As a result, the encoder will first be optimized to produce an informative encoding, then gradually optimized to also make that encoding easy to predict. ",
+        "bbox": [
+            174,
+            410,
+            825,
+            453
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 ROBOT PUSH DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            469,
+            370,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This dataset contains videos of a robot arm pushing objects on a table. The current joint angles and the location of the end effector are given, and we use these as the pose for the methods which require it. The action the robot arm is taking is fed into the predictor. ",
+        "bbox": [
+            174,
+            496,
+            825,
+            537
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Each of the methods considered was given two frames of context, and then trained to predict 17 subsequent frames. An encoding size of 16 was used for the E2E method. The size of the pose is 12, so the encoding size of the INDIVIDUAL method is 12. The other methods used an encoding size of 32. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            601
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Additionaly, we randomly split the dataset into training, validation and test. We used 64x64 images, and the same frame rate as the original dataset. Results from our test set are shown in this section. Note that our experimental protocol is different from Finn et al. (2016), where the test set is composed of novel objects. ",
+        "bbox": [
+            174,
+            607,
+            823,
+            662
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We hypothesized that the methods where the network could learn its own pose equivalent would predict the movement of the objects the robot arm pushes more accurately than the INDIVIDUAL method. To test this, we manually compared the E2E and EPEV methods to the INDIVIDUAL method and evaluated where the movement of predicted objects most closely matched the ground truth. We evaluated 40 videos in which objects move. The results are in Table 1. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Results from manual comparison of object predictions in 40 videos. The methods perform similarly in the remaining videos. ",
+        "bbox": [
+            168,
+            751,
+            823,
+            781
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/f7f06056543905ec9901e395d5afa1301ecf8b3c9eae1a7e13b0312b7bb4476c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Comparison</td><td>Numberofvideos</td></tr><tr><td></td><td></td></tr><tr><td>EPEVbetter than INDIVIDUAL</td><td>6</td></tr><tr><td>INDIVIDUALbetter thanEPEV</td><td>3</td></tr><tr><td>E2Ebetter than INDIVIDUAL</td><td>6</td></tr><tr><td>INDIVIDUAL better than E2E</td><td>6</td></tr></table>",
+        "bbox": [
+            312,
+            796,
+            683,
+            882
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the INDIVIDUAL method, the predictor network can only produce the pose, so the VAN has to infer how the objects will move based on the start and end state of the arm. We were surprised by how well the VAN could infer this. However, from examining the videos, the EPEV method had better object predictions than the INDIVIDUAL method, which supports our hypothesis. The magnified part of ground truth frame 19 in figure 4 shows that the robot arm pushed the yellow object. The EPEV and E2E methods correctly predict this, but in the INDIVIDUAL method, the robot arm covers up the yellow object instead of moving it. Additional analysis is in appendix section F. ",
+        "bbox": [
+            178,
+            882,
+            820,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/3be0f5512e34fea098d94f20ebb50f50db916ed6fe4929df111d9a9102431678.jpg",
+        "image_caption": [
+            "Figure 4: A visual comparison of the different methods on the robot push dataset. In the E2E and EPEV methods, the yellow object moves, but it does not in the INDIVIDUAL method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            274,
+            184,
+            635,
+            465
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The average Peak Signal to Noise Ratio (PSNR) of the different methods we introduce are similar on this dataset. In this data set, the model from Finn et al. (2016) gets a better PSNR than our model. The movement in this dataset can easily be represented by the movement of pixels, and it is relatively deterministic. So the model from Finn et al. (2016) which explicitly predicts the movement of objects and directly minimizes the L2 loss works well here. ",
+        "bbox": [
+            174,
+            539,
+            825,
+            608
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 LONG TERM PREDICTION ON A TOY DATASET",
+        "text_level": 1,
+        "bbox": [
+            174,
+            637,
+            526,
+            650
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To confirm our claim that our method works well for long term predictions, we trained our method on a toy task with known factors of variation. We used a dataset with a generated shape that bounces around the image and changes size deterministically. We trained the EPEV method and the CDNA method in Finn et al. (2016) to predict 16 frames, given the first 3 frames as context. We do not show the E2E method since it usually predicts blurrier images than the EPEV method. Both methods are evaluated on predicting approximately 1k frames. We added noise to the LSTM states of the predictor network during training to help predict reasonable motion further into the future. Results form a held out test set are described in the following. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            777
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "After visually inspecting the results of both methods, we found that when the CDNA fails, the shape disappears entirely, however when the EPEV method fails, the shape changes color. To quantitatively evaluate both methods, we used a script to measure whether a shape was present frames 1012 to 1022, and if that shape has the appropriate color. See table 2 for the results averaged over 1k runs. The CDNA method predicts a shape with the correct color about $2 5 \\%$ of the time, and the EPEV method predicts a shape with the correct color about $9 7 \\%$ of the time. The EPEV method sometimes fails by predicting the shape in the same location from frame to frame. This does not happen very often, as the reader can confirm by examining the randomly sampled predictions in appendix section E. It is unrealistic to expect the methods to predict the location of the shape accurately in frame 1000, since small errors propagate in each prediction step. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/861769e6d188899e4304167b540d3e4e694180dee9cada22f2d46f8d8ce45d97.jpg",
+        "image_caption": [
+            "Figure 5: A visual comparison of the EPEV method and CDNA from Finn et al. (2016) as the baseline. This example is cherry picked to show the typical quality of predictions from both methods. See appendix section E for non-cherry picked results. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            261,
+            103,
+            736,
+            226
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/3fea2c02da7353e21af59bd96d6bf8949e7831a4d190d801f6a460504c79e414.jpg",
+        "table_caption": [
+            "Table 2: Results on shapes dataset "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Shape has correct color</td><td> Shape has wrong color</td><td>Shape disappeared</td></tr><tr><td>EPEV</td><td>96.9%</td><td>3.1%</td><td>0%</td></tr><tr><td>CDNA Baseline</td><td>24.6%</td><td>5.7%</td><td>69.7%</td></tr></table>",
+        "bbox": [
+            179,
+            334,
+            816,
+            382
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 HUMANS 3.6M ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            412,
+            321,
+            428
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our method was also tested on the Humans 3.6M Dataset. Only the E2E and EPEV methods were tested here, since Villegas et al. (2017) has already shown the results using the ground truth pose. ",
+        "bbox": [
+            174,
+            439,
+            823,
+            468
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We used subjects 1, 5, 6, 7 and 8 for training, subject 9 for validation. Subject 11 results are reported in this paper for testing. We used 64 by 64 images. We subsampled the dataset to 6.25 frames per second. We trained the methods to predict 32 frames and the results in this paper show predicting 64 frames. Each method is given the first 5 frames as context frames. So the in these images, the model predicts about 10 seconds into the future from .8 seconds of context. We used an encoding size of 32 for the E2E method and a encoding size of 64 for the EPEV method on this dataset. We compare our method to the CDNA method in Finn et al. (2016) in Fig. 6. ",
+        "bbox": [
+            173,
+            474,
+            826,
+            571
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/70d8a53c74b20473aeb579651cf0f04dcaba9dc932e8fe229c530554b1f3581d.jpg",
+        "image_caption": [
+            "Figure 6: A visual comparison of the EPEV method and CDNA from Finn et al. (2016) as the baseline. This example is cherry picked to show results when there is significant movement in the ground truth. See appendix section G for non cherry picked results. The contrast of these images was increased to make the humans easier to see. In CDNA from Finn et al. (2016), the person disappeared part way through the prediction. The EPEV method, produced relatively sharp predictions up until frame 42, and a blurry human prediction at frame 63. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            339,
+            589,
+            656,
+            773
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "From visually inspecting the images we found that in images where there is not significant movement in the first 5 frames of the ground truth it is hard to tell the difference between our method and CDNA since both methods predict an image similar to the early ground truth frames. However, when there is significant movement in the first 5 ground truth frames, the predictions from EPEV are sharper further into the future than CDNA. See the appendix section G for images where there is significant movement in the first 5 ground truth frames so the methods can be compared. We also collected results from the E2E method, but those blur out very quickly and are shown in appendix section G. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            174
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The CDNA method from Finn et al. (2016) produces blurry images since it is trained to minimize L2 loss directly (Finn et al., 2016). In the EPEV method, the predictor and VAN are trained separately. This prevents the VAN from learning to produce blurry images when the predictor is not confident. The predictions will be sharp as long as the predictor network predicts a valid encoding. ",
+        "bbox": [
+            174,
+            180,
+            823,
+            236
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also compare our method to Villegas et al. (2017). This method gives sharper results than ours. We think that this is because Villegas et al. (2017) uses a adversarial loss (Goodfellow et al., 2014) and since nothing besides the human is moving in this dataset, the pose works well as a high level structure. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            299
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3.1 PERSON DETECTOR EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            314,
+            460,
+            328
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We propose to compare the methods quantitatively by considering whether the generated videos contain a recognizable person. To do this in an automated fashion, for each of the generated frames, we ran a MobileNet (Howard et al., 2017) object detection model pretrained on the MS-COCO (Lin et al., 2014) dataset. We recorded how confident the detector was that a person (one of the MSCOCO labels) is in the image. We call this the “person score” (its value ranges from 0 to 1, with a higher score corresponding to a higher confidence level). The results on each frame averaged over 1k runs are shown in Figure 7. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            435
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/4ddcaff68fa0a899ee634e88ea4e1c83fe00be23da0f93833f5c1609fa6c6d3b.jpg",
+        "image_caption": [
+            "Figure 7: Confidence of the person detector that a person is in the image (“person score”). The baseline method is CDNA from Finn et al. (2016). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            341,
+            454,
+            635,
+            614
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The person score on the ground truth frames is about 0.4. This is likely due to the mismatch between the training set images of the model (the MS-COCO dataset images are very different in terms of image statistics compared to the Humans 3.6M data). The person score is 0.26 on average for the images generated by the EPEV method, and 0.18 for CDNA from Finn et al. (2016). The person score degrades very rapidly in the first 8 frames of CDNA, but degrades more slowly in the EPEV method. The person score of the EPEV method on frame 63 is about the same as on frame 8 of CDNA. This confirms our visual analysis that the EPEV method produces clearer predictions further into the future. The EPEV method was only trained to predict 32 frames into the future but there is no significant drop in the person score at frame 32, showing that the EPEV method generalizes well to predicting longer sequences. ",
+        "bbox": [
+            174,
+            675,
+            825,
+            815
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3.2 HUMAN EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            829,
+            379,
+            843
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also used a service similar to Mechanical Turk to collect comparisons of 1,000 generated videos from our EPEV method and the CDNA baseline. The task showed videos generated by the two methods side by side and asked raters to confirm whether one of the videos is more realistic. The workers rated the EPEV method as more realistic $5 3 . 6 \\%$ of the time, the CDNA method as more realistic $1 1 . 1 \\%$ of the time and the videos as being about the same $3 5 . 3 \\%$ of the time. The high number of “same” responses could be because of it being difficult to tell the difference between the methods when there is little movement. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            152,
+            493,
+            170
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "On datasets where the pose does not capture all of the information needed to predict future frames, letting the network define its own high level structure in addition to the pose is an improvement upon a Villegas et al. (2017). The EPEV method generates sharper images than Finn et al. (2016) on non deterministic datasets, and can generate further into the future on a toy dataset that we introduced. We posit an adversarial loss between the predictor and encoder would likely help with potentially uncertain scenarios and would fix the problem of the EPEV method sometimes generating blurry images, ",
+        "bbox": [
+            173,
+            185,
+            825,
+            282
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            304,
+            285,
+            320
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Konstantinos Bousmalis, George Trigeorgis, Nathan Silberman, Dilip Krishnan, and Dumitru Erhan. Domain separation networks. In Advances in Neural Information Processing Systems, pp. 343– 351, 2016. ",
+        "bbox": [
+            176,
+            328,
+            823,
+            371
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Cristian Sminchisescu Catalin Ionescu, Fuxin Li. Latent structured models for human pose estimation. In International Conference on Computer Vision, 2011. ",
+        "bbox": [
+            171,
+            381,
+            823,
+            410
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR09, 2009. ",
+        "bbox": [
+            173,
+            420,
+            821,
+            449
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Ian Goodfellow, and Sergey Levine. Unsupervised learning for physical interaction through video prediction. In Advances in Neural Information Processing Systems, pp. 64–72, 2016. ",
+        "bbox": [
+            173,
+            458,
+            826,
+            501
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            555
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. CoRR, abs/1704.04861, 2017. URL http://arxiv.org/abs/ 1704.04861. ",
+        "bbox": [
+            174,
+            565,
+            826,
+            621
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Catalin Ionescu, Dragos Papava, Vlad Olaru, and Cristian Sminchisescu. Human3.6m: Large scale datasets and predictive methods for 3d human sensing in natural environments. IEEE Transactions on Pattern Analysis and Machine Intelligence, 36(7):1325–1339, jul 2014. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            675
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nal Kalchbrenner, Aaron van den Oord, Karen Simonyan, Ivo Danihelka, Oriol Vinyals, Alex Graves, and Koray Kavukcuoglu. Video pixel networks. arXiv preprint arXiv:1610.00527, 2016. ",
+        "bbox": [
+            176,
+            685,
+            825,
+            714
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "J. Lei Ba, J. R. Kiros, and G. E. Hinton. Layer Normalization. ArXiv e-prints, July 2016. ",
+        "bbox": [
+            169,
+            724,
+            758,
+            739
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge J. Belongie, Lubomir D. Bourdev, Ross B. Girshick, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C. Lawrence Zitnick. Microsoft COCO:´ common objects in context. CoRR, abs/1405.0312, 2014. URL http://arxiv.org/abs/ 1405.0312. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            806
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "William Lotter, Gabriel Kreiman, and David Cox. Deep predictive coding networks for video prediction and unsupervised learning. In ICLR. 2017. ",
+        "bbox": [
+            171,
+            816,
+            823,
+            845
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael Mathieu, Camille Couprie, and Yann LeCun. Deep multi-scale video prediction beyond ¨ mean square error. In ICLR. 2016. ",
+        "bbox": [
+            171,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "V. Michalski, R. Memisevic, and Kishore Konda. Modeling deep temporal dependencies with recurrent ”grammar cells”. In NIPS, 2014. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Roni Mittelman, Benjamin Kuipers, Silvio Savarese, and Honglak Lee. Structured recurrent temporal restricted boltzmann machines. In ICML. 2014. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-conditional video prediction using deep networks in atari games. In NIPS. 2015. ",
+        "bbox": [
+            173,
+            146,
+            825,
+            175
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Scott E Reed, Yi Zhang, Yuting Zhang, and Honglak Lee. Deep visual analogy-making. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 1252–1260. Curran Associates, Inc., 2015. URL http://papers. nips.cc/paper/5845-deep-visual-analogy-making.pdf. ",
+        "bbox": [
+            173,
+            189,
+            825,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014. ",
+        "bbox": [
+            173,
+            260,
+            823,
+            289
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. J. Mach. Learn. Res., 15 (1):1929–1958, January 2014. ISSN 1532-4435. URL http://dl.acm.org/citation. cfm?id=2627435.2670313. ",
+        "bbox": [
+            174,
+            303,
+            825,
+            359
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Elman Mansimov, and Ruslan Salakhudinov. Unsupervised learning of video representations using lstms. In ICML. 2015. ",
+        "bbox": [
+            173,
+            373,
+            823,
+            402
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Geoffrey E. Hinton, and Graham W. Taylor. The recurrent temporal restricted boltzmann machine. In NIPS. 2009. ",
+        "bbox": [
+            169,
+            416,
+            823,
+            445
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ruben Villegas, Jimei Yang, Yuliang Zou, Sungryull Sohn, Xunyu Lin, and Honglak Lee. Learning to generate long-term future via hierarchical prediction. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 3560–3569, 2017. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            516
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Appendices ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            559,
+            343,
+            587
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            609,
+            436,
+            626
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The convolutional neural net encoder is a VGG-16 network (Simonyan & Zisserman, 2014). In the EPEV method, the encoder needs to be pre-trained on Imagenet (Deng et al., 2009). If that is not done, the VAN will ignore the output from the encoder. All other configurations are run without pretraining. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            699
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The predictor network is a 20 layer LSTM, while the analogy network uses the deep analogy transformation described in Reed et al. (2015). The VAN outputs a mask which controls whether to use its own output, or the pixels of the first frame. This allows the network to focus on learning the changing parts of the image instead of the background. ",
+        "bbox": [
+            174,
+            705,
+            823,
+            762
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The end effector orientation is converted to quaternions (Bousmalis et al., 2016) in order to calculate the loss if the pose is used. Layer normalization (Lei Ba et al., 2016) is used between every other layer in the VAN and predictor networks. We used dropout (Srivastava et al., 2014) on the encoder and VAN to prevent overfitting. The network overfits less in the INDIVIDUAL method, so we used less dropout. ",
+        "bbox": [
+            174,
+            768,
+            825,
+            838
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "B HUMAN EVALUATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            862,
+            462,
+            877
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Each video in the comparison is generated from the same starting sequence. The side that the EPEV method and the CDNA method are displayed on is changed randomly. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/9c033459791c3201393e2345e6c37ffa0ec78887b7da0d24a9960c07dbec1502.jpg",
+        "image_caption": [
+            "Figure 8: The screen shown to workers in the human evaluation "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            104,
+            823,
+            268
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C EPEV METHOD WITH ENCODER OUTPUT FED TO VAN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            343,
+            658,
+            358
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "To see what the encoder has learned in the EPEV method, we can obtain results from the visual analogy network given the input from the encoder. The encoder is given the ground truth image. The results are shown in figure 9. The results show that the encoder encodes where the person is ",
+        "bbox": [
+            176,
+            383,
+            825,
+            426
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/776dbff016b5360c4dc96a4e83e8c805d42fd71dbe49f53771b93d174063b065.jpg",
+        "image_caption": [
+            "Figure 9: Results from the EPEV approach when the VAN is given the output of the encoder on the ground truth frame. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            457,
+            750,
+            650
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "in the image, as well as the orientation of the arms, legs and head to some extent. The results are not as good as one would expect from an autoencoder, since the encoder has the constraint that the encoding also has to be easy to predict. ",
+        "bbox": [
+            174,
+            732,
+            825,
+            775
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "D TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            811,
+            370,
+            828
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We trained all of the methods including Finn et al. (2016) for 3 million steps using async SGD, across 32 worker machines. We used a minibatch size of 8 sequences in each step. The minibatch size could be so small because there were multiple frames per sequence. In methods with multiple optimizers, a step is defined as running each optimizer once. The hyperparameters are optimized separately for both datasets on a validation set. We used the best learning rates for each method. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "E MORE RESULTS ON SHAPES DATAEST. ",
+        "bbox": [
+            173,
+            102,
+            521,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/cc5cf7cb9c24e8c0bcb69b19c23d489efb7ec1f6eb6beef1b7431889c0e37b0b.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            274,
+            188,
+            722,
+            946
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/484d8ed40c1fc527d45532ad5d675a478bf8fbf7757a507dae9d4598027f690a.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            274,
+            93,
+            722,
+            827
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "F MORE RESULTS ON ROBOT PUSH DATASET. ",
+        "bbox": [
+            173,
+            102,
+            562,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "F.1 FRAMES WHERE EPEV PREDICTS OBJECTS BETTER THAN INDIVIDUAL. ",
+        "bbox": [
+            173,
+            290,
+            707,
+            305
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/700bdf567e5a7755b2737cc9a60de4260e40f27fc33237022c6b7af86194b6f6.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            243,
+            417,
+            751,
+            914
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/569239391074089931ab41e82157136e1063632322800b768f9cca809c294c53.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            99,
+            751,
+            597
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/c024a2529b5965bd3d6d861063e16cd760cc6debe486d03dc4c7e482f004cc71.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            93,
+            751,
+            597
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/3483e43a37e54f6332b272d53f561a1a8e32cf007ad8771783e8d62bab2291f4.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            99,
+            751,
+            597
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/ea5024d0885488f784b503e50e32f603265710c311c3c8b6c2a350d1b58193a8.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            243,
+            97,
+            751,
+            597
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/ff40a9c300db449e5b6996428001db43b9b80928881bce55bd97052b64bcb886.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            243,
+            98,
+            751,
+            597
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "F.2 FRAMES WHERE INDIVIDUAL PREDICTS OBJECTS BETTER THAN EPEV.",
+        "bbox": [
+            173,
+            103,
+            707,
+            118
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f6764c4aa5eff479d4496a9c69ef5af01ee96782233a21fc0c6a6b05e43a573.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            417,
+            751,
+            914
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/858538105bc480abdb6611d81168abcea6bae6b29723330973d8f29504547302.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            243,
+            97,
+            751,
+            597
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/069f759e6c0939d33a8aa97ab731e7dae958b9c08feb5b63a64916e4a23bfc1b.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            243,
+            98,
+            751,
+            597
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/482e41031d658d6156cb1346339a781beb0226725316621703d5d6d0b2fc560e.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            417,
+            751,
+            915
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "image",
+        "img_path": "images/3e400c9219a1ea4a6f35b662abafbff5c50475712a606c8b53bee0fbf2d85a6c.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            98,
+            751,
+            597
+        ],
+        "page_idx": 23
+    },
+    {
+        "type": "image",
+        "img_path": "images/0199201311f2f6b5867ec8dc472497b48bbceb67102b2ec09ef7c2df3e3aa465.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            243,
+            98,
+            751,
+            597
+        ],
+        "page_idx": 24
+    },
+    {
+        "type": "text",
+        "text": "G MORE RESULTS ON HUMANS DATAEST. ",
+        "bbox": [
+            174,
+            102,
+            532,
+            118
+        ],
+        "page_idx": 25
+    },
+    {
+        "type": "text",
+        "text": "G.1 SIGNIFICANT MOVEMENT IN THE FIRST 5 GROUND TRUTH FRAMES. ",
+        "bbox": [
+            173,
+            169,
+            683,
+            183
+        ],
+        "page_idx": 25
+    },
+    {
+        "type": "image",
+        "img_path": "images/71a86dacb30e778632502ba5c498258f228c96f34c54e85b4da45523946b3fdc.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            210,
+            718,
+            921
+        ],
+        "page_idx": 25
+    },
+    {
+        "type": "image",
+        "img_path": "images/91d39a703f3126868a2073a26f966761f3b3143b12e363644c35443f64f2d2f9.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            92,
+            718,
+            804
+        ],
+        "page_idx": 26
+    },
+    {
+        "type": "image",
+        "img_path": "images/be39494cb6101b6bfb82d9be3cbdb48a43c256ad9bd1604c1bc78eff9649accf.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            94,
+            720,
+            806
+        ],
+        "page_idx": 27
+    },
+    {
+        "type": "image",
+        "img_path": "images/a833a5c7eff72401117ef34ca5f72eada8e15b4f0d7fb81acfc305094cd93261.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            104,
+            720,
+            805
+        ],
+        "page_idx": 28
+    },
+    {
+        "type": "text",
+        "text": "G.2 NO SIGNIFICANT MOVEMENT IN THE FIRST 5 GROUND TRUTH FRAMES. ",
+        "bbox": [
+            173,
+            103,
+            707,
+            118
+        ],
+        "page_idx": 29
+    },
+    {
+        "type": "image",
+        "img_path": "images/d6a4f6ba16e13fe6e3348f24e1a09f7d1a104087c3129b9a69b367c65f7cf79f.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            207,
+            718,
+            924
+        ],
+        "page_idx": 29
+    },
+    {
+        "type": "image",
+        "img_path": "images/ab989f92d1e95a0891cee8413381bd6a82ca5e8649c4195d3a9d1cd765b00bb0.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            98,
+            720,
+            806
+        ],
+        "page_idx": 30
+    },
+    {
+        "type": "image",
+        "img_path": "images/58dffff8198f4dca0be893d2ae2963b42404f3858854cc9e66182fbaee122c05.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            89,
+            718,
+            803
+        ],
+        "page_idx": 31
+    },
+    {
+        "type": "image",
+        "img_path": "images/97b0b5884eabe20fdeb62342892834496bf5e3484241d70e79bc7ceb3a0f6f51.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            90,
+            718,
+            804
+        ],
+        "page_idx": 32
+    },
+    {
+        "type": "image",
+        "img_path": "images/ad747ba62f54115aad4c9c9d7a2aceefeb2a112b3c2c93bc9cb290ded9971d60.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            92,
+            718,
+            803
+        ],
+        "page_idx": 33
+    },
+    {
+        "type": "image",
+        "img_path": "images/09de9001ce9572ea1cb93f126645c16837b4cae908473a4c65f88cee65cb999e.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            92,
+            718,
+            804
+        ],
+        "page_idx": 34
+    }
+]