Add files using upload-large-folder tool

parse/train/BJg4NgBKvH/BJg4NgBKvH.md

@@ -0,0 +1,233 @@
+# TRAINING BINARY NEURAL NETWORKS WITH REALTO-BINARY CONVOLUTIONS
+
+Brais Martinez1, Jing Yang1,2,\*, Adrian Bulat1,\* & Georgios Tzimiropoulos1,2
+
+1 Samsung AI Research Center, Cambridge, UK 2 Computer Vision Laboratory, The University of Nottingham, UK {brais.a,adrian.bulat,georgios.t}@samsung.com
+
+# ABSTRACT
+
+This paper shows how to train binary networks to within a few percent points $( \sim 3 - 5 \% )$ of the full precision counterpart. We first show how to build a strong baseline, which already achieves state-of-the-art accuracy, by combining recently proposed advances and carefully adjusting the optimization procedure. Secondly, we show that by attempting to minimize the discrepancy between the output of the binary and the corresponding real-valued convolution, additional significant accuracy gains can be obtained. We materialize this idea in two complementary ways: (1) with a loss function, during training, by matching the spatial attention maps computed at the output of the binary and real-valued convolutions, and (2) in a data-driven manner, by using the real-valued activations, available during inference prior to the binarization process, for re-scaling the activations right after the binary convolution. Finally, we show that, when putting all of our improvements together, the proposed model beats the current state of the art by more than $5 \%$ top-1 accuracy on ImageNet and reduces the gap to its realvalued counterpart to less than $3 \%$ and $5 \%$ top-1 accuracy on CIFAR-100 and ImageNet respectively when using a ResNet-18 architecture. Code available at https://github.com/brais-martinez/real2binary.
+
+# 1 INTRODUCTION
+
+Following the introduction of the BinaryNeuralNet (BNN) algorithm (Courbariaux et al., 2016), binary neural networks emerged as one of the most promising approaches for obtaining highly efficient neural networks that can be deployed on devices with limited computational resources. Binary convolutions are appealing mainly for two reasons: (a) Model compression: if the weights of the network are stored as bits in a 32-bit float, this implies a reduction of $3 2 \times$ in memory usage. (b) Computational speed-up: computationally intensive floating-point multiply and add operations are replaced by efficient xnor and pop-count operations, which have been shown to provide practical speed-ups of up to $5 8 \times$ on CPU (Rastegari et al., 2016) and, as opposed to general low bit-width operations, are amenable to standard hardware. Despite these appealing properties, binary neural networks have been criticized as binarization typically results in large accuracy drops. Thus, their deployment in practical scenarios is uncommon. For example, on ImageNet classification, there is a $\sim 1 8 \%$ gap in top-1 accuracy between a ResNet-18 and its binary counterpart when binarized with XNOR-Net (Rastegari et al., 2016), which is the method of choice for neural network binarization.
+
+But how far are we from training binary neural networks that are powerful enough to become a viable alternative to real-valued networks? Our first contribution in this work is to take stock of recent advances on binary neural networks and train a very strong baseline which already results in state-of-the-art performance. Our second contribution is a method for bridging most of the remaining gap, which boils down to minimizing the discrepancy between the output of the binary and the corresponding real-valued convolution. This idea is materialized in our work in two complementary ways: Firstly, we use an attention matching strategy so that the real-valued network can more closely guide the binary network during optimization. However, we show that due to the architectural discrepancies between the real and the binary networks, a direct application of teacher-student produces sub-optimal performance. Instead, we propose to use a sequence of teacher-student pairs that progressively bridges the architectural gap. Secondly, we further propose to use the real-valued activations of the binary network, available prior to the binarization preceding convolution, to compute scale factors that are used to re-scale the activations right after the application of the binary convolution. This is in line with recent works which have shown that re-scaling the binary convolution output can result in large performance gains (Rastegari et al., 2016; Bulat & Tzimiropoulos, 2019). However, unlike prior work, we compute the scaling factors in a data-driven manner based on the real-valued activations of each layer prior to binarization, which results in superior performance.
+
+![](images/dd8eb93919f6df00a97eca8a42b9931655439baef5d3ccbf0626594cd97c71a4.jpg)  
+Figure 1: Left: The proposed real-to-binary block. The diagram shows how spatial attention maps computed from a teacher real-valued network are matched with the ones computed from the binary network. Supervision is injected at the end of each binary block. See also section 4.2. Right: The proposed data-driven channel re-scaling approach. The left-hand side branch corresponds to the standard binary convolution module. The right-hand side branch corresponds to the proposed gating function that computes the channel-scaling factors from the output of the batch normalization. The factor $r$ controls the compression ratio on the gating function, and $H$ , $W$ and $C$ indicate the two spatial and the channel dimensions of the activation tensors. See also section 4.3.
+
+Overall, we make the following contributions:
+
+• We construct a very strong baseline by combining some recent insights on training binary networks and by performing a thorough experimentation to find the most well-suited optimization techniques. We show that this baseline already achieves state-of-the-art accuracy on ImageNet, surpassing all previously published works on binary networks.   
+We propose a real-to-binary attention matching: this entails that matching spatial attention maps computed at the output of the binary and real-valued convolutions is particularly suited for training binary neural networks (see Fig. 1 left and section 4.2). We also devise an approach in which the architectural gap between real and binary networks is progressively bridged through a sequence of teacher-student pairs.   
+We propose a data-driven channel re-scaling: this entails using the real-valued activations of the binary network prior to their binarization to compute the scale factors used to rescale the activations produced right after the application of the binary convolution. See Fig. 1, right, and section 4.3.   
+• We show that our combined contributions provide, for the first time, competitive results on two standard datasets, achieving $7 6 . 2 \%$ top-1 performance on CIFAR-100 and $6 5 . 4 \%$ top-1 performance on ImageNet when using a ResNet-18 –a gap bellow $3 \%$ and $5 \%$ respectively compared to their full precision counterparts.
+
+# 2 RELATED WORK
+
+While being pre-dated by other works on binary networks (Soudry et al., 2014), the BNN algorithm (Courbariaux et al., 2016) established how to train networks with binary weights within the familiar back-propagation paradigm. The training method relies on a real-valued copy of the network weights which is binarized during the forward pass, but is updated during back-propagation ignoring the binarization step. Unfortunately, BNN resulted in a staggering $\sim 2 8 \%$ gap in top-1 accuracy compared to the full precision ResNet-18 on ImageNet.
+
+It is worth noting that binary networks do have a number of floating point operations. In fact, the output of a binary convolution is not binary (values are integers resulting from the count). Also, in accordance to other low bit-width quantization methodologies, the first convolution (a costly $7 \times 7$ kernel in ResNet), the fully connected layer and the batch normalization layers are all real-valued. In consequence, a line of research has focused on developing methodologies that add a fractional amount of real-valued operations in exchange for significant accuracy gains. For example, the seminal work of XNOR-Net (Rastegari et al., 2016) proposed to add a real-valued scaling factor to each output channel of a binary convolution, a technique that has become standard for binary networks. Similarly, Bi-Real Net (Liu et al., 2018) argued that skip connections are fundamental for binary networks and observed that the flow of full precision activations provided by the skip connections is interrupted by the binary downsample convolutions. This degrades the signal and make subsequent skip connections less effective. To alleviate this, they proposed making the downsample layers real valued, obtaining around $3 \%$ accuracy increase in exchange for a small increase in computational complexity.
+
+Improving the optimization algorithm for binary networks has been another fundamental line of research. Examples include the use of smooth approximations of the gradient, the use of PReLU (Bulat et al., 2019), a two-stage training which binarizes the weights first and then the activations (Bulat et al., 2019) and progressive quantization (Gong et al., 2019; Bulat et al., 2019). The work in (Wang et al., 2019) proposed to learn channel correlations through reinforcement learning to better preserve the sign of a convolution output. A set of regularizers are added to the loss term in (Ding et al., 2019) so as to control the range of values of the activations, and guarantee good gradient flow. Other optimization aspects, such the effect of gradient clipping or batch-norm momentum, were empirically tested in (Alizadeh et al., 2019). In section 4.1, we show how to combine many of the insights provided in these works with standard optimization techniques to obtain a very strong baseline that already achieves state-of-the-art accuracy.
+
+While the aforementioned works either maintain the same computational cost, or increase it by a fractional amount, other research has focused instead on relaxing the problem constraints by increasing the number of binary operations by a large amount, typically a factor of 2 to 8 times. Examples include ABC-Net (Lin et al., 2017), the structure approximation of (Zhuang et al., 2019), the circulant CNN of (Liu et al., 2019), and the binary ensemble of (Zhu et al., 2019). Note that the large increase of binary operations diminishes the efficiency claim that justifies the use of binary networks in first place. Furthermore, we will show that there is still a lot of margin in order to bridge the accuracy gap prior to resorting to scaling up the network capacity1.
+
+The methodology proposed in this paper has some relations with prior work: our use of attention matching as described in section 4.2 is somewhat related to the feature distillation approach of (Zhuang et al., 2018). However, (Zhuang et al., 2018) tries to match whole feature maps of the to-be-quantized network with the quantized feature maps of a real-valued network that is trained in parallel with the to-be-quantized network. Such an approach is shown to improve training of low-bitwidth quantized models but not binary networks. Notably, our approach based on matching attention maps is much simpler and shown to be effective for the case of binary networks.
+
+Our data-driven channel re-scaling approach, described in section 4.3, is related to the channel rescaling approach of XNOR-Net, and also that of (Xu & Cheung, 2019; Bulat & Tzimiropoulos, 2019), which propose to learn the scale factors discriminatively through backpropagation. Contrary to (Xu & Cheung, 2019; Bulat & Tzimiropoulos, 2019), our method is data-driven and avoids using fixed scale factors learnt during training. Contrary to XNOR-Net, our method discriminatively learns how to produce the data-driven scale factors so that they are optimal for the task in hand.
+
+# 3 BACKGROUND
+
+This section reviews the binarization process proposed in (Courbariaux et al., 2016) and its improved version from (Rastegari et al., 2016), which is the method of choice for neural network binarization.
+
+We denote by $\mathcal { W } \in \mathbb { R } ^ { o \times c \times k \times k }$ and $\mathcal { A } \in \mathbb { R } ^ { c \times w _ { i n } \times h _ { i n } }$ the weights and input features of a CNN layer, where $o$ and $c$ represent the number of output and input channels, $k$ the width and height of the kernel, and $w _ { i n }$ and $h _ { i n }$ represent the spatial dimension of the input features $\mathcal { A }$ . In (Courbariaux et al., 2016), both weights and activations are binarized using the sign function and then convolution is performed as $\mathcal { A } \ast \mathcal { W } \approx \mathrm { s i g n } ( \mathcal { A } ) \circledast \mathrm { s i g n } ( \mathcal { W } )$ where $\circledast$ denotes the binary convolution, which can be implemented using bit-wise operations.
+
+However, this direct binarization approach introduces a high quantization error that leads to low accuracy. To alleviate this, XNOR-Net (Rastegari et al., 2016) proposes to use real-valued scaling factors to re-scale the output of the binary convolution as
+
+$$
+\mathcal { A } \ast \mathcal { W } \approx ( \mathrm { s i g n } ( \mathcal { A } ) \circledast \mathrm { s i g n } ( \mathcal { W } ) ) \odot \mathcal { K } \alpha ,
+$$
+
+where $\odot$ denotes the element-wise multiplication, $_ \alpha$ and $\kappa$ are the weight and activation scaling factors, respectively, calculated in Rastegari et al. (2016) in an analytic manner. More recently, Bulat & Tzimiropoulos (2019) proposed to fuse $_ { \pmb { \alpha } }$ and $\kappa$ into a single factor $\Gamma$ that is learned via backpropagation, resulting in further accuracy gains.
+
+# 4 METHOD
+
+This section firstly introduces our strong baseline. Then, we present two ways to improve the approximation of Eq. 1: Firstly, we use a loss based on matching attention maps computed from the binary and a real-valued network (see section 4.2). Secondly, we make the scaling factor a function of the real-valued input activations $\mathcal { A }$ (see section 4.3).
+
+# 4.1 BUILDING A STRONG BASELINE
+
+Currently, almost all works on binary networks use XNOR-Net and BNN as baselines. In this section, we show how to construct a strong baseline by incorporating insights and techniques described in recent works as well as standard optimization techniques. We show that our baseline already achieves state-of-the-art accuracy. We believe this is an important contribution towards understanding the true impact of proposed methodologies and towards assessing the true gap with real-valued networks. Following prior work in binary networks, we focus on the ResNet-18 architecture and apply the improvements listed below:
+
+Block structure: It is well-known that a modified ResNet block must be used to obtain optimal results for binary networks. We found the widely-used setting where the operations are ordered as BatchNorm Binarization BinaryConv Activation to be the best. The skip connection is the last operation of the block (Rastegari et al., 2016). Note that we use the sign function to binarize the activations. However, the BatchNorm layer includes an affine transformation and this ordering of the blocks allows its bias term act as a learnable binarization threshold.
+
+Residual learning: We used double skip connections, as proposed in (Liu et al., 2018).
+
+Activation: We used PReLU (He et al., 2015) as it is known to facilitate the training of binary networks (Bulat et al., 2019).
+
+Scaling factors: We used discriminatively learnt scaling factors via backpropagation as in (Bulat & Tzimiropoulos, 2019).
+
+Downsample layers: We used real-valued downsample layers (Liu et al., 2018). We found the large accuracy boost to be consistent across our experiments (around $3 - 4 \%$ top-1 improvement on ImageNet).
+
+We used the following training strategies to train our strong baseline:
+
+Initialization: When training binary networks, it is crucial to use a 2-stage optimization strategy (Bulat et al., 2019). In particular, we first train a network using binary activations and real-valued weights, and then use the resulting model as initialization to train a network where both weights and activations are binarized.
+
+Weight decay: Setting up weight decay carefully is surprisingly important. We use $1 e - 5$ when training stage 1 (binary activation and real weights network), and set it to 0 on stage 2 (Bethge et al., 2019). Note that weights at stage 2 are either 1 or $- 1$ , so applying an $L _ { 2 }$ regularization term to them does not make sense.
+
+Data augmentation: For CIFAR-100 we use the standard random crop, horizontal flip and rotation $( \pm 1 5 ^ { \circ } )$ . For ImageNet, we found that random cropping, flipping and colour jitter augmentation worked best. However, colour jitter is disabled for stage 2.
+
+Mix-up: We found that mix-up (Zhang et al., 2017) is crucial for CIFAR-100, while it slightly hurts performance for ImageNet – this is due to the higher risk of overfitting on CIFAR-100.
+
+Warm-up: We used warm-up for 5 epochs during stage 1 and no warm-up for stage 2.
+
+Optimizer: We used Adam (Kingma & Ba, 2014) with a stepwise scheduler. The learning rate is set to $1 e - 3$ for stage 1, and $2 e - 4$ for stage 2. For CIFAR-100, we trained for 350 epochs, with steps at epochs 150, 250 and 320. For ImageNet, we train for 75 epochs, with steps at epochs 40, 60 and 70. Batch sizes are 256 for ImageNet and 128 for CIFAR-100.
+
+# 4.2 REAL-TO-BINARY ATTENTION MATCHING
+
+We make the reasonable assumption that if a binary network is trained so that the output of each binary convolution more closely matches the output of a real convolution in the corresponding layer of a real-valued network, then significant accuracy gains can be obtained. Notably, a similar assumption was made in (Rastegari et al., 2016) where analytic scale factors were calculated so that the error between binary and real convolutions is minimized. Instead, and inspired by the attention transfer method of (Zagoruyko & Komodakis, 2017), we propose to enforce such a constraint via a loss term at the end of each convolutional block by comparing attention maps calculated from the binary and real-valued activations. Such supervisory signals provide the binary network with muchneeded extra guidance. It is also well-known that backpropagation for binary networks is not as effective as for real-valued ones. By introducing such loss terms at the end of each block, gradients do not have to traverse the whole network and suffer a degraded signal.
+
+Assuming that attention matching is applied at a set of $\mathcal { I }$ transfer points within the network, the total loss can be expressed as:
+
+$$
+\mathcal { L } _ { a t t } = \sum _ { j = 1 } ^ { \mathcal { I } } \Vert \frac { \mathcal { Q } _ { S } ^ { j } } { \Vert \mathcal { Q } _ { S } ^ { j } \Vert _ { 2 } } - \frac { \mathcal { Q } _ { T } ^ { j } } { \Vert \mathcal { Q } _ { T } ^ { j } \Vert _ { 2 } } \Vert ,
+$$
+
+where $\begin{array} { r } { \mathcal { Q } ^ { j } = \sum _ { i = 1 } ^ { c } | \mathcal { A } _ { i } | ^ { 2 } } \end{array}$ and $A _ { i }$ is the $i -$ th channel of activation map $\mathcal { A }$ . Moreover, at the end of the network, we apply a standard logit matching loss (Hinton et al., 2015).
+
+Progressive teacher-student: We observed that teacher and student having as similar architecture as possible is very important in our case. We thus train a sequence of teacher-student pairs that progressively bridges the differences between the real network and the binary network in small increments:
+
+Step 1: the teacher is the real-valued network with the standard ResNet architecture. The student is another real-valued network, but with the same architecture as the binary ResNet-18 (e.g. double skip connection, layer ordering, PReLU activations, etc). Furthermore, a soft binarization (a Tanh function) is applied to the activations instead of the binarization (sign) function. In this way the network is still real-valued, but it behaves more closely to a network with binary activations.
+
+Step 2: The network resulting from the previous step is used as the teacher. A network with binary activations and real-valued weights is used as the student.
+
+Step 3: The network resulting from step 2 is used as the teacher and the network with binary weights and binary activations is the student. In this stage, only logit matching is used.
+
+# 4.3 DATA-DRIVEN CHANNEL RE-SCALING
+
+While the approach of the previous section provides better guidance for the training of binary networks, the representation power of binary convolutions is still limited, hindering its capacity to approximate the real-valued network. Here we describe how to boost the representation capability of a binary neural network and yet incur in only a negligible increment on the number of operations.
+
+Previous works have shown the effectiveness of re-scaling binary convolutions with the goal of better approximating real convolutions. XNOR-Net (Rastegari et al., 2016) proposed to compute these scale factors analytically while (Bulat & Tzimiropoulos, 2019; Xu & Cheung, 2019) proposed to learn them discriminatively in an end-to-end manner, showing additional accuracy gains. For the latter case, during training, the optimization aims to find a set of fixed scaling factors that minimize the average expected loss for the training set. We propose instead to go beyond this and obtain discriminatively-trained input-dependent scaling factors – thus, at test time, these scaling factors will not be fixed but rather inferred from data.
+
+Let us first recall what the signal flow is when going through a binary block. The activations entering a binary block are actually real-valued. Batch normalization centers the activations, which are then binarized, losing a large amount of information. Binary convolution, re-scaling and PReLU follow. We propose to use the full-precision activation signal, available prior to the large information loss incurred by the binarization operation, to predict the scaling factors used to re-scale the output of the binary convolution channel-wise. Specifically, we propose to approximate the real convolution as follows:
+
+$$
+\mathcal { A } \ast \mathcal { W } \approx ( \mathrm { s i g n } ( \mathcal { A } ) \circledast \mathrm { s i g n } ( \mathcal { W } ) ) \odot \alpha \odot G ( \mathcal { A } ; \mathcal { W } _ { G } ) ,
+$$
+
+where $\mathcal { W } _ { G }$ are the parameters of the gating function $G$ . Such function computes the scale factors used to re-scale the output of the binary convolution, and uses the pre-convolution real-valued activations as input. Fig. 1 shows our implementation of function $G$ . The design is inspired by Hu et al. (2018), but we use the gating function to predict ahead rather than as a self-attention mechanism.
+
+An optimal mechanism to modulate the output of the binary convolution clearly should not be the same for all examples as in Bulat & Tzimiropoulos (2019) or Xu & Cheung (2019). Note that in Rastegari et al. (2016) the computation of the scale factors depends on the input activations. However the analytic calculation is sub-optimal with respect to the task at hand. To circumvent the aforementioned problems, our method learns, via backpropagation for the task at hand, to predict the modulating factors using the real-valued input activations. By doing so, more than $1 / 3$ of the remaining gap with the real-valued network is bridged.
+
+# 4.4 COMPUTATIONAL COST ANALYSIS
+
+Table 1 details the computational cost of the different binary network methodologies. We differentiate between the number of binary and floating point operations, including operations such as skip connections, pooling layers, etc. It shows that our method leaves the number of binary operations constant, and that the number of FLOPs increases by only $1 \%$ of the total floating point operation count. This is assuming a factor $r$ of 8, which is the one used in all of our experiments. To put this into perspective, the magnitude is similar to the operation increase incurred by the XNOR-Net with respect to its predecessor, BNN. Similarly, the double skip connections proposed in (Liu et al., 2018) adds again a comparable amount of operations. Note however that in order to fully exploit the computational efficiency of binary convolutions during inference, a specialized engine such as (Zhang et al., 2019; Yang et al., 2017) is required.
+
+# 5 RESULTS
+
+We present two main sets of experiments. We used ImageNet (Russakovsky et al., 2015) as a benchmark to compare our method against other state-of-the-art approaches in Sec. 5.1. ImageNet is the most widely used dataset to report results on binary networks and, at the same time, allows us to show for the first time that binary networks can perform competitively on a large-scale dataset. We further used CIFAR-100 (Krizhevsky & Hinton, 2009) to conduct ablation studies (Sec. 5.2).
+
+Table 1: Breakdown of floating point and binary operations for variants of binary ResNet-18.   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>BOPS</td><td rowspan=1 colspan=1>FLOPS</td></tr><tr><td rowspan=1 colspan=1>BNN (Courbariaux et al., 2016)XNOR-Net (Rastegari et al., 2016)Double Skip ((Liu et al., 2018)Bi-Real (Liu et al.,2018)Ours</td><td rowspan=1 colspan=1>1.695×1091.695×1091.695×1091.676×1091.676×109</td><td rowspan=1 colspan=1>1.314×1081.333×1081.351×1081.544×1081.564×108</td></tr><tr><td rowspan=1 colspan=1>Full Precision</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1.826×109</td></tr></table>
+
+# 5.1 COMPARISON WITH THE STATE-OF-THE-ART
+
+Table 2 shows a comparison between our method and relevant state-of-the-art methods, including low-bit quantization methods other than binary.
+
+Vs. other binary networks: Our strong baseline already comfortably achieves state-of-the art results, surpassing the previously best-reported result by about $1 \%$ (Wang et al., 2019). Our full method further improves over the state-of-the-art by $5 . 5 \%$ top-1 accuracy. When comparing to binary models that scale the capacity of the network (second set of results on Tab. 2), only (Zhuang et al., 2019) outperforms our method, surpassing it by $0 . 9 \%$ top-1 accuracy - yet, this is achieved using 4 times the number of binary blocks.
+
+Vs. real-valued networks: Our method reduces the performance gap with its real-valued counterpart to $\sim 4 \%$ top-1 accuracy, or $\sim 5 \%$ if we compare against a real-valued network trained with attention transfer.
+
+Vs. other low-bit quantization: Table 2 also shows a comparison to the state-of-the-art for low-bit quantization methods (first set of results). It can be seen that our method surpasses the performance of all methods, except for TTQ (Zhu et al., 2017), which uses 2-bit weights, full-precision activations and 1.5 the channel width at each layer.
+
+# 5.2 ABLATION STUDIES
+
+In order to conduct a more detailed ablation study we provide results on CIFAR-100. We thoroughly optimized a ResNet-18 full precision network to serve as the real-valued baseline.
+
+Teacher-Student effectiveness: We trained a real-valued ResNet-18 using ResNet-34 as its teacher, yielding $\sim 1 \%$ top-1 accuracy increase. Instead, our progressive teacher-student strategy yields $\sim 5 \%$ top-1 accuracy gain, showing that it is a fundamental tool when training binary networks, and that its impact is much larger than for real-valued networks, where the baseline optimization is already healthier.
+
+Performance gap to real-valued: We observe that, for CIFAR-100, we close the gap with realvalued networks to about $2 \%$ when comparing with the full-precision ResNet-18, and to about $3 \%$ when optimized using teacher supervision. The gap is consistent to that on ImageNet in relative terms: $\mathrm { { 1 3 \% } }$ and $1 0 \%$ relative degradation on ImageNet and CIFAR-100 respectively.
+
+Binary vs real downsample: Our proposed method achieves similar performance increase irrespective of whether binary or real-valued downsample layers are used, the improvement being $5 . 5 \%$ and $6 . 6 \%$ top-1 accuracy gain respectively. It is also interesting to note that the results on the ablation study are consistent for all entries on both cases.
+
+Scaling factors and attention matching: It is also noteworthy that the gating module is not effective in the absence of attention matching (see $\mathrm { \bf S B + G }$ entries). It seems clear from this result that both are interconnected: the extra supervisory signal is necessary to properly guide the training, while the extra flexibility added through the gating mechanism boosts the capacity of the network to mimic the attention map.
+
+Table 2: Comparison with state-of-the-art methods on ImageNet. \*\* indicates real-valued downsample. The second column indicates the number of bits used to represent weights and activations. Methods include low-bit quantization (upper section), and methods multiplying the capacity of the network (second section). For the latter case, the second column includes the multiplicative factor of the network capacity used.   
+
+<table><tr><td rowspan=2 colspan=1>Method</td><td rowspan=1 colspan=3>ImageNet</td></tr><tr><td rowspan=1 colspan=1>Bitwidth (W/A)</td><td rowspan=1 colspan=1>Top-1</td><td rowspan=1 colspan=1>Top-5</td></tr><tr><td rowspan=6 colspan=1>BWN (Rastegari et al., 2016)TTQ (Zhu et al., 2017)HWGQ (Cai et al., 2017)LQ-Net (Zhang et al., 2018)SYQ (Faraone et al., 2018)DOREFA-Net (Zhou et al.,2016)</td><td rowspan=1 colspan=1>1/32</td><td rowspan=1 colspan=1>60.8</td><td rowspan=1 colspan=1>83.0</td></tr><tr><td rowspan=2 colspan=1>2/321/2</td><td rowspan=1 colspan=1>66.6</td><td rowspan=1 colspan=1>87.2</td></tr><tr><td rowspan=1 colspan=1>59.6</td><td rowspan=1 colspan=1>82.2</td></tr><tr><td rowspan=3 colspan=1>1/21/22/2</td><td rowspan=1 colspan=1>62.6</td><td rowspan=1 colspan=1>84.3</td></tr><tr><td rowspan=1 colspan=1>55.4</td><td rowspan=1 colspan=1>78.6</td></tr><tr><td rowspan=1 colspan=1>62.6</td><td rowspan=1 colspan=1>84.4</td></tr><tr><td rowspan=4 colspan=1>ABC-Net (Lin et al., 2017)Circulant CNN (Liu et al., 2019)Struct Appr (Zhuang et al., 2019)Struct Appr** (Zhuang et al., 2019)Ensemble (Zhu et al., 2019)</td><td rowspan=1 colspan=1>(1/1)×5</td><td rowspan=1 colspan=1>65.0</td><td rowspan=1 colspan=1>85.9</td></tr><tr><td rowspan=2 colspan=1>(1/1)×4(1/1)×4</td><td rowspan=1 colspan=1>61.4</td><td rowspan=1 colspan=1>82.8</td></tr><tr><td rowspan=1 colspan=1>64.2</td><td rowspan=1 colspan=1>85.6</td></tr><tr><td rowspan=1 colspan=1>(1/1)x4(1/1)×6</td><td rowspan=1 colspan=1>66.361.0</td><td rowspan=1 colspan=1>86.61</td></tr><tr><td rowspan=3 colspan=1>BNN (Courbariaux et al., 2016)XNOR-Net (Rastegari et al., 2016)Trained Bin (Xu &amp; Cheung,2019)Bi-Real Net (Liu et al., 2018)**CI-Net (Wang et al., 2019)XNOR-Net++ (Bulat &amp; Tzimiropoulos,2019)CI-Net (Wang et al., 2019)**</td><td rowspan=2 colspan=1>1/11/11/11/1</td><td rowspan=2 colspan=1>42.251.254.256.4</td><td rowspan=1 colspan=1>69.273.277.9</td></tr><tr><td rowspan=2 colspan=1>56.456.757.159.9</td><td rowspan=2 colspan=1>79.580.179.984.2</td></tr><tr><td rowspan=1 colspan=1>1/11/11/1</td></tr><tr><td rowspan=2 colspan=1>Strong Baseline (ours)**Real-to-Bin (ours)**</td><td rowspan=1 colspan=1>1/1</td><td rowspan=1 colspan=1>60.9</td><td rowspan=1 colspan=1>83.0</td></tr><tr><td rowspan=1 colspan=1>1/1</td><td rowspan=1 colspan=1>65.4</td><td rowspan=1 colspan=1>86.2</td></tr><tr><td rowspan=1 colspan=1>Real valuedReal valued T-S</td><td rowspan=1 colspan=1>32/3232/32</td><td rowspan=1 colspan=1>69.370.7</td><td rowspan=1 colspan=1>89.290.0</td></tr></table>
+
+Table 3: Top-1 and Top-5 classification accuracy using ResNet-18 on CIFAR-100. \*\* indicates real-valued downsample layers. $G$ indicates that the gating function of Sec. 4.3 is used.   
+
+<table><tr><td rowspan=2 colspan=1>Method</td><td rowspan=1 colspan=1>Stage 1</td><td rowspan=1 colspan=1>Stage 2</td></tr><tr><td rowspan=1 colspan=1>Top-1/Top-5</td><td rowspan=1 colspan=1>Top-1/Top-5</td></tr><tr><td rowspan=1 colspan=1>Strong BaselineSB + Att TransSB + Att Trans + HKDSB +GSB + Progressive TSReal-to-Bin</td><td rowspan=1 colspan=1>69.3/88.772.2 /90.373.1 /91.267.2 / 87.073.8 /91.575.0 /92.2</td><td rowspan=1 colspan=1>68.0/88.371.1/90.171.9 /90.966.2 / 86.872.3 / 89.873.5 / 91.6</td></tr><tr><td rowspan=1 colspan=1>Strong Baseline**SB + Att Trans**SB+Att Trans + HKD**SB + G**SB + Progressive TS**Real-to-Bin**</td><td rowspan=1 colspan=1>72.1/89.974.3 /91.375.4 /92.272.0 /89.875.7 /92.176.5 /92.8</td><td rowspan=1 colspan=1>69.6/89.272.6 /91.473.9 /91.270.9 / 89.374.6 / 91.876.2 / 92.7</td></tr><tr><td rowspan=1 colspan=1>Full Prec (our impl.)Full Prec + TS (our impl.)</td><td rowspan=1 colspan=2>78.3/93.679.3 /94.4</td></tr></table>
+
+# 6 CONCLUSION
+
+In this work we showed how to train binary networks to within a few percent points of their realvalued counterpart, turning binary networks from hopeful research into a compelling alternative to real-valued networks. We did so by training a binary network to not only predict training labels, but also mimic the behaviour of real-valued networks. To this end, we devised a progressive attention matching strategy to drive optimization, and combined it with a gating strategy for scaling the output of binary convolutions, increasing the representation power of the convolutional block. The two strategies combine perfectly to boost the state-of-the-art of binary networks by 5.5 top-1 accuracy on ImageNet, the standard benchmark for binary networks.
+
+# REFERENCES
+
+Milad Alizadeh, Javier Fernandez-Marqu ´ es, Nicholas D. Lane, and Yarin Gal. An empirical study of ´ binary neural networks’ optimisation. In International Conference on Learning Representations, 2019.
+
+Joseph Bethge, Haojin Yang, Marvin Bornstein, and Christoph Meinel. Back to simplicity: How to train accurate BNNs from scratch? arXiv preprint arXiv:1906.08637, 2019.
+
+Adrian Bulat and Georgios Tzimiropoulos. XNOR-Net $^ { + + }$ : Improved binary neural networks. In British Machine Vision Conference, 2019.
+
+Adrian Bulat, Georgios Tzimiropoulos, Jean Kossaifi, and Maja Pantic. Improved training of binary networks for human pose estimation and image recognition. arXiv preprint arXiv:1904.05868, 2019.
+
+Zhaowei Cai, Xiaodong He, Jian Sun, and Nuno Vasconcelos. Deep learning with low precision by half-wave gaussian quantization. In IEEE Conference on Computer Vision and Pattern Recognition, 2017.
+
+Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training deep neural networks with weights and activations constrained to $+ 1$ or-1. arXiv, 2016.
+
+Ruizhou Ding, Ting-Wu Chin, Zeye Liu, and Diana Marculescu. Regularizing activation distribution for training binarized deep networks. In IEEE Conference on Computer Vision and Pattern Recognition, 2019.
+
+Julian Faraone, Nicholas J. Fraser, Michaela Blott, and Philip H. W. Leong. SYQ: learning symmetric quantization for efficient deep neural networks. In IEEE Conference on Computer Vision and Pattern Recognition, 2018.
+
+Ruihao Gong, Xianglong Liu, Shenghu Jiang, Tianxiang Li, Peng Hu, Jiazhen Lin, Fengwei Yu, and Junjie Yan. Differentiable soft quantization: Bridging full-precision and low-bit neural networks. arXiv, 2019.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In IEEE International Conference on Computer Vision, pp. 1026–1034, 2015.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Jie Hu, Li Shen, and Gang Sun. Squeeze-and-excitation networks. In IEEE Conference on Computer Vision and Pattern Recognition, 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Xiaofan Lin, Cong Zhao, and Wei Pan. Towards accurate binary convolutional neural network. In Advances on Neural Information Processing Systems, 2017.
+
+Chunlei Liu, Wenrui Ding, Xin Xia, Baochang Zhang, Jiaxin Gu, Jianzhuang Liu, Rongrong Ji, and David Doermann. Circulant binary convolutional networks: Enhancing the performance of 1-bit dcnns with circulant back propagation. In IEEE Conference on Computer Vision and Pattern Recognition, 2019.
+
+Zechun Liu, Baoyuan Wu, Wenhan Luo, Xin Yang, Wei Liu, and Kwang-Ting Cheng. Bi-Real Net: Enhancing the performance of 1-bit CNNs with improved representational capability and advanced training algorithm. In European Conference on Computer Vision, 2018.
+
+Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-Net: Imagenet classification using binary convolutional neural networks. In European Conference on Computer Vision, 2016.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li FeiFei. ImageNet Large Scale Visual Recognition Challenge. International Journal on Computer Vision, 115(3):211–252, 2015.
+
+Daniel Soudry, Itay Hubara, and Ron Meir. Expectation backpropagation: Parameter-free training of multilayer neural networks with continuous or discrete weights. In Advances on Neural Information Processing Systems, 2014.
+
+Ziwei Wang, Jiwen Lu, Chenxin Tao, Jie Zhou, and Qi Tian. Learning channel-wise interactions for binary convolutional neural networks. In IEEE Conference on Computer Vision and Pattern Recognition, 2019.
+
+Zhe Xu and Ray C.C. Cheung. Accurate and compact convolutional neural networks with trained binarization. In British Machine Vision Conference, 2019.
+
+Haojin Yang, Martin Fritzsche, Christian Bartz, and Christoph Meinel. BMXNet: An open-source binary neural network implementation based on MXNet. In ACM International Conference on Multimedia, 2017.
+
+Sergey Zagoruyko and Nikos Komodakis. Paying more attention to attention: Improving the performance of convolutional neural networks via attention transfer. In International Conference on Learning Representations, 2017.
+
+Dongqing Zhang, Jiaolong Yang, Dongqiangzi Ye, and Gang Hua. LQ-Nets: Learned quantization for highly accurate and compact deep neural networks. In European Conference on Computer Vision, 2018.
+
+Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. Mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017.
+
+Jianhao Zhang, Yingwei Pan, Ting Yao, He Zhao, and Tao Mei. dabnn: A super fast inference framework for binary neural networks on ARM devices. In ACM International Conference on Multimedia, 2019.
+
+Shuchang Zhou, Yuxin Wu, Zekun Ni, Xinyu Zhou, He Wen, and Yuheng Zou. DoReFa-Net: Training low bitwidth convolutional neural networks with low bitwidth gradients. arXiv, 2016.
+
+Chenzhuo Zhu, Song Han, Huizi Mao, and William J Dally. Trained ternary quantization. International Conference on Learning Representations, 2017.
+
+Shilin Zhu, Xin Dong, and Hao Su. Binary ensemble neural network: More bits per network or more networks per bit? In IEEE Conference on Computer Vision and Pattern Recognition, 2019.
+
+Bohan Zhuang, Chunhua Shen, Mingkui Tan, Lingqiao Liu, and Ian D. Reid. Towards effective low-bitwidth convolutional neural networks. In IEEE Conference on Computer Vision and Pattern Recognition, 2018.
+
+Bohan Zhuang, Chunhua Shen, Mingkui Tan, Lingqiao Liu, and Ian Reid. Structured binary neural networks for accurate image classification and semantic segmentation. In IEEE Conference on Computer Vision and Pattern Recognition, 2019.

parse/train/BJg4NgBKvH/BJg4NgBKvH_content_list.json

@@ -0,0 +1,1263 @@
+[
+    {
+        "type": "text",
+        "text": "TRAINING BINARY NEURAL NETWORKS WITH REALTO-BINARY CONVOLUTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            112,
+            820,
+            160
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Brais Martinez1, Jing Yang1,2,\\*, Adrian Bulat1,\\* & Georgios Tzimiropoulos1,2 ",
+        "bbox": [
+            184,
+            181,
+            715,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Samsung AI Research Center, Cambridge, UK 2 Computer Vision Laboratory, The University of Nottingham, UK {brais.a,adrian.bulat,georgios.t}@samsung.com ",
+        "bbox": [
+            184,
+            200,
+            622,
+            242
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            279,
+            544,
+            292
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper shows how to train binary networks to within a few percent points $( \\sim 3 - 5 \\% )$ of the full precision counterpart. We first show how to build a strong baseline, which already achieves state-of-the-art accuracy, by combining recently proposed advances and carefully adjusting the optimization procedure. Secondly, we show that by attempting to minimize the discrepancy between the output of the binary and the corresponding real-valued convolution, additional significant accuracy gains can be obtained. We materialize this idea in two complementary ways: (1) with a loss function, during training, by matching the spatial attention maps computed at the output of the binary and real-valued convolutions, and (2) in a data-driven manner, by using the real-valued activations, available during inference prior to the binarization process, for re-scaling the activations right after the binary convolution. Finally, we show that, when putting all of our improvements together, the proposed model beats the current state of the art by more than $5 \\%$ top-1 accuracy on ImageNet and reduces the gap to its realvalued counterpart to less than $3 \\%$ and $5 \\%$ top-1 accuracy on CIFAR-100 and ImageNet respectively when using a ResNet-18 architecture. Code available at https://github.com/brais-martinez/real2binary. ",
+        "bbox": [
+            233,
+            311,
+            764,
+            547
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            578,
+            336,
+            594
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Following the introduction of the BinaryNeuralNet (BNN) algorithm (Courbariaux et al., 2016), binary neural networks emerged as one of the most promising approaches for obtaining highly efficient neural networks that can be deployed on devices with limited computational resources. Binary convolutions are appealing mainly for two reasons: (a) Model compression: if the weights of the network are stored as bits in a 32-bit float, this implies a reduction of $3 2 \\times$ in memory usage. (b) Computational speed-up: computationally intensive floating-point multiply and add operations are replaced by efficient xnor and pop-count operations, which have been shown to provide practical speed-ups of up to $5 8 \\times$ on CPU (Rastegari et al., 2016) and, as opposed to general low bit-width operations, are amenable to standard hardware. Despite these appealing properties, binary neural networks have been criticized as binarization typically results in large accuracy drops. Thus, their deployment in practical scenarios is uncommon. For example, on ImageNet classification, there is a $\\sim 1 8 \\%$ gap in top-1 accuracy between a ResNet-18 and its binary counterpart when binarized with XNOR-Net (Rastegari et al., 2016), which is the method of choice for neural network binarization. ",
+        "bbox": [
+            173,
+            612,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "But how far are we from training binary neural networks that are powerful enough to become a viable alternative to real-valued networks? Our first contribution in this work is to take stock of recent advances on binary neural networks and train a very strong baseline which already results in state-of-the-art performance. Our second contribution is a method for bridging most of the remaining gap, which boils down to minimizing the discrepancy between the output of the binary and the corresponding real-valued convolution. This idea is materialized in our work in two complementary ways: Firstly, we use an attention matching strategy so that the real-valued network can more closely guide the binary network during optimization. However, we show that due to the architectural discrepancies between the real and the binary networks, a direct application of teacher-student produces sub-optimal performance. Instead, we propose to use a sequence of teacher-student pairs that progressively bridges the architectural gap. Secondly, we further propose to use the real-valued activations of the binary network, available prior to the binarization preceding convolution, to compute scale factors that are used to re-scale the activations right after the application of the binary convolution. This is in line with recent works which have shown that re-scaling the binary convolution output can result in large performance gains (Rastegari et al., 2016; Bulat & Tzimiropoulos, 2019). However, unlike prior work, we compute the scaling factors in a data-driven manner based on the real-valued activations of each layer prior to binarization, which results in superior performance. ",
+        "bbox": [
+            174,
+            799,
+            823,
+            897
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/dd8eb93919f6df00a97eca8a42b9931655439baef5d3ccbf0626594cd97c71a4.jpg",
+        "image_caption": [
+            "Figure 1: Left: The proposed real-to-binary block. The diagram shows how spatial attention maps computed from a teacher real-valued network are matched with the ones computed from the binary network. Supervision is injected at the end of each binary block. See also section 4.2. Right: The proposed data-driven channel re-scaling approach. The left-hand side branch corresponds to the standard binary convolution module. The right-hand side branch corresponds to the proposed gating function that computes the channel-scaling factors from the output of the batch normalization. The factor $r$ controls the compression ratio on the gating function, and $H$ , $W$ and $C$ indicate the two spatial and the channel dimensions of the activation tensors. See also section 4.3. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            215,
+            101,
+            782,
+            327
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            487,
+            825,
+            626
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Overall, we make the following contributions: ",
+        "bbox": [
+            173,
+            632,
+            482,
+            647
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We construct a very strong baseline by combining some recent insights on training binary networks and by performing a thorough experimentation to find the most well-suited optimization techniques. We show that this baseline already achieves state-of-the-art accuracy on ImageNet, surpassing all previously published works on binary networks.   \nWe propose a real-to-binary attention matching: this entails that matching spatial attention maps computed at the output of the binary and real-valued convolutions is particularly suited for training binary neural networks (see Fig. 1 left and section 4.2). We also devise an approach in which the architectural gap between real and binary networks is progressively bridged through a sequence of teacher-student pairs.   \nWe propose a data-driven channel re-scaling: this entails using the real-valued activations of the binary network prior to their binarization to compute the scale factors used to rescale the activations produced right after the application of the binary convolution. See Fig. 1, right, and section 4.3.   \n• We show that our combined contributions provide, for the first time, competitive results on two standard datasets, achieving $7 6 . 2 \\%$ top-1 performance on CIFAR-100 and $6 5 . 4 \\%$ top-1 performance on ImageNet when using a ResNet-18 –a gap bellow $3 \\%$ and $5 \\%$ respectively compared to their full precision counterparts. ",
+        "bbox": [
+            214,
+            661,
+            825,
+            915
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            339,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While being pre-dated by other works on binary networks (Soudry et al., 2014), the BNN algorithm (Courbariaux et al., 2016) established how to train networks with binary weights within the familiar back-propagation paradigm. The training method relies on a real-valued copy of the network weights which is binarized during the forward pass, but is updated during back-propagation ignoring the binarization step. Unfortunately, BNN resulted in a staggering $\\sim 2 8 \\%$ gap in top-1 accuracy compared to the full precision ResNet-18 on ImageNet. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            223
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "It is worth noting that binary networks do have a number of floating point operations. In fact, the output of a binary convolution is not binary (values are integers resulting from the count). Also, in accordance to other low bit-width quantization methodologies, the first convolution (a costly $7 \\times 7$ kernel in ResNet), the fully connected layer and the batch normalization layers are all real-valued. In consequence, a line of research has focused on developing methodologies that add a fractional amount of real-valued operations in exchange for significant accuracy gains. For example, the seminal work of XNOR-Net (Rastegari et al., 2016) proposed to add a real-valued scaling factor to each output channel of a binary convolution, a technique that has become standard for binary networks. Similarly, Bi-Real Net (Liu et al., 2018) argued that skip connections are fundamental for binary networks and observed that the flow of full precision activations provided by the skip connections is interrupted by the binary downsample convolutions. This degrades the signal and make subsequent skip connections less effective. To alleviate this, they proposed making the downsample layers real valued, obtaining around $3 \\%$ accuracy increase in exchange for a small increase in computational complexity. ",
+        "bbox": [
+            174,
+            231,
+            825,
+            424
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Improving the optimization algorithm for binary networks has been another fundamental line of research. Examples include the use of smooth approximations of the gradient, the use of PReLU (Bulat et al., 2019), a two-stage training which binarizes the weights first and then the activations (Bulat et al., 2019) and progressive quantization (Gong et al., 2019; Bulat et al., 2019). The work in (Wang et al., 2019) proposed to learn channel correlations through reinforcement learning to better preserve the sign of a convolution output. A set of regularizers are added to the loss term in (Ding et al., 2019) so as to control the range of values of the activations, and guarantee good gradient flow. Other optimization aspects, such the effect of gradient clipping or batch-norm momentum, were empirically tested in (Alizadeh et al., 2019). In section 4.1, we show how to combine many of the insights provided in these works with standard optimization techniques to obtain a very strong baseline that already achieves state-of-the-art accuracy. ",
+        "bbox": [
+            173,
+            431,
+            825,
+            583
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While the aforementioned works either maintain the same computational cost, or increase it by a fractional amount, other research has focused instead on relaxing the problem constraints by increasing the number of binary operations by a large amount, typically a factor of 2 to 8 times. Examples include ABC-Net (Lin et al., 2017), the structure approximation of (Zhuang et al., 2019), the circulant CNN of (Liu et al., 2019), and the binary ensemble of (Zhu et al., 2019). Note that the large increase of binary operations diminishes the efficiency claim that justifies the use of binary networks in first place. Furthermore, we will show that there is still a lot of margin in order to bridge the accuracy gap prior to resorting to scaling up the network capacity1. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            703
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The methodology proposed in this paper has some relations with prior work: our use of attention matching as described in section 4.2 is somewhat related to the feature distillation approach of (Zhuang et al., 2018). However, (Zhuang et al., 2018) tries to match whole feature maps of the to-be-quantized network with the quantized feature maps of a real-valued network that is trained in parallel with the to-be-quantized network. Such an approach is shown to improve training of low-bitwidth quantized models but not binary networks. Notably, our approach based on matching attention maps is much simpler and shown to be effective for the case of binary networks. ",
+        "bbox": [
+            174,
+            709,
+            825,
+            806
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our data-driven channel re-scaling approach, described in section 4.3, is related to the channel rescaling approach of XNOR-Net, and also that of (Xu & Cheung, 2019; Bulat & Tzimiropoulos, 2019), which propose to learn the scale factors discriminatively through backpropagation. Contrary to (Xu & Cheung, 2019; Bulat & Tzimiropoulos, 2019), our method is data-driven and avoids using fixed scale factors learnt during training. Contrary to XNOR-Net, our method discriminatively learns how to produce the data-driven scale factors so that they are optimal for the task in hand. ",
+        "bbox": [
+            174,
+            814,
+            823,
+            869
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            152,
+            326,
+            170
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This section reviews the binarization process proposed in (Courbariaux et al., 2016) and its improved version from (Rastegari et al., 2016), which is the method of choice for neural network binarization. ",
+        "bbox": [
+            174,
+            184,
+            823,
+            213
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We denote by $\\mathcal { W } \\in \\mathbb { R } ^ { o \\times c \\times k \\times k }$ and $\\mathcal { A } \\in \\mathbb { R } ^ { c \\times w _ { i n } \\times h _ { i n } }$ the weights and input features of a CNN layer, where $o$ and $c$ represent the number of output and input channels, $k$ the width and height of the kernel, and $w _ { i n }$ and $h _ { i n }$ represent the spatial dimension of the input features $\\mathcal { A }$ . In (Courbariaux et al., 2016), both weights and activations are binarized using the sign function and then convolution is performed as $\\mathcal { A } \\ast \\mathcal { W } \\approx \\mathrm { s i g n } ( \\mathcal { A } ) \\circledast \\mathrm { s i g n } ( \\mathcal { W } )$ where $\\circledast$ denotes the binary convolution, which can be implemented using bit-wise operations. ",
+        "bbox": [
+            174,
+            218,
+            825,
+            304
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, this direct binarization approach introduces a high quantization error that leads to low accuracy. To alleviate this, XNOR-Net (Rastegari et al., 2016) proposes to use real-valued scaling factors to re-scale the output of the binary convolution as ",
+        "bbox": [
+            174,
+            310,
+            825,
+            353
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9f7a1fe3ef694e43d70b827d9be5d8c219e5b5c4a85eee9a87a6eb821fd15178.jpg",
+        "text": "$$\n\\mathcal { A } \\ast \\mathcal { W } \\approx ( \\mathrm { s i g n } ( \\mathcal { A } ) \\circledast \\mathrm { s i g n } ( \\mathcal { W } ) ) \\odot \\mathcal { K } \\alpha ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            361,
+            632,
+            378
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\odot$ denotes the element-wise multiplication, $_ \\alpha$ and $\\kappa$ are the weight and activation scaling factors, respectively, calculated in Rastegari et al. (2016) in an analytic manner. More recently, Bulat & Tzimiropoulos (2019) proposed to fuse $_ { \\pmb { \\alpha } }$ and $\\kappa$ into a single factor $\\Gamma$ that is learned via backpropagation, resulting in further accuracy gains. ",
+        "bbox": [
+            174,
+            385,
+            825,
+            441
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            462,
+            282,
+            478
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This section firstly introduces our strong baseline. Then, we present two ways to improve the approximation of Eq. 1: Firstly, we use a loss based on matching attention maps computed from the binary and a real-valued network (see section 4.2). Secondly, we make the scaling factor a function of the real-valued input activations $\\mathcal { A }$ (see section 4.3). ",
+        "bbox": [
+            174,
+            494,
+            825,
+            551
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 BUILDING A STRONG BASELINE",
+        "text_level": 1,
+        "bbox": [
+            176,
+            569,
+            433,
+            583
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Currently, almost all works on binary networks use XNOR-Net and BNN as baselines. In this section, we show how to construct a strong baseline by incorporating insights and techniques described in recent works as well as standard optimization techniques. We show that our baseline already achieves state-of-the-art accuracy. We believe this is an important contribution towards understanding the true impact of proposed methodologies and towards assessing the true gap with real-valued networks. Following prior work in binary networks, we focus on the ResNet-18 architecture and apply the improvements listed below: ",
+        "bbox": [
+            173,
+            594,
+            825,
+            693
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Block structure: It is well-known that a modified ResNet block must be used to obtain optimal results for binary networks. We found the widely-used setting where the operations are ordered as BatchNorm Binarization BinaryConv Activation to be the best. The skip connection is the last operation of the block (Rastegari et al., 2016). Note that we use the sign function to binarize the activations. However, the BatchNorm layer includes an affine transformation and this ordering of the blocks allows its bias term act as a learnable binarization threshold. ",
+        "bbox": [
+            173,
+            698,
+            825,
+            784
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Residual learning: We used double skip connections, as proposed in (Liu et al., 2018). ",
+        "bbox": [
+            174,
+            790,
+            743,
+            804
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Activation: We used PReLU (He et al., 2015) as it is known to facilitate the training of binary networks (Bulat et al., 2019). ",
+        "bbox": [
+            174,
+            810,
+            823,
+            839
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Scaling factors: We used discriminatively learnt scaling factors via backpropagation as in (Bulat & Tzimiropoulos, 2019). ",
+        "bbox": [
+            173,
+            845,
+            821,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Downsample layers: We used real-valued downsample layers (Liu et al., 2018). We found the large accuracy boost to be consistent across our experiments (around $3 - 4 \\%$ top-1 improvement on ImageNet). ",
+        "bbox": [
+            176,
+            881,
+            823,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We used the following training strategies to train our strong baseline: ",
+        "bbox": [
+            176,
+            103,
+            625,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Initialization: When training binary networks, it is crucial to use a 2-stage optimization strategy (Bulat et al., 2019). In particular, we first train a network using binary activations and real-valued weights, and then use the resulting model as initialization to train a network where both weights and activations are binarized. ",
+        "bbox": [
+            174,
+            125,
+            825,
+            180
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Weight decay: Setting up weight decay carefully is surprisingly important. We use $1 e - 5$ when training stage 1 (binary activation and real weights network), and set it to 0 on stage 2 (Bethge et al., 2019). Note that weights at stage 2 are either 1 or $- 1$ , so applying an $L _ { 2 }$ regularization term to them does not make sense. ",
+        "bbox": [
+            174,
+            188,
+            825,
+            243
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Data augmentation: For CIFAR-100 we use the standard random crop, horizontal flip and rotation $( \\pm 1 5 ^ { \\circ } )$ . For ImageNet, we found that random cropping, flipping and colour jitter augmentation worked best. However, colour jitter is disabled for stage 2. ",
+        "bbox": [
+            174,
+            251,
+            825,
+            292
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Mix-up: We found that mix-up (Zhang et al., 2017) is crucial for CIFAR-100, while it slightly hurts performance for ImageNet – this is due to the higher risk of overfitting on CIFAR-100. ",
+        "bbox": [
+            173,
+            299,
+            823,
+            328
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Warm-up: We used warm-up for 5 epochs during stage 1 and no warm-up for stage 2. ",
+        "bbox": [
+            174,
+            334,
+            738,
+            349
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Optimizer: We used Adam (Kingma & Ba, 2014) with a stepwise scheduler. The learning rate is set to $1 e - 3$ for stage 1, and $2 e - 4$ for stage 2. For CIFAR-100, we trained for 350 epochs, with steps at epochs 150, 250 and 320. For ImageNet, we train for 75 epochs, with steps at epochs 40, 60 and 70. Batch sizes are 256 for ImageNet and 128 for CIFAR-100. ",
+        "bbox": [
+            174,
+            356,
+            825,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 REAL-TO-BINARY ATTENTION MATCHING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            430,
+            509,
+            445
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We make the reasonable assumption that if a binary network is trained so that the output of each binary convolution more closely matches the output of a real convolution in the corresponding layer of a real-valued network, then significant accuracy gains can be obtained. Notably, a similar assumption was made in (Rastegari et al., 2016) where analytic scale factors were calculated so that the error between binary and real convolutions is minimized. Instead, and inspired by the attention transfer method of (Zagoruyko & Komodakis, 2017), we propose to enforce such a constraint via a loss term at the end of each convolutional block by comparing attention maps calculated from the binary and real-valued activations. Such supervisory signals provide the binary network with muchneeded extra guidance. It is also well-known that backpropagation for binary networks is not as effective as for real-valued ones. By introducing such loss terms at the end of each block, gradients do not have to traverse the whole network and suffer a degraded signal. ",
+        "bbox": [
+            173,
+            457,
+            825,
+            611
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assuming that attention matching is applied at a set of $\\mathcal { I }$ transfer points within the network, the total loss can be expressed as: ",
+        "bbox": [
+            171,
+            617,
+            823,
+            646
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6e72c68e6bd943c5f336d1b6c3a4883dad5f9b28ce57347fcd1f89da1eaa0c0e.jpg",
+        "text": "$$\n\\mathcal { L } _ { a t t } = \\sum _ { j = 1 } ^ { \\mathcal { I } } \\Vert \\frac { \\mathcal { Q } _ { S } ^ { j } } { \\Vert \\mathcal { Q } _ { S } ^ { j } \\Vert _ { 2 } } - \\frac { \\mathcal { Q } _ { T } ^ { j } } { \\Vert \\mathcal { Q } _ { T } ^ { j } \\Vert _ { 2 } } \\Vert ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            654,
+            609,
+            699
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\mathcal { Q } ^ { j } = \\sum _ { i = 1 } ^ { c } | \\mathcal { A } _ { i } | ^ { 2 } } \\end{array}$ and $A _ { i }$ is the $i -$ th channel of activation map $\\mathcal { A }$ . Moreover, at the end of the network, we apply a standard logit matching loss (Hinton et al., 2015). ",
+        "bbox": [
+            174,
+            708,
+            821,
+            737
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Progressive teacher-student: We observed that teacher and student having as similar architecture as possible is very important in our case. We thus train a sequence of teacher-student pairs that progressively bridges the differences between the real network and the binary network in small increments: ",
+        "bbox": [
+            174,
+            742,
+            825,
+            797
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Step 1: the teacher is the real-valued network with the standard ResNet architecture. The student is another real-valued network, but with the same architecture as the binary ResNet-18 (e.g. double skip connection, layer ordering, PReLU activations, etc). Furthermore, a soft binarization (a Tanh function) is applied to the activations instead of the binarization (sign) function. In this way the network is still real-valued, but it behaves more closely to a network with binary activations. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            867
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Step 2: The network resulting from the previous step is used as the teacher. A network with binary activations and real-valued weights is used as the student. ",
+        "bbox": [
+            173,
+            868,
+            821,
+            896
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Step 3: The network resulting from step 2 is used as the teacher and the network with binary weights and binary activations is the student. In this stage, only logit matching is used. ",
+        "bbox": [
+            174,
+            896,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 DATA-DRIVEN CHANNEL RE-SCALING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            475,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While the approach of the previous section provides better guidance for the training of binary networks, the representation power of binary convolutions is still limited, hindering its capacity to approximate the real-valued network. Here we describe how to boost the representation capability of a binary neural network and yet incur in only a negligible increment on the number of operations. ",
+        "bbox": [
+            174,
+            130,
+            823,
+            185
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Previous works have shown the effectiveness of re-scaling binary convolutions with the goal of better approximating real convolutions. XNOR-Net (Rastegari et al., 2016) proposed to compute these scale factors analytically while (Bulat & Tzimiropoulos, 2019; Xu & Cheung, 2019) proposed to learn them discriminatively in an end-to-end manner, showing additional accuracy gains. For the latter case, during training, the optimization aims to find a set of fixed scaling factors that minimize the average expected loss for the training set. We propose instead to go beyond this and obtain discriminatively-trained input-dependent scaling factors – thus, at test time, these scaling factors will not be fixed but rather inferred from data. ",
+        "bbox": [
+            174,
+            193,
+            825,
+            304
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Let us first recall what the signal flow is when going through a binary block. The activations entering a binary block are actually real-valued. Batch normalization centers the activations, which are then binarized, losing a large amount of information. Binary convolution, re-scaling and PReLU follow. We propose to use the full-precision activation signal, available prior to the large information loss incurred by the binarization operation, to predict the scaling factors used to re-scale the output of the binary convolution channel-wise. Specifically, we propose to approximate the real convolution as follows: ",
+        "bbox": [
+            174,
+            310,
+            825,
+            407
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d6481f5f75c50eea92574a5a4ad126073eff2c4255b99690a5c11840a9eebb6f.jpg",
+        "text": "$$\n\\mathcal { A } \\ast \\mathcal { W } \\approx ( \\mathrm { s i g n } ( \\mathcal { A } ) \\circledast \\mathrm { s i g n } ( \\mathcal { W } ) ) \\odot \\alpha \\odot G ( \\mathcal { A } ; \\mathcal { W } _ { G } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            429,
+            671,
+            446
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { W } _ { G }$ are the parameters of the gating function $G$ . Such function computes the scale factors used to re-scale the output of the binary convolution, and uses the pre-convolution real-valued activations as input. Fig. 1 shows our implementation of function $G$ . The design is inspired by Hu et al. (2018), but we use the gating function to predict ahead rather than as a self-attention mechanism. ",
+        "bbox": [
+            174,
+            457,
+            823,
+            513
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "An optimal mechanism to modulate the output of the binary convolution clearly should not be the same for all examples as in Bulat & Tzimiropoulos (2019) or Xu & Cheung (2019). Note that in Rastegari et al. (2016) the computation of the scale factors depends on the input activations. However the analytic calculation is sub-optimal with respect to the task at hand. To circumvent the aforementioned problems, our method learns, via backpropagation for the task at hand, to predict the modulating factors using the real-valued input activations. By doing so, more than $1 / 3$ of the remaining gap with the real-valued network is bridged. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            618
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.4 COMPUTATIONAL COST ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            636,
+            454,
+            650
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1 details the computational cost of the different binary network methodologies. We differentiate between the number of binary and floating point operations, including operations such as skip connections, pooling layers, etc. It shows that our method leaves the number of binary operations constant, and that the number of FLOPs increases by only $1 \\%$ of the total floating point operation count. This is assuming a factor $r$ of 8, which is the one used in all of our experiments. To put this into perspective, the magnitude is similar to the operation increase incurred by the XNOR-Net with respect to its predecessor, BNN. Similarly, the double skip connections proposed in (Liu et al., 2018) adds again a comparable amount of operations. Note however that in order to fully exploit the computational efficiency of binary convolutions during inference, a specialized engine such as (Zhang et al., 2019; Yang et al., 2017) is required. ",
+        "bbox": [
+            174,
+            661,
+            825,
+            801
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            821,
+            281,
+            838
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We present two main sets of experiments. We used ImageNet (Russakovsky et al., 2015) as a benchmark to compare our method against other state-of-the-art approaches in Sec. 5.1. ImageNet is the most widely used dataset to report results on binary networks and, at the same time, allows us to show for the first time that binary networks can perform competitively on a large-scale dataset. We further used CIFAR-100 (Krizhevsky & Hinton, 2009) to conduct ablation studies (Sec. 5.2). ",
+        "bbox": [
+            176,
+            853,
+            823,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/90277349eaacaa6b800bf88fbb95c453de228f8dcfada0391dfe5ea055c5a1f3.jpg",
+        "table_caption": [
+            "Table 1: Breakdown of floating point and binary operations for variants of binary ResNet-18. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>BOPS</td><td rowspan=1 colspan=1>FLOPS</td></tr><tr><td rowspan=1 colspan=1>BNN (Courbariaux et al., 2016)XNOR-Net (Rastegari et al., 2016)Double Skip ((Liu et al., 2018)Bi-Real (Liu et al.,2018)Ours</td><td rowspan=1 colspan=1>1.695×1091.695×1091.695×1091.676×1091.676×109</td><td rowspan=1 colspan=1>1.314×1081.333×1081.351×1081.544×1081.564×108</td></tr><tr><td rowspan=1 colspan=1>Full Precision</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1.826×109</td></tr></table>",
+        "bbox": [
+            281,
+            101,
+            717,
+            208
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 COMPARISON WITH THE STATE-OF-THE-ART ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            276,
+            524,
+            291
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows a comparison between our method and relevant state-of-the-art methods, including low-bit quantization methods other than binary. ",
+        "bbox": [
+            176,
+            309,
+            821,
+            337
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Vs. other binary networks: Our strong baseline already comfortably achieves state-of-the art results, surpassing the previously best-reported result by about $1 \\%$ (Wang et al., 2019). Our full method further improves over the state-of-the-art by $5 . 5 \\%$ top-1 accuracy. When comparing to binary models that scale the capacity of the network (second set of results on Tab. 2), only (Zhuang et al., 2019) outperforms our method, surpassing it by $0 . 9 \\%$ top-1 accuracy - yet, this is achieved using 4 times the number of binary blocks. ",
+        "bbox": [
+            174,
+            344,
+            825,
+            428
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Vs. real-valued networks: Our method reduces the performance gap with its real-valued counterpart to $\\sim 4 \\%$ top-1 accuracy, or $\\sim 5 \\%$ if we compare against a real-valued network trained with attention transfer. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            477
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Vs. other low-bit quantization: Table 2 also shows a comparison to the state-of-the-art for low-bit quantization methods (first set of results). It can be seen that our method surpasses the performance of all methods, except for TTQ (Zhu et al., 2017), which uses 2-bit weights, full-precision activations and 1.5 the channel width at each layer. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            540
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 ABLATION STUDIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            570,
+            352,
+            585
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to conduct a more detailed ablation study we provide results on CIFAR-100. We thoroughly optimized a ResNet-18 full precision network to serve as the real-valued baseline. ",
+        "bbox": [
+            171,
+            602,
+            823,
+            631
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Teacher-Student effectiveness: We trained a real-valued ResNet-18 using ResNet-34 as its teacher, yielding $\\sim 1 \\%$ top-1 accuracy increase. Instead, our progressive teacher-student strategy yields $\\sim 5 \\%$ top-1 accuracy gain, showing that it is a fundamental tool when training binary networks, and that its impact is much larger than for real-valued networks, where the baseline optimization is already healthier. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            720
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Performance gap to real-valued: We observe that, for CIFAR-100, we close the gap with realvalued networks to about $2 \\%$ when comparing with the full-precision ResNet-18, and to about $3 \\%$ when optimized using teacher supervision. The gap is consistent to that on ImageNet in relative terms: $\\mathrm { { 1 3 \\% } }$ and $1 0 \\%$ relative degradation on ImageNet and CIFAR-100 respectively. ",
+        "bbox": [
+            174,
+            728,
+            823,
+            784
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Binary vs real downsample: Our proposed method achieves similar performance increase irrespective of whether binary or real-valued downsample layers are used, the improvement being $5 . 5 \\%$ and $6 . 6 \\%$ top-1 accuracy gain respectively. It is also interesting to note that the results on the ablation study are consistent for all entries on both cases. ",
+        "bbox": [
+            174,
+            790,
+            823,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Scaling factors and attention matching: It is also noteworthy that the gating module is not effective in the absence of attention matching (see $\\mathrm { \\bf S B + G }$ entries). It seems clear from this result that both are interconnected: the extra supervisory signal is necessary to properly guide the training, while the extra flexibility added through the gating mechanism boosts the capacity of the network to mimic the attention map. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/920287efd5edd1cfde6757b1b37edebed9aa9f14b4cef8438f15029a332e231f.jpg",
+        "table_caption": [
+            "Table 2: Comparison with state-of-the-art methods on ImageNet. \\*\\* indicates real-valued downsample. The second column indicates the number of bits used to represent weights and activations. Methods include low-bit quantization (upper section), and methods multiplying the capacity of the network (second section). For the latter case, the second column includes the multiplicative factor of the network capacity used. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Method</td><td rowspan=1 colspan=3>ImageNet</td></tr><tr><td rowspan=1 colspan=1>Bitwidth (W/A)</td><td rowspan=1 colspan=1>Top-1</td><td rowspan=1 colspan=1>Top-5</td></tr><tr><td rowspan=6 colspan=1>BWN (Rastegari et al., 2016)TTQ (Zhu et al., 2017)HWGQ (Cai et al., 2017)LQ-Net (Zhang et al., 2018)SYQ (Faraone et al., 2018)DOREFA-Net (Zhou et al.,2016)</td><td rowspan=1 colspan=1>1/32</td><td rowspan=1 colspan=1>60.8</td><td rowspan=1 colspan=1>83.0</td></tr><tr><td rowspan=2 colspan=1>2/321/2</td><td rowspan=1 colspan=1>66.6</td><td rowspan=1 colspan=1>87.2</td></tr><tr><td rowspan=1 colspan=1>59.6</td><td rowspan=1 colspan=1>82.2</td></tr><tr><td rowspan=3 colspan=1>1/21/22/2</td><td rowspan=1 colspan=1>62.6</td><td rowspan=1 colspan=1>84.3</td></tr><tr><td rowspan=1 colspan=1>55.4</td><td rowspan=1 colspan=1>78.6</td></tr><tr><td rowspan=1 colspan=1>62.6</td><td rowspan=1 colspan=1>84.4</td></tr><tr><td rowspan=4 colspan=1>ABC-Net (Lin et al., 2017)Circulant CNN (Liu et al., 2019)Struct Appr (Zhuang et al., 2019)Struct Appr** (Zhuang et al., 2019)Ensemble (Zhu et al., 2019)</td><td rowspan=1 colspan=1>(1/1)×5</td><td rowspan=1 colspan=1>65.0</td><td rowspan=1 colspan=1>85.9</td></tr><tr><td rowspan=2 colspan=1>(1/1)×4(1/1)×4</td><td rowspan=1 colspan=1>61.4</td><td rowspan=1 colspan=1>82.8</td></tr><tr><td rowspan=1 colspan=1>64.2</td><td rowspan=1 colspan=1>85.6</td></tr><tr><td rowspan=1 colspan=1>(1/1)x4(1/1)×6</td><td rowspan=1 colspan=1>66.361.0</td><td rowspan=1 colspan=1>86.61</td></tr><tr><td rowspan=3 colspan=1>BNN (Courbariaux et al., 2016)XNOR-Net (Rastegari et al., 2016)Trained Bin (Xu &amp; Cheung,2019)Bi-Real Net (Liu et al., 2018)**CI-Net (Wang et al., 2019)XNOR-Net++ (Bulat &amp; Tzimiropoulos,2019)CI-Net (Wang et al., 2019)**</td><td rowspan=2 colspan=1>1/11/11/11/1</td><td rowspan=2 colspan=1>42.251.254.256.4</td><td rowspan=1 colspan=1>69.273.277.9</td></tr><tr><td rowspan=2 colspan=1>56.456.757.159.9</td><td rowspan=2 colspan=1>79.580.179.984.2</td></tr><tr><td rowspan=1 colspan=1>1/11/11/1</td></tr><tr><td rowspan=2 colspan=1>Strong Baseline (ours)**Real-to-Bin (ours)**</td><td rowspan=1 colspan=1>1/1</td><td rowspan=1 colspan=1>60.9</td><td rowspan=1 colspan=1>83.0</td></tr><tr><td rowspan=1 colspan=1>1/1</td><td rowspan=1 colspan=1>65.4</td><td rowspan=1 colspan=1>86.2</td></tr><tr><td rowspan=1 colspan=1>Real valuedReal valued T-S</td><td rowspan=1 colspan=1>32/3232/32</td><td rowspan=1 colspan=1>69.370.7</td><td rowspan=1 colspan=1>89.290.0</td></tr></table>",
+        "bbox": [
+            215,
+            128,
+            781,
+            469
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/d1a5d0d7e40376455749af2f123c1aaf6b2a84a0a0a27ef2f8acbf6dd2a084cf.jpg",
+        "table_caption": [
+            "Table 3: Top-1 and Top-5 classification accuracy using ResNet-18 on CIFAR-100. \\*\\* indicates real-valued downsample layers. $G$ indicates that the gating function of Sec. 4.3 is used. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Method</td><td rowspan=1 colspan=1>Stage 1</td><td rowspan=1 colspan=1>Stage 2</td></tr><tr><td rowspan=1 colspan=1>Top-1/Top-5</td><td rowspan=1 colspan=1>Top-1/Top-5</td></tr><tr><td rowspan=1 colspan=1>Strong BaselineSB + Att TransSB + Att Trans + HKDSB +GSB + Progressive TSReal-to-Bin</td><td rowspan=1 colspan=1>69.3/88.772.2 /90.373.1 /91.267.2 / 87.073.8 /91.575.0 /92.2</td><td rowspan=1 colspan=1>68.0/88.371.1/90.171.9 /90.966.2 / 86.872.3 / 89.873.5 / 91.6</td></tr><tr><td rowspan=1 colspan=1>Strong Baseline**SB + Att Trans**SB+Att Trans + HKD**SB + G**SB + Progressive TS**Real-to-Bin**</td><td rowspan=1 colspan=1>72.1/89.974.3 /91.375.4 /92.272.0 /89.875.7 /92.176.5 /92.8</td><td rowspan=1 colspan=1>69.6/89.272.6 /91.473.9 /91.270.9 / 89.374.6 / 91.876.2 / 92.7</td></tr><tr><td rowspan=1 colspan=1>Full Prec (our impl.)Full Prec + TS (our impl.)</td><td rowspan=1 colspan=2>78.3/93.679.3 /94.4</td></tr></table>",
+        "bbox": [
+            290,
+            619,
+            705,
+            848
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work we showed how to train binary networks to within a few percent points of their realvalued counterpart, turning binary networks from hopeful research into a compelling alternative to real-valued networks. We did so by training a binary network to not only predict training labels, but also mimic the behaviour of real-valued networks. To this end, we devised a progressive attention matching strategy to drive optimization, and combined it with a gating strategy for scaling the output of binary convolutions, increasing the representation power of the convolutional block. The two strategies combine perfectly to boost the state-of-the-art of binary networks by 5.5 top-1 accuracy on ImageNet, the standard benchmark for binary networks. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            246
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            267,
+            285,
+            282
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Milad Alizadeh, Javier Fernandez-Marqu ´ es, Nicholas D. Lane, and Yarin Gal. An empirical study of ´ binary neural networks’ optimisation. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            176,
+            290,
+            823,
+            333
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joseph Bethge, Haojin Yang, Marvin Bornstein, and Christoph Meinel. Back to simplicity: How to train accurate BNNs from scratch? arXiv preprint arXiv:1906.08637, 2019. ",
+        "bbox": [
+            169,
+            343,
+            823,
+            372
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Adrian Bulat and Georgios Tzimiropoulos. XNOR-Net $^ { + + }$ : Improved binary neural networks. In British Machine Vision Conference, 2019. ",
+        "bbox": [
+            174,
+            382,
+            820,
+            411
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Adrian Bulat, Georgios Tzimiropoulos, Jean Kossaifi, and Maja Pantic. Improved training of binary networks for human pose estimation and image recognition. arXiv preprint arXiv:1904.05868, 2019. ",
+        "bbox": [
+            174,
+            421,
+            826,
+            463
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhaowei Cai, Xiaodong He, Jian Sun, and Nuno Vasconcelos. Deep learning with low precision by half-wave gaussian quantization. In IEEE Conference on Computer Vision and Pattern Recognition, 2017. ",
+        "bbox": [
+            173,
+            473,
+            825,
+            517
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training deep neural networks with weights and activations constrained to $+ 1$ or-1. arXiv, 2016. ",
+        "bbox": [
+            173,
+            526,
+            821,
+            569
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ruizhou Ding, Ting-Wu Chin, Zeye Liu, and Diana Marculescu. Regularizing activation distribution for training binarized deep networks. In IEEE Conference on Computer Vision and Pattern Recognition, 2019. ",
+        "bbox": [
+            173,
+            579,
+            823,
+            622
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Julian Faraone, Nicholas J. Fraser, Michaela Blott, and Philip H. W. Leong. SYQ: learning symmetric quantization for efficient deep neural networks. In IEEE Conference on Computer Vision and Pattern Recognition, 2018. ",
+        "bbox": [
+            173,
+            632,
+            825,
+            675
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ruihao Gong, Xianglong Liu, Shenghu Jiang, Tianxiang Li, Peng Hu, Jiazhen Lin, Fengwei Yu, and Junjie Yan. Differentiable soft quantization: Bridging full-precision and low-bit neural networks. arXiv, 2019. ",
+        "bbox": [
+            173,
+            685,
+            825,
+            728
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In IEEE International Conference on Computer Vision, pp. 1026–1034, 2015. ",
+        "bbox": [
+            173,
+            738,
+            825,
+            781
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015. ",
+        "bbox": [
+            171,
+            791,
+            823,
+            820
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jie Hu, Li Shen, and Gang Sun. Squeeze-and-excitation networks. In IEEE Conference on Computer Vision and Pattern Recognition, 2018. ",
+        "bbox": [
+            171,
+            830,
+            823,
+            859
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            869,
+            823,
+            898
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            171,
+            909,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xiaofan Lin, Cong Zhao, and Wei Pan. Towards accurate binary convolutional neural network. In Advances on Neural Information Processing Systems, 2017. ",
+        "bbox": [
+            169,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chunlei Liu, Wenrui Ding, Xin Xia, Baochang Zhang, Jiaxin Gu, Jianzhuang Liu, Rongrong Ji, and David Doermann. Circulant binary convolutional networks: Enhancing the performance of 1-bit dcnns with circulant back propagation. In IEEE Conference on Computer Vision and Pattern Recognition, 2019. ",
+        "bbox": [
+            174,
+            141,
+            825,
+            198
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zechun Liu, Baoyuan Wu, Wenhan Luo, Xin Yang, Wei Liu, and Kwang-Ting Cheng. Bi-Real Net: Enhancing the performance of 1-bit CNNs with improved representational capability and advanced training algorithm. In European Conference on Computer Vision, 2018. ",
+        "bbox": [
+            173,
+            207,
+            825,
+            251
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-Net: Imagenet classification using binary convolutional neural networks. In European Conference on Computer Vision, 2016. ",
+        "bbox": [
+            174,
+            260,
+            825,
+            301
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li FeiFei. ImageNet Large Scale Visual Recognition Challenge. International Journal on Computer Vision, 115(3):211–252, 2015. ",
+        "bbox": [
+            174,
+            310,
+            825,
+            368
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Daniel Soudry, Itay Hubara, and Ron Meir. Expectation backpropagation: Parameter-free training of multilayer neural networks with continuous or discrete weights. In Advances on Neural Information Processing Systems, 2014. ",
+        "bbox": [
+            174,
+            377,
+            823,
+            420
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ziwei Wang, Jiwen Lu, Chenxin Tao, Jie Zhou, and Qi Tian. Learning channel-wise interactions for binary convolutional neural networks. In IEEE Conference on Computer Vision and Pattern Recognition, 2019. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            472
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhe Xu and Ray C.C. Cheung. Accurate and compact convolutional neural networks with trained binarization. In British Machine Vision Conference, 2019. ",
+        "bbox": [
+            171,
+            482,
+            823,
+            511
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Haojin Yang, Martin Fritzsche, Christian Bartz, and Christoph Meinel. BMXNet: An open-source binary neural network implementation based on MXNet. In ACM International Conference on Multimedia, 2017. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            563
+        ],
+        "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. In International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            614
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dongqing Zhang, Jiaolong Yang, Dongqiangzi Ye, and Gang Hua. LQ-Nets: Learned quantization for highly accurate and compact deep neural networks. In European Conference on Computer Vision, 2018. ",
+        "bbox": [
+            173,
+            625,
+            825,
+            666
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. Mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017. ",
+        "bbox": [
+            171,
+            675,
+            823,
+            705
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jianhao Zhang, Yingwei Pan, Ting Yao, He Zhao, and Tao Mei. dabnn: A super fast inference framework for binary neural networks on ARM devices. In ACM International Conference on Multimedia, 2019. ",
+        "bbox": [
+            173,
+            714,
+            825,
+            757
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shuchang Zhou, Yuxin Wu, Zekun Ni, Xinyu Zhou, He Wen, and Yuheng Zou. DoReFa-Net: Training low bitwidth convolutional neural networks with low bitwidth gradients. arXiv, 2016. ",
+        "bbox": [
+            173,
+            766,
+            821,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chenzhuo Zhu, Song Han, Huizi Mao, and William J Dally. Trained ternary quantization. International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            171,
+            804,
+            823,
+            834
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shilin Zhu, Xin Dong, and Hao Su. Binary ensemble neural network: More bits per network or more networks per bit? In IEEE Conference on Computer Vision and Pattern Recognition, 2019. ",
+        "bbox": [
+            171,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bohan Zhuang, Chunhua Shen, Mingkui Tan, Lingqiao Liu, and Ian D. Reid. Towards effective low-bitwidth convolutional neural networks. In IEEE Conference on Computer Vision and Pattern Recognition, 2018. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bohan Zhuang, Chunhua Shen, Mingkui Tan, Lingqiao Liu, and Ian Reid. Structured binary neural networks for accurate image classification and semantic segmentation. In IEEE Conference on Computer Vision and Pattern Recognition, 2019. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    }
+]

parse/train/H1Heentlx/H1Heentlx.md

@@ -0,0 +1,289 @@
+# DEEP VARIATIONAL CANONICAL CORRELATION ANALYSIS
+
+Weiran Wang1 Xinchen Yan2 Honglak Lee2 Karen Livescu1   
+1TTI-Chicago, Chicago, IL 60637, USA   
+2University of Michigan, Ann Arbor, MI 48109, USA   
+1{weiranwang,klivescu}@ttic.edu {xcyan,honglak}@umich.edu
+
+# ABSTRACT
+
+We present deep variational canonical correlation analysis (VCCA), a deep multiview learning model that extends the latent variable model interpretation of linear CCA (Bach and Jordan, 2005) to nonlinear observation models parameterized by deep neural networks (DNNs). Computing the marginal data likelihood, as well as inference of the latent variables, are intractable under this model. We derive a variational lower bound of the data likelihood by parameterizing the posterior density of the latent variables with another DNN, and approximate the lower bound via Monte Carlo sampling. Interestingly, the resulting model resembles that of multiview autoencoders (Ngiam et al., 2011), with the key distinction of an additional sampling procedure at the bottleneck layer. We also propose a variant of VCCA called VCCA-private which can, in addition to the “common variables” underlying both views, extract the “private variables” within each view. We demonstrate that VCCA-private is able to disentangle the shared and private information for multi-view data without hard supervision.
+
+# 1 INTRODUCTION
+
+In the multi-view representation learning setting, we have multiple views/measurements of the same underlying signal, and the goal is to learn useful features of each view using complementary information contained in the views. The intuition underlying this setting is that the learned features can help uncover the common sources of variation in the views, which can be helpful for exploratory analysis or for downstream tasks.
+
+A classical approach in this setting is canonical correlation analysis (CCA, Hotelling, 1936) and its nonlinear extensions, including the kernel extension (Lai and Fyfe, 2000; Akaho, 2001; Melzer et al., 2001; Bach and Jordan, 2002) and the deep neural network (DNN) extension (Andrew et al., 2013; Wang et al., 2015b). CCA projects two random vectors $\mathbf { x } \in \mathbb { R } ^ { d _ { x } }$ and $\mathbf { y } \in \mathbb { R } ^ { d _ { y } }$ into a lowerdimensional subspace so that the projections are maximally correlated. There is a probabilistic latent variable model interpretation of linear CCA (Bach and Jordan, 2005) as shown in Figure 1 (left). Assume that $\mathbf { x }$ and y are linear functions of some lower-dimensional random variable $\textbf { z } \in \mathbb { R } ^ { d _ { z } }$ , where $d _ { z } \leq \operatorname* { m i n } ( d _ { x } , d _ { y } )$ . When the prior distribution of the latent variable $p ( \mathbf { z } )$ and the conditional distributions $p ( \mathbf { x } | \mathbf { z } )$ and $p ( \mathbf { y } \vert \mathbf { z } )$ are Gaussian, Bach and Jordan (2005) showed that $\mathbb { E } [ \mathbf { z } | \mathbf { x } ]$ (resp. $\mathbb { E } [ \mathbf { z } | \mathbf { y } ] )$ lives in the same space as the linear CCA projection for $\mathbf { x }$ (resp. y).
+
+This generative interpretation of CCA is often lost in nonlinear extensions of CCA. For example, in deep CCA (DCCA, (Andrew et al., 2013)), to extend CCA to nonlinear mappings with greater representation power, one extracts nonlinear features from the original inputs of each view using two DNNs, f for $\mathbf { x }$ and $\mathbf { g }$ for $\mathbf { y }$ , so that the canonical correlation of the DNN outputs (measured by a linear CCA with projection matrices $\mathbf { U }$ and $\mathbf { V }$ ) is maximized. Formally, given a dataset of $N$ pairs of observations $( \mathbf { x } _ { 1 } , \mathbf { y } _ { 1 } ) , \dotsc , ( \mathbf { x } _ { N } , \mathbf { y } _ { N } )$ of the random vectors $\displaystyle ( \mathbf { x } , \mathbf { y } )$ , DCCA optimizes
+
+$$
+\begin{array} { r l } { \underset { \mathbf { w } _ { \mathrm { f } } , \mathbf { w } _ { \mathbf { g } } } { \operatorname* { m a x } } \ : \mathrm { t r } \left( \mathbf { U } ^ { \top } \mathbf { f } ( \mathbf { X } ) \mathbf { g } ( \mathbf { Y } ) ^ { \top } \mathbf { V } \right) } & { \mathrm { ~ s . t . ~ } \mathbf { U } ^ { \top } \left( \mathbf { f } ( \mathbf { X } ) \mathbf { f } ( \mathbf { X } ) ^ { \top } \right) \mathbf { U } = \mathbf { V } ^ { \top } \left( \mathbf { g } ( \mathbf { Y } ) \mathbf { g } ( \mathbf { Y } ) ^ { \top } \right) \mathbf { V } = N \mathbf { I } , } \end{array}
+$$
+
+where $\mathbf { f } ( \mathbf { X } ) = [ \mathbf { f } ( \mathbf { x } _ { 1 } ) , \dots , \mathbf { f } ( \mathbf { x } _ { N } ) ]$ and $\mathbf { g } ( \mathbf { Y } ) = [ \mathbf { g } ( \mathbf { y } _ { 1 } ) , \dots , \mathbf { g } ( \mathbf { y } _ { N } ) ]$ , and $\mathbf { W _ { f } }$ denotes all weight parameters of the DNN f (and similarly for $\mathbf { g }$ ).
+
+![](images/bb2dbd35f41d89ff34e8e2a1eee60726a3db9398263cd445bbccb4c32a1eba91.jpg)  
+Figure 1: Left: Probabilistic interpretation of CCA (Bach and Jordan, 2005). Right: The deep variational CCA (VCCA) model.
+
+DCCA has achieved good performance in the multi-view representation learning setting across different domains (Wang et al., 2015b,a; Lu et al., 2015; Yan and Mikolajczyk, 2015). However, a disadvantage of DCCA is that it directly looks for DNNs that can map inputs into the low-dimensional space, without a model for generating samples from the latent space. Although Wang et al. (2015b)’s deep canonically correlated autoencoders (DCCAE) model optimizes the combination of the autoencoder objective (reconstruction errors) and the canonical correlation objective, the authors found that in practice, the canonical correlation term tends to dominate the reconstruction error terms in the DCCAE objective when tuning performance for a downstream task (especially when the inputs are noisy), and as a result the inputs are not reconstructed well. At the same time, optimization of the DCCA and DCCAE objectives is challenging due to the constraints that couple all training samples.
+
+The main contribution of this paper is the proposal of a new deep multi-view learning model named deep variational CCA (VCCA), which extends the latent variable model interpretation of linear CCA to nonlinear observation models parameterized by DNNs. Computing the marginal data likelihood, as well as inference of the latent variables, are intractable under this model. Inspired by variational autoencoders (VAE, Kingma and Welling, 2014), we parameterize the posterior distribution of the latent variables with another DNN, and derive a variational lower bound of the data likelihood as the objective of VCCA, which is further approximated by Monte Carlo sampling. With the reparameterization trick, sampling for the Monte Carlo approximation is trivial and all DNN weights in VCCA can be optimized jointly via stochastic gradient descent, using unbiased gradient estimates from small minibatches. Interestingly, VCCA is related to multi-view autoencoders (Ngiam et al., 2011), with the key distinctions of additional regularization on the posterior distribution and the sampling procedure at the bottleneck layer.
+
+We also propose a variant of VCCA called VCCA-private that can, in addition to the “common variables” underlying both views, extract the “private variables” within each view. We demonstrate that VCCA-private is able to disentangle the shared and private information for multi-view data without hard supervision. Last but not least, as generative models, VCCA and VCCA-private enable us to obtain high-quality samples for the input of each view.
+
+# 2 VARIATIONAL CCA
+
+The probabilistic latent variable model of CCA (Bach and Jordan, 2005) defines the following joint distribution over the random variables $\displaystyle ( \mathbf { x } , \mathbf { y } )$ :
+
+$$
+p ( \mathbf { x } , \mathbf { y } , \mathbf { z } ) = p ( \mathbf { z } ) p ( \mathbf { x } | \mathbf { z } ) p ( \mathbf { y } | \mathbf { z } ) , \qquad p ( \mathbf { x } , \mathbf { y } ) = \int p ( \mathbf { x } , \mathbf { y } , \mathbf { z } ) d \mathbf { z } .
+$$
+
+The assumption underlying this model is that, conditioned on the latent variables $\textbf { z } \in \mathbb { R } ^ { d _ { z } }$ , the two views $\mathbf { x }$ and $\mathbf { y }$ are independent. However, linear observation models $( p ( \mathbf { x } | \mathbf { z } )$ and $p ( \mathbf { y } \vert \mathbf { z } )$ as shown in Figure 1 (left)) have limited representation power. In this paper, we consider nonlinear observation models $p _ { \pmb { \theta } } ( \mathbf { x } | \mathbf { z } ; \pmb { \theta } _ { x } )$ and $p _ { \pmb { \theta } } ( \mathbf { y } | \mathbf { z } ; \pmb { \theta } _ { y } )$ , parameterized by $\pmb { \theta } _ { x }$ and $\theta _ { y }$ respectively, which can be the collections of weights of DNNs. In this case, the marginal likelihood $p _ { \pmb { \theta } } ( \mathbf { x } , \mathbf { y } )$ does not have a closed form. In addition, the inference problem $p _ { \pmb { \theta } } ( \mathbf { z } | \mathbf { x } )$ —the problem of inferring the latent variables given one of the views—is also intractable.
+
+Inspired by Kingma and Welling (2014)’s work on variational autoencoders (VAE), we approximate $p _ { \pmb { \theta } } ( \mathbf { z } | \mathbf { x } )$ with the conditional density $q _ { \phi } ( \mathbf { z } | \mathbf { x } ; \phi _ { z } )$ , where $\phi _ { z }$ is the collection of parameters of another DNN.1 We can derive a lower bound on the marginal data likelihood using $q _ { \phi } ( \mathbf { z } | \mathbf { x } )$ :
+
+$$
+\begin{array} { r l } & { \log p _ { \theta } ( \mathbf { x } , \mathbf { y } ) = \log p _ { \theta } ( \mathbf { x } , \mathbf { y } ) \int q _ { \phi } ( \mathbf { z } | \mathbf { x } ) d \mathbf { z } = \int \log p _ { \theta } ( \mathbf { x } , \mathbf { y } ) q _ { \phi } ( \mathbf { z } | \mathbf { x } ) d \mathbf { z } } \\ & { \qquad = \int q _ { \phi } ( \mathbf { z } | \mathbf { x } ) \left( \log \frac { q _ { \phi } ( \mathbf { z } | \mathbf { x } ) } { p _ { \theta } ( \mathbf { z } | \mathbf { x } , \mathbf { y } ) } + \log \frac { p _ { \theta } ( \mathbf { x } , \mathbf { y } , \mathbf { z } ) } { q _ { \phi } ( \mathbf { z } | \mathbf { x } ) } \right) d \mathbf { z } } \\ & { \qquad = D _ { K L } ( q _ { \phi } ( \mathbf { z } | \mathbf { x } ) | | p _ { \theta } ( \mathbf { z } | \mathbf { x } , \mathbf { y } ) ) + \mathbb { E } _ { q _ { \phi } ( \mathbf { z } | \mathbf { x } ) } \left[ \log \frac { p _ { \theta } ( \mathbf { x } , \mathbf { y } , \mathbf { z } ) } { q _ { \phi } ( \mathbf { z } | \mathbf { x } ) } \right] } \\ & { \qquad \geq \mathbb { E } _ { q _ { \phi } ( \mathbf { z } | \mathbf { x } ) } \left[ \log \frac { p _ { \theta } ( \mathbf { x } , \mathbf { y } , \mathbf { z } ) } { q _ { \phi } ( \mathbf { z } | \mathbf { x } ) } \right] = : \mathcal { L } ( \mathbf { x } , \mathbf { y } ; \theta , \phi ) } \end{array}
+$$
+
+where we used the fact that KL divergence is nonnegative in the last step. As a result, $\mathcal { L } ( \mathbf { x } , \mathbf { y } ; \pmb { \theta } , \phi )$ is a lower bound on the data log-likelihood $\log _ { \pmb { \theta } } p ( \mathbf { x } , \mathbf { y } )$ . Substituting (2) into (3), we have
+
+$$
+\begin{array} { l } { \displaystyle \mathcal { L } ( \mathbf { x } , \mathbf { y } ; \pmb { \theta } , \phi ) = \int q _ { \phi } ( \mathbf { z } | \mathbf { x } ) \left( \log \frac { p ( \mathbf { z } ) } { q _ { \phi } ( \mathbf { z } | \mathbf { x } ) } + \log p _ { \theta } ( \mathbf { x } | \mathbf { z } ) + \log p _ { \theta } ( \mathbf { y } | \mathbf { z } ) \right) d \mathbf { z } } \\ { \displaystyle = - D _ { K L } ( q _ { \phi } ( \mathbf { z } | \mathbf { x } ) | | p ( \mathbf { z } ) ) + \mathbb { E } _ { q _ { \phi } ( \mathbf { z } | \mathbf { x } ) } \left[ \log p _ { \theta } ( \mathbf { x } | \mathbf { z } ) + \log p _ { \theta } ( \mathbf { y } | \mathbf { z } ) \right] . } \end{array}
+$$
+
+VCCA maximizes this variational lower bound on the data likelihood on the training set:
+
+$$
+\operatorname* { m a x } _ { \pmb { \theta } , \phi } \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \mathcal { L } ( \mathbf { x } _ { i } , \mathbf { y } _ { i } ; \pmb { \theta } , \phi ) .
+$$
+
+The first term in (4) measures the KL divergence between the approximate posterior distribution and the prior distribution of the latent variables $\mathbf { z }$ . When the parameterization $q _ { \phi } ( \mathbf { z } | \mathbf { x } )$ is chosen properly, this term can be computed exactly in closed form. As a concrete example, let the variational approximate posterior be a multivariate Gaussian with diagonal covariance. That is, for a sample pair $\left( \mathbf { x } _ { i } , \mathbf { y } _ { i } \right)$ , we have
+
+$$
+\log q _ { \phi } ( \mathbf { z } _ { i } | \mathbf { x } _ { i } ) = \log \mathcal { N } ( \mathbf { z } _ { i } ; \pmb { \mu } _ { i } , \pmb { \Sigma } _ { i } ) , \qquad \quad \pmb { \Sigma } _ { i } = \mathrm { d i a g } \left( \sigma _ { i 1 } ^ { 2 } , \dots , \sigma _ { i d _ { z } } ^ { 2 } \right) ,
+$$
+
+where the mean $\pmb { \mu } _ { i }$ and covariance $\Sigma _ { i }$ are outputs of an encoding DNN f (and thus $[ \pmb { \mu } _ { i } , \pmb { \Sigma } _ { i } ] =$ $\mathbf { f } ( \mathbf { x } _ { i } ; \boldsymbol { \phi } _ { z } )$ are deterministic nonlinear functions of $\mathbf { x } _ { i }$ ). In this case, we have
+
+$$
+D _ { K L } \big ( q _ { \phi } ( \mathbf { z } _ { i } | \mathbf { x } _ { i } ) | | p ( \mathbf { z } _ { i } ) \big ) = - \frac { 1 } { 2 } \sum _ { j = 1 } ^ { d _ { z } } \left( 1 + \log \sigma _ { i j } ^ { 2 } - \sigma _ { i j } ^ { 2 } - \mu _ { i j } ^ { 2 } \right) .
+$$
+
+The second term of (4) corresponds to the expected complete data likelihood under the approximate posterior distribution. Though still intractable, this term can be approximated by Monte Carlo sampling. In particular, we draw $L$ samples ${ \bf z } _ { i } ^ { ( l ) } \sim q _ { \phi } ( { \bf z } _ { i } | { \bf x } _ { i } )$ :
+
+$$
+\begin{array} { r } { { \bf z } _ { i } ^ { ( l ) } = \mu _ { i } + \Sigma _ { i } \epsilon ^ { ( l ) } , \qquad \mathrm { w h e r e } \quad \epsilon ^ { ( l ) } \sim \mathcal { N } ( { \bf 0 } , { \bf I } ) , \qquad \mathrm { f o r } \quad l = 1 , \dots , L , } \end{array}
+$$
+
+and have
+
+$$
+\mathbb { E } _ { q _ { \phi } ( \mathbf { z } _ { i } | \mathbf { x } _ { i } ) } \left[ \log p _ { \theta } ( \mathbf { x } _ { i } | \mathbf { z } _ { i } ) + \log p _ { \theta } ( \mathbf { y } _ { i } | \mathbf { z } _ { i } ) \right] \approx \frac { 1 } { L } \sum _ { l = 1 } ^ { L } \log p _ { \theta } \left( \mathbf { x } _ { i } | \mathbf { z } _ { i } ^ { ( l ) } \right) + \log p _ { \theta } \left( \mathbf { y } _ { i } | \mathbf { z } _ { i } ^ { ( l ) } \right) .
+$$
+
+Notice that we parameterized $q _ { \phi } ( \mathbf { z } _ { i } | \mathbf { x } _ { i } )$ above to obtain the VCCA objective; this is useful when the first view is available for downstream tasks, in which case we can directly apply $q _ { \phi } ( \mathbf { z } _ { i } | \mathbf { x } _ { i } )$ to obtain its projection (as features). One could also derive likelihood lower bounds by parameterizing the approximate posteriors $q _ { \phi } ( \mathbf { z } _ { i } | \mathbf { y } _ { i } )$ and $q _ { \phi } ( \mathbf { z } _ { i } | \mathbf { x } _ { i } , \mathbf { y } _ { i } )$ , and optimize their convex combinations for training. We give a sketch of VCCA in Figure 1 (right).
+
+![](images/94cf35c9dc267919464e46591d6c5cab4fa1e5a4bd9ed7d9e3549dfe1dfdb48c.jpg)  
+Figure 2: VCCA-private: variational CCA with view-specific private variables.
+
+Connection to multi-view autoencoder (MVAE) If we use the Gaussian observation models
+
+$$
+\begin{array} { r } { \log p _ { \theta } ( \mathbf { x } | \mathbf { z } ) = \log \mathcal { N } ( \mathbf { g } _ { x } ( \mathbf { z } ; \theta _ { x } ) , \mathbf { I } ) , \qquad \quad \log p _ { \theta } ( \mathbf { y } | \mathbf { z } ) = \log \mathcal { N } ( \mathbf { g } _ { y } ( \mathbf { z } ; \theta _ { y } ) , \mathbf { I } ) , } \end{array}
+$$
+
+we observe that $\log p _ { \pmb { \theta } } \left( \mathbf { x } _ { i } | \mathbf { z } _ { i } ^ { ( l ) } \right)$ and $\log p _ { \pmb { \theta } } \left( \mathbf { y } _ { i } | \mathbf { z } _ { i } ^ { ( l ) } \right)$ measure the reconstruction errors of each view’s inputs from samples z(l)i u sing the two DNNs $\mathbf { g } _ { x }$ and $\mathbf { g } _ { y }$ respectively. In this case, maximizing $\mathcal { L } ( \mathbf { x } , \mathbf { y } ; \pmb { \theta } , \phi )$ is equivalent to
+
+$$
+\operatorname* { n i n } _ { \substack { \boldsymbol { y } , \boldsymbol { \phi } } } \quad \frac { 1 } { N } \sum _ { i = 1 } ^ { N } D _ { K L } ( q _ { \boldsymbol { \phi } } ( \mathbf { z } _ { i } | \mathbf { x } _ { i } ) | | \boldsymbol { p } ( \mathbf { z } _ { i } ) ) + \frac { 1 } { 2 N L } \sum _ { i = 1 } ^ { N } \sum _ { l = 1 } ^ { L } \Big \| \mathbf { x } _ { i } - \mathbf { g } _ { x } \left( \mathbf { z } _ { i } ^ { ( l ) } ; \boldsymbol { \theta } _ { x } \right) \Big \| ^ { 2 } + \Big \| \mathbf { y } _ { i } - \mathbf { g } _ { y } \left( \mathbf { z } _ { i } ^ { ( l ) } ; \boldsymbol { \theta } _ { y } \right) \Big \| ^ { 2 } ,
+$$
+
+$$
+\begin{array} { r } { \mathbf { z } _ { i } ^ { ( l ) } = \pmb { \mu } _ { i } + \pmb { \Sigma } _ { i } \pmb { \epsilon } ^ { ( l ) } , \quad \mathrm { w h e r e } \ \pmb { \epsilon } ^ { ( l ) } \sim \mathcal { N } ( \mathbf { 0 } , \mathbf { I } ) , \quad l = 1 , \dots , L . } \end{array}
+$$
+
+Now, consider the case of $\Sigma _ { i } \to \mathbf { 0 }$ , for $i = 1 , \ldots , N$ , and we have $\mathbf { z } _ { i } ^ { ( l ) }  \pmb { \mu } _ { i }$ which is a deterministic function of $\mathbf { x }$ (and there is no need for sampling). In the limit, the second term of (9) reduces to
+
+$$
+\frac { 1 } { 2 N } \sum _ { i = 1 } ^ { N } \left\| \mathbf { x } _ { i } - \mathbf { g } _ { x } ( \mathbf { f } ( \mathbf { x } _ { i } ; \boldsymbol { \phi } _ { z } ) ; \boldsymbol { \theta } _ { x } ) \right\| ^ { 2 } + \left\| \mathbf { y } _ { i } - \mathbf { g } _ { y } ( \mathbf { f } ( \mathbf { x } _ { i } ; \boldsymbol { \phi } _ { z } ) ; \boldsymbol { \theta } _ { y } ) \right\| ^ { 2 } ,
+$$
+
+which is the objective of the multi-view autoencoder (MVAE, Ngiam et al., 2011). Note, however, that $\Sigma _ { i } \ \to \ 0$ is prevented by the VCCA objective as it results in a large penalty in $D _ { K L } ( q _ { \phi } ( \mathbf { z } _ { i } | \mathbf { x } _ { i } ) | | p ( \mathbf { z } _ { i } ) )$ . Compared with the MVAE objective, in the VCCA objective we are creating $L$ different “noisy” versions of the latent representation and enforce that these versions reconstruct the original inputs well. The “noise” distribution (the variances $\Sigma _ { i }$ ) are also learned and regularized by the KL divergence $D _ { K L } ( q _ { \phi } ( { \bf z } _ { i } | { \bf x } _ { i } ) | | p ( { \bf z } _ { i } ) )$ . Using the VCCA objective, we expect to learn different representations from those of MVAE, due to these regularization effects.
+
+# 2.1 EXTRACTING PRIVATE VARIABLES
+
+So far, VCCA aims at extracting only the latent variables $\mathbf { z }$ that are common to both views. A potential disadvantage of this model is that it assumes the common variables are sufficient by themselves to generate the views, which can be too restrictive in practice. Consider the example of audio and articulatory measurements as two views for speech. Although the transcription is a common variable behind the views, it combines with the physical environment and the vocal tract anatomy to generate the individual views. In other words, there might be large variations in the input space that can not be explained by the common variables, making the objective (4) hard to optimize. It may then be beneficial to explicitly model the private variables within each view.
+
+We therefore propose a new probabilistic graphical model, shown in Figure 2, that we refer to as VCCA-private. We introduce two sets of hidden variables $\mathbf { h } _ { x } \in \mathbb { R } ^ { d _ { h _ { x } } }$ and $\mathbf { h } _ { y } \in \mathbb { R } ^ { d _ { h _ { y } } }$ to explain the aspects of $\mathbf { x }$ and $\mathbf { y }$ not captured by the common variables $\mathbf { z }$ . Under this model, the data likelihood
+
+is defined by
+
+$$
+\begin{array} { l } { p _ { \theta } ( \mathbf { x } , \mathbf { y } , \mathbf { z } , \mathbf { h } _ { x } , \mathbf { h } _ { y } ) = p ( \mathbf { z } ) p ( \mathbf { h } _ { x } ) p ( \mathbf { h } _ { y } ) p _ { \theta } ( \mathbf { x } | \mathbf { z } , \mathbf { h } _ { x } ; \theta _ { x } ) p _ { \theta } ( \mathbf { y } | \mathbf { z } , \mathbf { h } _ { y } ; \theta _ { y } ) , } \\ { p _ { \theta } ( \mathbf { x } , \mathbf { y } ) = \displaystyle \int \int \int p _ { \theta } ( \mathbf { x } , \mathbf { y } , \mathbf { z } , \mathbf { h } _ { x } , \mathbf { h } _ { y } ) d \mathbf { z } d \mathbf { h } _ { x } d \mathbf { h } _ { y } . } \end{array}
+$$
+
+To obtain tractable inference, we introduce the following factored variational posterior
+
+$$
+\begin{array} { r } { q _ { \phi } ( \mathbf { z } , \mathbf { h } _ { x } , \mathbf { h } _ { y } | \mathbf { x } , \mathbf { y } ) = q _ { \phi } ( \mathbf { z } | \mathbf { x } ; \phi _ { z } ) q _ { \phi } ( \mathbf { h } _ { x } | \mathbf { x } ; \phi _ { x } ) q _ { \phi } ( \mathbf { h } _ { y } | \mathbf { y } ; \phi _ { y } ) , } \end{array}
+$$
+
+where each factor is parameterized by a different DNN. Similarly to VCCA, we can derive a variational lower bound on the data likelihood for VCCA-private as
+
+$$
+\begin{array} { r l } & { \quad \log p _ { \theta } ( \mathbf { x } , \mathbf { y } ) } \\ & { \geq \iint \int d \varphi ( \mathbf { z } , \mathbf { h } _ { x } , \mathbf { h } _ { y } | \mathbf { x } , \mathbf { y } ) \log \frac { p _ { \theta } ( \mathbf { x } , \mathbf { y } , \mathbf { z } , \mathbf { h } _ { x } , \mathbf { h } _ { y } ) } { q _ { \phi } ( \mathbf { z } , \mathbf { h } _ { x } , \mathbf { h } _ { y } | \mathbf { x } , \mathbf { y } ) } d \mathbf { z } d \mathbf { h } _ { x } d \mathbf { h } _ { y } } \\ & { = \iint \int d \varphi ( \mathbf { z } , \mathbf { h } _ { x } , \mathbf { h } _ { y } | \mathbf { x } , \mathbf { y } ) \left[ \log \frac { p ( \mathbf { z } ) } { q _ { \phi } ( \mathbf { z } | \mathbf { x } ) } + \log \frac { p ( \mathbf { h } _ { x } ) } { q _ { \phi } ( \mathbf { h } _ { x } | \mathbf { x } ) } + \log \frac { p ( \mathbf { h } _ { y } ) } { q _ { \phi } ( \mathbf { h } _ { y } | \mathbf { y } ) } \right. } \\ & { \qquad \left. + \log p _ { \theta } ( \mathbf { z } | \mathbf { z } , \mathbf { h } _ { x } ) + \log p _ { \theta } ( \mathbf { z } | \mathbf { z } , \mathbf { h } _ { y } ) \right] d \mathbf { z } d \mathbf { h } _ { x } d \mathbf { h } _ { y } } \\ & { = - D _ { K L } ( q _ { \phi } ( \mathbf { z } | \mathbf { x } ) | | p ( \mathbf { z } ) ) - D _ { K L } ( q _ { \phi } ( \mathbf { h } _ { x } | \mathbf { x } ) | | p ( \mathbf { h } _ { x } ) ) - D _ { K L } ( q _ { \phi } ( \mathbf { h } _ { y } | \mathbf { y } ) | | p ( \mathbf { h } _ { y } ) ) } \\ &  \quad + \int \int q _ { \phi } ( \mathbf { z } | \mathbf { x } ) q _ { \phi } ( \mathbf { h } _ { x } | \mathbf { x } ) \log p _ { \theta } ( \mathbf { x } | \mathbf { z } , \mathbf { h } _ { x } ) d \mathbf { z } d \mathbf { h } _ { x } + \iint q _ { \phi } ( \mathbf { z } | \mathbf { x } ) q _ { \phi } ( \mathbf { h } _ { y } | \mathbf { y } ) \log p _ { \theta } ( \mathbf { y } | \mathbf { z } , \mathbf { h } _ { y } ) d \end{array}
+$$
+
+As in VCCA, the last two terms of (14) can be approximated by Monte Carlo sampling. For example, we draw samples of $\mathbf { z }$ and $\mathbf { h } _ { x }$ from their corresponding approximate posteriors, and concatenate their samples as inputs to the DNN parameterizing $p _ { \pmb { \theta } } ( \mathbf { x } | \mathbf { z } , \mathbf { h } _ { x } )$ . In this paper, we use simple Gaussian prior distributions for the private variables, i.e., $\mathbf { h } _ { x } \sim \mathcal { N } ( \mathbf { 0 } , \mathbf { I } )$ and $\mathbf { h } _ { y } \sim \mathcal { N } ( \mathbf { 0 } , \mathbf { I } )$ . We leave to future work to examine the effect of more sophisticated prior distributions for the latent variables.
+
+VCCA-private maximizes this lower bound on the training set, i.e.,
+
+$$
+\operatorname* { m a x } _ { \theta , \phi } \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \mathcal { L } _ { \mathrm { p r i v a t e } } ( \mathbf { x } _ { i } , \mathbf { y } _ { i } ; \mathbf { \boldsymbol { \theta } } , \phi ) .
+$$
+
+Optimization The objectives (5) and (14) decouple over the training samples and can be trained efficiently using stochastic gradient descent. Enabled by the reparameterization trick, unbiased gradient estimates are obtained by Monte Carlo sampling and the standard backpropagation procedure on minibatches of training samples. We apply the ADAM algorithm (Kingma and Ba, 2015) for optimizing our objectives.
+
+# 3 RELATED WORK
+
+Recently, there has been much interest in unsupervised deep generative models (Kingma and Welling, 2014; Rezende et al., 2014; Goodfellow et al., 2014; Gregor et al., 2015; Makhzani et al., 2016; Burda et al., 2016; Alain et al., 2016). A common motivation behind these models is that, with the expressive power of DNNs, the generative models can capture distributions for complex inputs. Additionally, if we are able to generate realistic samples from the learned distribution, we can infer that we have discovered the underlying structure of the data, which may allow us to reduce the sample complexity for learning for downstream tasks. These previous models have mostly focused on single-view data. Here we focus on the multi-view setting where multiple views of the data are present for feature extraction but only one view is available at test time (in downstream tasks).
+
+Some recent work has explored deep generative models for (semi-)supervised learning. Kingma et al. (2014) built a generative model based on variational autoencoders (VAEs) for semi-supervised classification, where the authors model the input distribution with two set of latent variables: the class label (if it is missing) and another set that models the intra-class variabilities (styles). Sohn et al. (2015) proposed a conditional generative model for structured output prediction, where the authors explicitly model the uncertainty in the input/output using Gaussian latent variables. While there are two set of observations (input and output labels) in these work, their graphical models are different from that of VCCA.
+
+Our work is also related to the deep multi-view probabilistic models based on restricted Boltzmann machines (Srivastava and Salakhutdinov, 2014; Sohn et al., 2014). We note that these are undirected graphical models for which both inference and learning are difficult, and one typically resorts to carefully designed variational approximation and Gibbs sampling procedures for training such models. In contrast, our models only require sampling from simple, standard distributions (such as Gaussians), and all parameters can be learned end-to-end by standard stochastic gradient methods. Therefore, our models are more scalable than the previous multi-view probabilistic models.
+
+On the other hand, there is a rich literature in modeling multi-view data using the same or similar graphical models behind VCCA/VCCA-private (Wang, 2007; Jia et al., 2010; Salzmann et al., 2010; Virtanen et al., 2011; Memisevic et al., 2012; Klami et al., 2013). Our methods differ from previous work in parameterizing the probability distributions using DNNs. This makes the model more powerful, while still having tractable objectives and efficient end-to-end training using the local reparameterization technique. We note that, unlike earlier work on probabilistic models of linear CCA (Bach and Jordan, 2005), VCCA does not optimize the same criterion, nor produce the same solution, as any linear or nonlinear CCA. However, we retain the terminology in order to clarify the connection with earlier work on probabilistic models for CCA, which we are extending with DNN models for the observations and for the variational posterior distribution approximation.
+
+# 4 EXPERIMENTAL RESULTS
+
+In this section, we compare different multi-view representation learning algorithms on three tasks involving several domains: image-image, speech-articulation, and image-text. The algorithms we choose to compare below are closely related to the proposed model or have been shown to have strong empirical performance under similar settings.
+
+• Linear CCA: its probabilistic interpretation motivates this work.   
+• Deep CCA (DCCA) (Andrew et al., 2013): see its objective in (1).   
+• Deep canonically correlated autoencoders (DCCAE) (Wang et al., 2015b): combination of the DCCA objective and the reconstruction errors of each view.   
+• Multi-view autoencoder (MVAE) (Ngiam et al., 2011): see its objective in (10).   
+• Multi-view contrastive loss (Hermann and Blunsom, 2014): based on the intuition that the distance between embeddings of paired examples $\mathbf { x } ^ { + }$ and $\mathbf { y } ^ { + }$ should be smaller than the distance between embeddings of $\mathbf { x } ^ { + }$ and an unmatched negative example $\mathbf { y } ^ { - }$ by a margin: $\operatorname* { m i n } _ { f , g } \ \mathcal { L } _ { c o n t r a s t } : = \frac { 1 } { N } \sum _ { i } ^ { N } \operatorname* { m a x } \left( 0 , \ m + d i s \left( f ( \mathbf { x } _ { i } ^ { + } ) , g ( \mathbf { y } _ { i } ^ { + } ) \right) - d i s \left( f ( \mathbf { x } _ { i } ^ { + } ) , g ( \mathbf { y } _ { i } ^ { - } ) \right) \right) ,$ where $\mathbf { y } _ { i } ^ { - }$ is a randomly sampled view 2 example, and $m$ is a margin hyperparameter. We use the
+
+cosine distance $\begin{array} { r } { d i s \left( \mathbf { a } , \mathbf { b } \right) = 1 - \left. \frac { \mathbf { a } } { \| \mathbf { a } \| } , \ \frac { \mathbf { b } } { \| \mathbf { b } \| } \right. } \end{array}$ .
+
+# 4.1 NOISY MNIST DATASET
+
+We first demonstrate our algorithms on the noisy MNIST dataset used by Wang et al. (2015b). The dataset is generated using the MNIST dataset (LeCun et al., 1998), which consists of $2 8 \times 2 8$ grayscale digit images, with $6 0 K / 1 0 K$ images for training/testing. We first linearly rescale the pixel values to the range $[ 0 , 1 ]$ . Then, we randomly rotate the images at angles uniformly sampled from $[ - \pi / 4 , \pi / 4 ]$ and the resulting images are used as view 1 inputs. For each view 1 image, we randomly select an image of the same identity (0-9) from the original dataset, add independent random noise uniformly sampled from [0, 1] to each pixel, and truncate the pixel final values to [0, 1] to obtain the corresponding view 2 sample. Selection of input images are given in Figure 3 (left). The original training set is further split into training/tuning sets of size $5 0 K / 1 0 K$ . The data generation process ensures that the digit identity is the only common variable underlying both views.
+
+![](images/4d3e1b453862a4241c4236728c099bbc3bff1644a1b351db312c4630ff24fbe7.jpg)  
+Figure 3: Left: Selection of view 1 images (top) and their corresponding view 2 images (bottom) from noisy MNIST. Right: 2D t-SNE visualization of features learned by previous multi-view models.
+
+To evaluate the amount of class information extracted by different methods, after unsupervised learning of latent representations, we reveal the labels and train a linear SVM on the projected view 1 training data (using the one-versus-all scheme), and use it to classify the projected test set. This experiment simulates the typical usage of multi-view learning methods, which is to extract useful representations for downstream discriminative tasks.
+
+Note that this synthetic dataset perfectly satisfies the multi-view assumption that the two views are independent given the class label, so the latent representation should contain precisely the class information. This is indeed achieved by CCA-based and contrastive loss-based multi-view approaches. In Figure 3 (right), we show 2D t-SNE (van der Maaten and Hinton, 2008) visualizations of the original view 1 inputs and view 1 projections by various deep multi-view methods.
+
+We use DNNs with 3 hidden layers of 1024 rectified linear units (ReLUs, Nair and Hinton, 2010) each to parameterize the distributions: $q _ { \phi } ( \mathbf { z } | \mathbf { x } )$ , $p _ { \pmb { \theta } } ( \mathbf { x } | \mathbf { z } )$ , $p _ { \pmb { \theta } } ( \mathbf { y } | \mathbf { z } )$ in VCCA, and additionally $q _ { \phi } ( \mathbf { h } _ { x } | \mathbf { x } )$ and $q _ { \phi } ( \mathbf { h } _ { y } | \mathbf { y } )$ in VCCA-private. The capacities of these networks are the same as those of their counterparts in DCCA and DCCAE from Wang et al. (2015b). The reconstruction networks $p _ { \pmb { \theta } } ( \mathbf { x } | \mathbf { z } )$ or $p _ { \pmb { \theta } } ( \mathbf { x } | \mathbf { z } , \mathbf { h } _ { x } )$ model each pixel of $\mathbf { x }$ as an independent Bernoulli variable and parameterize its mean (using a sigmoid activation); $p _ { \pmb { \theta } } ( \mathbf { y } | \mathbf { z } )$ and $p _ { \pmb { \theta } } ( \mathbf { y } | \mathbf { z } , \mathbf { h } _ { y } )$ model $\mathbf { y }$ with diagonal Gaussians and parameterize the mean (using a sigmoid activation) and standard deviation for each pixel dimension. We tune the dimensionality $d _ { z }$ over $\{ 1 0 , 2 0 , 3 0 , 4 0 , 5 0 \}$ , and fix $d _ { h _ { x } } = d _ { h _ { y } } = 3 0$ for VCCA-private. We select the hyperparameter combination that yields the best SVM classification accuracy on the projected tuning set, and report the corresponding accuracy on the projected test set.
+
+The effect of dropout We add dropout (Srivastava et al., 2014) to all intermediate layers and the input layers and find it to be very useful in our models, with most of the gain coming from dropout applied to the samples of $\mathbf { z }$ , $\mathbf { h } _ { x }$ and $\mathbf { h } _ { y }$ . This is because dropout encourages each latent dimension to reconstruct the inputs well in the absence of other dimensions, and therefore avoids learning coadapted features. Intuitively, in VCCA-private dropout also helps to prevent the degenerate situation where the pathways $\mathbf { x } \to \mathbf { h } _ { x } \to \mathbf { x }$ and $\mathbf { y }  \mathbf { h } _ { y }  \mathbf { y }$ achieve good reconstruction while ignoring $\mathbf { z }$ (e.g., by setting it to a constant). We use the same dropout rate for all layers and tune it over $\{ 0 , 0 . 1 , 0 . 2 , 0 . 3 , 0 . 4 \}$ .
+
+We show the 2D t-SNE embeddings of the common variables $\mathbf { z }$ learned by VCCA and VCCA-private on test set in Figure 4. We observe that in general, VCCA/VCCA-private tend to separate the classes in the projection well; dropout significantly improves the performance of both VCCA and VCCAprivate, with the latter slightly outperforming the former. While such class separation can also be achieved by DCCA/contrastive loss as well, these methods can not naturally generate samples in the input space. On the other hand, such separation is not achieved by multi-view autoencoders.
+
+![](images/6029ce042a12b82b310d492e7252093b471226c5e8f698c2c263cf4972437533.jpg)  
+Figure 4: 2D t-SNE embeddings of the extracted shared variables $\mathbf { z }$ on the test set by VCCA (top row) and VCCA-private (bottom row) for different dropout rates. $d _ { z } = 4 0$ for both algorithms.
+
+![](images/54bac0f2be82393a5938196bd107102f4254ce2324e28451011619fd5cb4d27c.jpg)  
+Figure 5: Sample reconstruction of view 2 images from the test set by VCCA and VCCA-private.
+
+The effect of private variables on reconstructions We show sample reconstructions (mean and standard deviation) by VCCA for the view 2 images from the test set in Figure 5 (columns 2 and 3). We observe that for each input, the mean reconstruction of $\mathbf { y } _ { i }$ by VCCA is a prototypical image of the same digit, regardless of the individual style in $\mathbf { y } _ { i }$ . This is to be expected, as $\mathbf { y } _ { i }$ contains an arbitrary image of the same digit as $\mathbf { x } _ { i }$ , and the variation in background noise in $\mathbf { y } _ { i }$ does not appear in $\mathbf { x } _ { i }$ and can not be reflected in $q _ { \phi } ( \mathbf { z } | \mathbf { x } )$ ; thus the best way for $\mathbf { p } _ { \pmb { \theta } } ( \mathbf { y } | \mathbf { z } )$ to model $\mathbf { y } _ { i }$ is to output a prototypical image of that class to achieve on average small reconstruction error. On the other hand, since $\mathbf { y } _ { i }$ contains little rotation of the digits, this variation is suppressed to a large extent in $q _ { \phi } ( \mathbf { z } | \mathbf { x } )$ (it is no longer the major variation in $\mathbf { z }$ as in the original inputs).
+
+We show sample reconstructions by VCCA-private for the same set of view 2 images in Figure 5 (columns 4 and 5). With the help of private variables $\mathbf { h } _ { y }$ (as part of the input to $p _ { \pmb { \theta } } ( \mathbf { y } | \mathbf { z } , \mathbf { h } _ { y } ) )$ , the model does a much better job in reconstructing the styles of y. And by disentangling the private variables from the shared variables, $q _ { \phi } ( \mathbf { z } | \mathbf { x } )$ achieves even better class separation than VCCA does.
+
+Table 1: Performance of features extracted by different methods for downstream tasks: Classification error rates of linear SVMs on MNIST, mean phone error rate (PER) over 6 folds on XRMB, and mean average precision (mAP) for unimodal retrieval on MIR-Flickr.   
+
+<table><tr><td>Method</td><td>Noisy MNIST Error rate (%,↓)</td><td>XRMB PER(%,↓)</td><td>Flickr mAP (↑)</td></tr><tr><td>Original inputs</td><td>13.1</td><td>37.6</td><td>0.480</td></tr><tr><td>CCA</td><td>19.1</td><td>29.4</td><td>0.529</td></tr><tr><td>DCCA</td><td>2.9</td><td>25.4</td><td>0.573</td></tr><tr><td>DCCAE</td><td>2.2</td><td>25.4</td><td>0.573</td></tr><tr><td>Contrastive</td><td>2.7</td><td>24.6</td><td>0.565</td></tr><tr><td>MVAE</td><td>11.7</td><td>29.4</td><td>0.477</td></tr><tr><td>VCCA</td><td>3.0</td><td>28.0</td><td>0.605</td></tr><tr><td>VCCA-private</td><td>2.4</td><td>25.2</td><td>0.609</td></tr></table>
+
+We also note that the standard deviation of the reconstruction is low within the digit and high outside the digit, implying that $p _ { \pmb { \theta } } ( \mathbf { y } | \mathbf { z } , \mathbf { h } _ { y } )$ is able to separate the background noise from the digit image.
+
+Disentanglement of private/shared variables In Figure 6 (in Appendix) we provide the 2D $t$ - SNE embeddings of the shared variables $\mathbf { z }$ (top row) and the private variables $\mathbf { h } _ { x }$ (bottom row) learned by VCCA-private. In the embedding of $\mathbf { h } _ { x }$ , digits with different identities but the same rotation are mapped close together, and the rotation varies smoothly from left to right, confirming that the private variables contain little class information but mainly style information.
+
+Finally, we give the test error rates of linear SVMs applied to the features learned with different models in Table 1. VCCA-private is comparable in performance to the best previous approach (DCCAE), while having the advantage that it can also generate.
+
+# 4.2 XRMB SPEECH-ARTICULATION DATASET
+
+We now consider the task of learning acoustic features for speech recognition. We use data from the Wisconsin $\mathrm { X }$ -ray microbeam (XRMB) corpus (Westbury, 1994), which contains simultaneously recorded speech and articulatory measurements from 47 American English speakers. We follow the setup of Wang et al. (2015a,b) and use the learned features for speaker-independent phonetic recognition.2 The two input views are standard 39D acoustic features $\lvert 1 3 \ \mathrm { m e l }$ frequency cepstral coefficients (MFCCs) and their first and second derivatives) and 16D articulatory features (horizontal/vertical displacement of 8 pellets attached to several parts of the vocal tract), each then concatenated over a 7-frame window around each frame to incorporate context. The speakers are split into disjoint sets of 35/8/2/2 speakers for feature learning/recognizer training/tuning/testing. The 35 speakers for feature learning are fixed; the remaining 12 are used in a 6-fold experiment (recognizer training on 8 speakers, tuning on 2 speakers, and testing on the remaining 2 speakers). Each speaker has roughly $5 0 K$ frames. We remove the per-speaker mean and variance of the articulatory measurements for each training speaker, and remove the mean of the acoustic measurements for each utterance. All learned feature types are used in a “tandem” speech recognizer (Hermansky et al., 2000), i.e., they are appended to the original 39D features and used in a standard hidden Markov model (HMM)-based recognizer with Gaussian mixture observation distributions.
+
+Each algorithm uses up to 3 ReLU hidden layers, each of 1500 units, for the projection and reconstruction mappings. For VCCA/VCCA-private, we use Gaussian observation models as the inputs are real-valued. In contrast to the MNIST experiments, we do not learn the standard deviations of each output dimension on training data, as this leads to poor downstream task performance. Instead, we use isotropic covariances for each view, and tune the standard deviations by grid search. The best model uses a smaller standard deviation (0.1) for the view 2 than for view 1 (1.0), effectively putting more emphasis on the reconstruction of articulatory measurements. Our best performing VCCA model uses $d _ { z } = 7 0$ , while the best performing VCCA-private model uses $d _ { z } = 7 0$ and $d _ { h _ { x } } = d _ { h _ { y } } = 1 0$ .
+
+The mean phone error rates (PER) over 6 folds obtained by different algorithms are given in Table 1.   
+Our methods achieve competitive performance in comparison to previous deep multi-view methods.
+
+# 4.3 MIR-FLICKR DATASET
+
+Finally, we consider the task of learning cross-modality features for topic classification on the MIRFlickr database (Huiskes and Lew, 2008). The Flickr database contains 1 million images accompanied by user tags, among which 25000 images are labeled with 38 topic classes (each image may be categorized as multiple topics). We use the same image and text features as in previous work (Srivastava and Salakhutdinov, 2014; Sohn et al., 2014): the image feature is 3857 dimensional real-valued vector, composed of Pyramid Histogram of Words (PHOW) (Bosch et al., 2007), GIST (Oliva and Torralba, 2001), and MPEG-7 descriptors (Manjunath et al., 2001), while the text feature is a 2000-dimensional binary vector of frequent tags.
+
+Following the same protocol as Sohn et al. (2014), we train multi-view representations using the unlabelled data,3 and use projected image features of the labeled data (further divided into splits of 10000/5000/10000 samples for training/tuning/testing) for training and evaluating a classifier that predicts the topic labels, corresponding to the unimodal query task in Srivastava and Salakhutdinov (2014); Sohn et al. (2014). For each algorithm, we select the model which achieves the highest mean average precision (mAP) on the validation set, and report its performance on the test set.
+
+Each algorithm uses up to 4 ReLU hidden layers, each of 1024 units, for the projection and reconstruction mappings. For VCCA/VCCA-private, we use Gaussian observation models with isotropic covariance for image features, with standard deviation tuned by grid search, and a Bernoulli model for text features. In this experiment, we also found it helpful to tune an additional trade-off parameter for the text-view likelihood (cross-entropy); the best VCCA/VCCA-private models prefer a large trade-off parameter of the level $1 0 ^ { 4 }$ , emphasizing the reconstruction of the sparse text-view inputs. Our best performing VCCA model uses $d _ { z } = 1 0 2 4$ , while the best performing VCCA-private model uses $d _ { z } = 1 0 2 4$ and $d _ { h _ { x } } = d _ { h _ { y } } = 1 6$ .
+
+As shown in Table 1, VCCA/VCCA-private achieve significantly higher mAPs than other methods considered here. Being much easier to train, the performance of our methods are competitive with the previous state-of-the-art mAP result of 0.607 achieved by the multi-view RBMs of Sohn et al. (2014) under the same setting.
+
+# 5 CONCLUSIONS
+
+We have proposed variational canonical correlation analysis (VCCA), a deep generative method for multi-view representation learning. Our method embodies a natural idea for multi-view learning: the multiple views can be generated from a small set of shared latent variables. VCCA is parameterized by DNNs and can be trained efficiently by backpropagation, and is therefore scalable. We have also shown that, by modeling the private variables that are specific to each view, the VCCA-private variant can disentangle shared/private variables and provide higher-quality reconstructions.
+
+In the future, we will explore other prior distributions such as mixtures of Gaussians or discrete random variables, which may enforce clustering in the latent space and in turn work better for discriminative tasks. We will also explore other observation models, including replacing the autoencoder objective with that of adversarial networks (Goodfellow et al., 2014; Makhzani et al., 2016; Chen et al., 2016). Another direction is to explicitly incorporate the structure of the inputs, such as the sequence structure of speech and text and the spatial structure of images.
+
+# ACKOWLEDGEMENTS
+
+This research was supported by NSF grant IIS-1321015. The opinions expressed in this work are those of the authors and do not necessarily reflect the views of the funding agency. This research used GPUs donated by NVIDIA Corporation.
+
+#
+
+REFERENCES   
+S. Akaho. A kernel method for canonical correlation analysis. In Proceedings of the International Meeting of the Psychometric Society (IMPS2001), 2001.   
+G. Alain, Y. Bengio, L. Yao, J. Yosinski, E. Thibodeau-Laufer, S. Zhang, and P. Vincent. GSNs: Generative stochastic networks. Information and Inference, 5(2):210–249, 2016.   
+G. Andrew, R. Arora, J. Bilmes, and K. Livescu. Deep canonical correlation analysis. In Int. Conf. Machine Learning, pages 1247–1255, 2013.   
+F. R. Bach and M. I. Jordan. Kernel independent component analysis. Journal of Machine Learning Research, 3:1–48, 2002.   
+F. R. Bach and M. I. Jordan. A probabilistic interpretation of canonical correlation analysis. Technical Report 688, Dept. of Statistics, University of California, Berkeley, 2005.   
+A. Bosch, A. Zisserman, and X. Munoz. Image classification using random forests and ferns. In 2007 IEEE 11th International Conference on Computer Vision, pages 1–8. IEEE, 2007.   
+Y. Burda, R. Grosse, and R. Salakhutdinov. Importance weighted autoencoders. 2016.   
+X. Chen, Y. Duan, R. Houthooft, J. Schulman, I. Sutskever, and P. Abbeel. InfoGAN: Interpretable representation learning by information maximizing generative adversarial nets. arXiv:1606.03657 [cs.LG], 2016.   
+I. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial nets. pages 2672–2680, 2014.   
+K. Gregor, I. Danihelka, A. Graves, D. J. Rezende, and D. Wierstra. DRAW: A recurrent neural network for image generation. In Int. Conf. Machine Learning, pages 1462–1471, 2015.   
+K. M. Hermann and P. Blunsom. Multilingual distributed representations without word alignment. In Int. Conf. Learning Representations, 2014. arXiv:1312.6173 [cs.CL].   
+H. Hermansky, D. P. W. Ellis, and S. Sharma. Tandem connectionist feature extraction for conventional HMM systems. In IEEE Int. Conf. Acoustics, Speech and Sig. Proc., pages 1635–1638, 2000.   
+H. Hotelling. Relations between two sets of variates. Biometrika, 28(3/4):321–377, 1936.   
+M. J. Huiskes and M. S. Lew. The mir flickr retrieval evaluation. In Proceedings of the 1st ACM International Conference on Multimedia Information Retrieval, pages 39–43, 2008. doi: 10.1145/ 1460096.1460104. URL http://doi.acm.org/10.1145/1460096.1460104.   
+Y. Jia, M. Salzmann, and T. Darrell. Factorized latent spaces with structured sparsity. pages 982– 990, 2010.   
+D. Kingma and J. Ba. ADAM: A method for stochastic optimization. In Int. Conf. Learning Representations, 2015.   
+D. P. Kingma and M. Welling. Auto-encoding variational Bayes. arXiv:1312.6114 [stat.ML], 2014.   
+D. P. Kingma, S. Mohamed, D. J. Rezende, and M. Welling. Semi-supervised learning with deep generative models. pages 3581–3589, 2014.   
+A. Klami, S. Virtanen, and S. Kaski. Bayesian canonical correlation analysis. Journal of Machine Learning Research, pages 965–1003, 2013.   
+P. L. Lai and C. Fyfe. Kernel and nonlinear canonical correlation analysis. Int. J. Neural Syst., 10 (5):365–377, 2000.   
+Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proc. IEEE, 86(11):2278–2324, 1998.   
+A. Lu, W. Wang, M. Bansal, K. Gimpel, and K. Livescu. Deep multilingual correlation for improved word embeddings. In The 2015 Conference of the North American Chapter of the Association for Computational Linguistics - Human Language Technologies (NAACL-HLT 2015), 2015.   
+A. Makhzani, J. Shlens, N. Jaitly, and I. Goodfellow. Adversarial autoencoders. In Int. Conf. Learning Representations, 2016.   
+B. S. Manjunath, J.-R. Ohm, V. V. Vasudevan, and A. Yamada. Color and texture descriptors. IEEE Transactions on circuits and systems for video technology, 11(6):703–715, 2001.   
+T. Melzer, M. Reiter, and H. Bischof. Nonlinear feature extraction using generalized canonical correlation analysis. In Int. Conf. Artificial Neural Networks, pages 353–360, 2001.   
+R. Memisevic, L. Sigal, and D. J. Fleet. Shared kernel information embedding for discriminative inference. IEEE Trans. Pattern Analysis and Machine Intelligence, 34(4):778–790, 2012.   
+V. Nair and G. E. Hinton. Rectified linear units improve restricted Boltzmann machines. In Int. Conf. Machine Learning, pages 807–814, 2010.   
+J. Ngiam, A. Khosla, M. Kim, J. Nam, H. Lee, and A. Ng. Multimodal deep learning. In Int. Conf. Machine Learning, pages 689–696, 2011.   
+A. Oliva and A. Torralba. Modeling the shape of the scene: A holistic representation of the spatial envelope. International journal of computer vision, 42(3):145–175, 2001.   
+D. Povey, A. Ghoshal, G. Boulianne, L. Burget, O. Glembek, N. Goel, M. Hannemann, P. Motlicek, Y. Qian, P. Schwarz, J. Silovsky, G. Stemmer, and K. Vesely. The Kaldi speech recognition toolkit. In IEEE Workshop on Automatic Speech Recognition and Understanding, 2011.   
+D. J. Rezende, S. Mohamed, and D. Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Int. Conf. Machine Learning, pages 1278–1286, 2014.   
+M. Salzmann, C. H. Ek, R. Urtasun, and T. Darrell. Factorized orthogonal latent spaces. In Int. Workshop on Artificial Intelligence and Statistics, pages 701–708, 2010.   
+K. Sohn, W. Shang, and H. Lee. Improved multimodal deep learning with variation of information. pages 2141–2149, 2014.   
+K. Sohn, H. Lee, and X. Yan. Learning structured output representation using deep conditional generative models. pages 3465–3473, 2015.   
+N. Srivastava and R. Salakhutdinov. Multimodal learning with deep boltzmann machines. Journal of Machine Learning Research, 15:2949–2980, 2014.   
+N. Srivastava, G. E. Hinton, A. Krizhevsky, I. Sutskever, and R. R. Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15:1929–1958, 2014.   
+L. J. P. van der Maaten and G. E. Hinton. Visualizing data using $t$ -SNE. Journal of Machine Learning Research, 9:2579–2605, 2008.   
+S. Virtanen, A. Klami, and S. Kaski. Bayesian CCA via group sparsity. In Int. Conf. Machine Learning, pages 457–464, 2011.   
+C. Wang. Variational Bayesian approach to canonical correlation analysis. IEEE Trans. Neural Networks, 18(3):905–910, 2007.   
+W. Wang and K. Livescu. Large-scale approximate kernel canonical correlation analysis. In Int. Conf. Learning Representations, 2016. arXiv:1511.04773 [cs.LG].   
+W. Wang, R. Arora, K. Livescu, and J. Bilmes. Unsupervised learning of acoustic features via deep canonical correlation analysis. In IEEE Int. Conf. Acoustics, Speech and Sig. Proc., 2015a.   
+W. Wang, R. Arora, K. Livescu, and J. Bilmes. On deep multi-view representation learning. In Int. Conf. Machine Learning, pages 1083–1092, 2015b.
+
+J. R. Westbury. X-Ray Microbeam Speech Production Database User’s Handbook Version 1.0, 1994. F. Yan and K. Mikolajczyk. Deep correlation for matching images and text. In IEEE Computer Society Conf. Computer Vision and Pattern Recognition, pages 3441–3450, 2015. S. J. Young, D. Kernshaw, J. Odell, D. Ollason, V. Valtchev, and P. Woodland. The HTK book version 2.2. Technical report, Entropic, Ltd., 1999.
+
+# A ADDITIONAL T-SNE VISUALIZATION OF NOISY MNIST
+
+![](images/75fc2d64d13d742f31a2eb39292512368c0b88e3d21db40621c9404dee6e5307.jpg)  
+Figure 6: 2D $t$ -SNE embedding of the shared variables $\mathbf { z } \in \mathbb { R } ^ { 4 0 }$ (top) and private variables $\mathbf { h } _ { x } \in \mathbb { R } ^ { 3 0 }$ (bottom).

parse/train/H1Heentlx/H1Heentlx_content_list.json

@@ -0,0 +1,1223 @@
+[
+    {
+        "type": "text",
+        "text": "DEEP VARIATIONAL CANONICAL CORRELATION ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            99,
+            637,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Weiran Wang1 Xinchen Yan2 Honglak Lee2 Karen Livescu1   \n1TTI-Chicago, Chicago, IL 60637, USA   \n2University of Michigan, Ann Arbor, MI 48109, USA   \n1{weiranwang,klivescu}@ttic.edu {xcyan,honglak}@umich.edu ",
+        "bbox": [
+            184,
+            167,
+            766,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            263,
+            544,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present deep variational canonical correlation analysis (VCCA), a deep multiview learning model that extends the latent variable model interpretation of linear CCA (Bach and Jordan, 2005) to nonlinear observation models parameterized by deep neural networks (DNNs). Computing the marginal data likelihood, as well as inference of the latent variables, are intractable under this model. We derive a variational lower bound of the data likelihood by parameterizing the posterior density of the latent variables with another DNN, and approximate the lower bound via Monte Carlo sampling. Interestingly, the resulting model resembles that of multiview autoencoders (Ngiam et al., 2011), with the key distinction of an additional sampling procedure at the bottleneck layer. We also propose a variant of VCCA called VCCA-private which can, in addition to the “common variables” underlying both views, extract the “private variables” within each view. We demonstrate that VCCA-private is able to disentangle the shared and private information for multi-view data without hard supervision. ",
+        "bbox": [
+            233,
+            295,
+            764,
+            489
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            511,
+            336,
+            526
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In the multi-view representation learning setting, we have multiple views/measurements of the same underlying signal, and the goal is to learn useful features of each view using complementary information contained in the views. The intuition underlying this setting is that the learned features can help uncover the common sources of variation in the views, which can be helpful for exploratory analysis or for downstream tasks. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            609
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A classical approach in this setting is canonical correlation analysis (CCA, Hotelling, 1936) and its nonlinear extensions, including the kernel extension (Lai and Fyfe, 2000; Akaho, 2001; Melzer et al., 2001; Bach and Jordan, 2002) and the deep neural network (DNN) extension (Andrew et al., 2013; Wang et al., 2015b). CCA projects two random vectors $\\mathbf { x } \\in \\mathbb { R } ^ { d _ { x } }$ and $\\mathbf { y } \\in \\mathbb { R } ^ { d _ { y } }$ into a lowerdimensional subspace so that the projections are maximally correlated. There is a probabilistic latent variable model interpretation of linear CCA (Bach and Jordan, 2005) as shown in Figure 1 (left). Assume that $\\mathbf { x }$ and y are linear functions of some lower-dimensional random variable $\\textbf { z } \\in \\mathbb { R } ^ { d _ { z } }$ , where $d _ { z } \\leq \\operatorname* { m i n } ( d _ { x } , d _ { y } )$ . When the prior distribution of the latent variable $p ( \\mathbf { z } )$ and the conditional distributions $p ( \\mathbf { x } | \\mathbf { z } )$ and $p ( \\mathbf { y } \\vert \\mathbf { z } )$ are Gaussian, Bach and Jordan (2005) showed that $\\mathbb { E } [ \\mathbf { z } | \\mathbf { x } ]$ (resp. $\\mathbb { E } [ \\mathbf { z } | \\mathbf { y } ] )$ lives in the same space as the linear CCA projection for $\\mathbf { x }$ (resp. y). ",
+        "bbox": [
+            173,
+            617,
+            825,
+            757
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This generative interpretation of CCA is often lost in nonlinear extensions of CCA. For example, in deep CCA (DCCA, (Andrew et al., 2013)), to extend CCA to nonlinear mappings with greater representation power, one extracts nonlinear features from the original inputs of each view using two DNNs, f for $\\mathbf { x }$ and $\\mathbf { g }$ for $\\mathbf { y }$ , so that the canonical correlation of the DNN outputs (measured by a linear CCA with projection matrices $\\mathbf { U }$ and $\\mathbf { V }$ ) is maximized. Formally, given a dataset of $N$ pairs of observations $( \\mathbf { x } _ { 1 } , \\mathbf { y } _ { 1 } ) , \\dotsc , ( \\mathbf { x } _ { N } , \\mathbf { y } _ { N } )$ of the random vectors $\\displaystyle ( \\mathbf { x } , \\mathbf { y } )$ , DCCA optimizes ",
+        "bbox": [
+            174,
+            762,
+            825,
+            848
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d04b1575d80b54a5a22ee500f47027fc2622022ed79883846d4fe56348d9c763.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\underset { \\mathbf { w } _ { \\mathrm { f } } , \\mathbf { w } _ { \\mathbf { g } } } { \\operatorname* { m a x } } \\ : \\mathrm { t r } \\left( \\mathbf { U } ^ { \\top } \\mathbf { f } ( \\mathbf { X } ) \\mathbf { g } ( \\mathbf { Y } ) ^ { \\top } \\mathbf { V } \\right) } & { \\mathrm { ~ s . t . ~ } \\mathbf { U } ^ { \\top } \\left( \\mathbf { f } ( \\mathbf { X } ) \\mathbf { f } ( \\mathbf { X } ) ^ { \\top } \\right) \\mathbf { U } = \\mathbf { V } ^ { \\top } \\left( \\mathbf { g } ( \\mathbf { Y } ) \\mathbf { g } ( \\mathbf { Y } ) ^ { \\top } \\right) \\mathbf { V } = N \\mathbf { I } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            852,
+            789,
+            878
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { f } ( \\mathbf { X } ) = [ \\mathbf { f } ( \\mathbf { x } _ { 1 } ) , \\dots , \\mathbf { f } ( \\mathbf { x } _ { N } ) ]$ and $\\mathbf { g } ( \\mathbf { Y } ) = [ \\mathbf { g } ( \\mathbf { y } _ { 1 } ) , \\dots , \\mathbf { g } ( \\mathbf { y } _ { N } ) ]$ , and $\\mathbf { W _ { f } }$ denotes all weight parameters of the DNN f (and similarly for $\\mathbf { g }$ ). ",
+        "bbox": [
+            176,
+            893,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/bb2dbd35f41d89ff34e8e2a1eee60726a3db9398263cd445bbccb4c32a1eba91.jpg",
+        "image_caption": [
+            "Figure 1: Left: Probabilistic interpretation of CCA (Bach and Jordan, 2005). Right: The deep variational CCA (VCCA) model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            212,
+            99,
+            787,
+            309
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "DCCA has achieved good performance in the multi-view representation learning setting across different domains (Wang et al., 2015b,a; Lu et al., 2015; Yan and Mikolajczyk, 2015). However, a disadvantage of DCCA is that it directly looks for DNNs that can map inputs into the low-dimensional space, without a model for generating samples from the latent space. Although Wang et al. (2015b)’s deep canonically correlated autoencoders (DCCAE) model optimizes the combination of the autoencoder objective (reconstruction errors) and the canonical correlation objective, the authors found that in practice, the canonical correlation term tends to dominate the reconstruction error terms in the DCCAE objective when tuning performance for a downstream task (especially when the inputs are noisy), and as a result the inputs are not reconstructed well. At the same time, optimization of the DCCA and DCCAE objectives is challenging due to the constraints that couple all training samples. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            512
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main contribution of this paper is the proposal of a new deep multi-view learning model named deep variational CCA (VCCA), which extends the latent variable model interpretation of linear CCA to nonlinear observation models parameterized by DNNs. Computing the marginal data likelihood, as well as inference of the latent variables, are intractable under this model. Inspired by variational autoencoders (VAE, Kingma and Welling, 2014), we parameterize the posterior distribution of the latent variables with another DNN, and derive a variational lower bound of the data likelihood as the objective of VCCA, which is further approximated by Monte Carlo sampling. With the reparameterization trick, sampling for the Monte Carlo approximation is trivial and all DNN weights in VCCA can be optimized jointly via stochastic gradient descent, using unbiased gradient estimates from small minibatches. Interestingly, VCCA is related to multi-view autoencoders (Ngiam et al., 2011), with the key distinctions of additional regularization on the posterior distribution and the sampling procedure at the bottleneck layer. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            685
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We also propose a variant of VCCA called VCCA-private that can, in addition to the “common variables” underlying both views, extract the “private variables” within each view. We demonstrate that VCCA-private is able to disentangle the shared and private information for multi-view data without hard supervision. Last but not least, as generative models, VCCA and VCCA-private enable us to obtain high-quality samples for the input of each view. ",
+        "bbox": [
+            174,
+            691,
+            825,
+            762
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 VARIATIONAL CCA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            775,
+            370,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The probabilistic latent variable model of CCA (Bach and Jordan, 2005) defines the following joint distribution over the random variables $\\displaystyle ( \\mathbf { x } , \\mathbf { y } )$ : ",
+        "bbox": [
+            174,
+            805,
+            823,
+            835
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f3aee4c1624868fff0126811028a203b5efece8d5e556e254968b360c2e1d5f0.jpg",
+        "text": "$$\np ( \\mathbf { x } , \\mathbf { y } , \\mathbf { z } ) = p ( \\mathbf { z } ) p ( \\mathbf { x } | \\mathbf { z } ) p ( \\mathbf { y } | \\mathbf { z } ) , \\qquad p ( \\mathbf { x } , \\mathbf { y } ) = \\int p ( \\mathbf { x } , \\mathbf { y } , \\mathbf { z } ) d \\mathbf { z } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            840,
+            717,
+            873
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The assumption underlying this model is that, conditioned on the latent variables $\\textbf { z } \\in \\mathbb { R } ^ { d _ { z } }$ , the two views $\\mathbf { x }$ and $\\mathbf { y }$ are independent. However, linear observation models $( p ( \\mathbf { x } | \\mathbf { z } )$ and $p ( \\mathbf { y } \\vert \\mathbf { z } )$ as shown in Figure 1 (left)) have limited representation power. In this paper, we consider nonlinear observation models $p _ { \\pmb { \\theta } } ( \\mathbf { x } | \\mathbf { z } ; \\pmb { \\theta } _ { x } )$ and $p _ { \\pmb { \\theta } } ( \\mathbf { y } | \\mathbf { z } ; \\pmb { \\theta } _ { y } )$ , parameterized by $\\pmb { \\theta } _ { x }$ and $\\theta _ { y }$ respectively, which can be the collections of weights of DNNs. In this case, the marginal likelihood $p _ { \\pmb { \\theta } } ( \\mathbf { x } , \\mathbf { y } )$ does not have a closed form. In addition, the inference problem $p _ { \\pmb { \\theta } } ( \\mathbf { z } | \\mathbf { x } )$ —the problem of inferring the latent variables given one of the views—is also intractable. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            102,
+            825,
+            160
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Inspired by Kingma and Welling (2014)’s work on variational autoencoders (VAE), we approximate $p _ { \\pmb { \\theta } } ( \\mathbf { z } | \\mathbf { x } )$ with the conditional density $q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ; \\phi _ { z } )$ , where $\\phi _ { z }$ is the collection of parameters of another DNN.1 We can derive a lower bound on the marginal data likelihood using $q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } )$ : ",
+        "bbox": [
+            174,
+            165,
+            825,
+            210
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2a31241f9668a02c893820e5df98b0b4fb94386a31172c11eac27f35d6b4d7d3.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\log p _ { \\theta } ( \\mathbf { x } , \\mathbf { y } ) = \\log p _ { \\theta } ( \\mathbf { x } , \\mathbf { y } ) \\int q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) d \\mathbf { z } = \\int \\log p _ { \\theta } ( \\mathbf { x } , \\mathbf { y } ) q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) d \\mathbf { z } } \\\\ & { \\qquad = \\int q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) \\left( \\log \\frac { q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) } { p _ { \\theta } ( \\mathbf { z } | \\mathbf { x } , \\mathbf { y } ) } + \\log \\frac { p _ { \\theta } ( \\mathbf { x } , \\mathbf { y } , \\mathbf { z } ) } { q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) } \\right) d \\mathbf { z } } \\\\ & { \\qquad = D _ { K L } ( q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) | | p _ { \\theta } ( \\mathbf { z } | \\mathbf { x } , \\mathbf { y } ) ) + \\mathbb { E } _ { q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) } \\left[ \\log \\frac { p _ { \\theta } ( \\mathbf { x } , \\mathbf { y } , \\mathbf { z } ) } { q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) } \\right] } \\\\ & { \\qquad \\geq \\mathbb { E } _ { q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) } \\left[ \\log \\frac { p _ { \\theta } ( \\mathbf { x } , \\mathbf { y } , \\mathbf { z } ) } { q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) } \\right] = : \\mathcal { L } ( \\mathbf { x } , \\mathbf { y } ; \\theta , \\phi ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            212,
+            736,
+            352
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where we used the fact that KL divergence is nonnegative in the last step. As a result, $\\mathcal { L } ( \\mathbf { x } , \\mathbf { y } ; \\pmb { \\theta } , \\phi )$ is a lower bound on the data log-likelihood $\\log _ { \\pmb { \\theta } } p ( \\mathbf { x } , \\mathbf { y } )$ . Substituting (2) into (3), we have ",
+        "bbox": [
+            173,
+            352,
+            823,
+            381
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8c9157ec19b190a391391a1ca9d81211f3aef443a43a3a877f4d844225367e77.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\mathcal { L } ( \\mathbf { x } , \\mathbf { y } ; \\pmb { \\theta } , \\phi ) = \\int q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) \\left( \\log \\frac { p ( \\mathbf { z } ) } { q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) } + \\log p _ { \\theta } ( \\mathbf { x } | \\mathbf { z } ) + \\log p _ { \\theta } ( \\mathbf { y } | \\mathbf { z } ) \\right) d \\mathbf { z } } \\\\ { \\displaystyle = - D _ { K L } ( q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) | | p ( \\mathbf { z } ) ) + \\mathbb { E } _ { q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) } \\left[ \\log p _ { \\theta } ( \\mathbf { x } | \\mathbf { z } ) + \\log p _ { \\theta } ( \\mathbf { y } | \\mathbf { z } ) \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            381,
+            764,
+            435
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "VCCA maximizes this variational lower bound on the data likelihood on the training set: ",
+        "bbox": [
+            173,
+            435,
+            754,
+            449
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1751fef8c23125ec742b4b484d36ba47632ecbfcb157acc8b206490bbb31296f.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\pmb { \\theta } , \\phi } \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\mathcal { L } ( \\mathbf { x } _ { i } , \\mathbf { y } _ { i } ; \\pmb { \\theta } , \\phi ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            449,
+            596,
+            493
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The first term in (4) measures the KL divergence between the approximate posterior distribution and the prior distribution of the latent variables $\\mathbf { z }$ . When the parameterization $q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } )$ is chosen properly, this term can be computed exactly in closed form. As a concrete example, let the variational approximate posterior be a multivariate Gaussian with diagonal covariance. That is, for a sample pair $\\left( \\mathbf { x } _ { i } , \\mathbf { y } _ { i } \\right)$ , we have ",
+        "bbox": [
+            173,
+            500,
+            825,
+            570
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b97d8a1df56db59ce5a177e9f032ab791e47b7884f9f75ec85b5bcbb844ff17a.jpg",
+        "text": "$$\n\\log q _ { \\phi } ( \\mathbf { z } _ { i } | \\mathbf { x } _ { i } ) = \\log \\mathcal { N } ( \\mathbf { z } _ { i } ; \\pmb { \\mu } _ { i } , \\pmb { \\Sigma } _ { i } ) , \\qquad \\quad \\pmb { \\Sigma } _ { i } = \\mathrm { d i a g } \\left( \\sigma _ { i 1 } ^ { 2 } , \\dots , \\sigma _ { i d _ { z } } ^ { 2 } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            571,
+            732,
+            592
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the mean $\\pmb { \\mu } _ { i }$ and covariance $\\Sigma _ { i }$ are outputs of an encoding DNN f (and thus $[ \\pmb { \\mu } _ { i } , \\pmb { \\Sigma } _ { i } ] =$ $\\mathbf { f } ( \\mathbf { x } _ { i } ; \\boldsymbol { \\phi } _ { z } )$ are deterministic nonlinear functions of $\\mathbf { x } _ { i }$ ). In this case, we have ",
+        "bbox": [
+            173,
+            592,
+            823,
+            621
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2ff93599247700d81814feb55dbfaa1cff26165d375136a184443d51de5ac9cd.jpg",
+        "text": "$$\nD _ { K L } \\big ( q _ { \\phi } ( \\mathbf { z } _ { i } | \\mathbf { x } _ { i } ) | | p ( \\mathbf { z } _ { i } ) \\big ) = - \\frac { 1 } { 2 } \\sum _ { j = 1 } ^ { d _ { z } } \\left( 1 + \\log \\sigma _ { i j } ^ { 2 } - \\sigma _ { i j } ^ { 2 } - \\mu _ { i j } ^ { 2 } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            622,
+            704,
+            666
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The second term of (4) corresponds to the expected complete data likelihood under the approximate posterior distribution. Though still intractable, this term can be approximated by Monte Carlo sampling. In particular, we draw $L$ samples ${ \\bf z } _ { i } ^ { ( l ) } \\sim q _ { \\phi } ( { \\bf z } _ { i } | { \\bf x } _ { i } )$ : ",
+        "bbox": [
+            174,
+            674,
+            825,
+            720
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2eabca76ae41dab077d1447a0dfa75a0eb360d6ecd36bc8d4e2dd8be6e1e8224.jpg",
+        "text": "$$\n\\begin{array} { r } { { \\bf z } _ { i } ^ { ( l ) } = \\mu _ { i } + \\Sigma _ { i } \\epsilon ^ { ( l ) } , \\qquad \\mathrm { w h e r e } \\quad \\epsilon ^ { ( l ) } \\sim \\mathcal { N } ( { \\bf 0 } , { \\bf I } ) , \\qquad \\mathrm { f o r } \\quad l = 1 , \\dots , L , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            722,
+            740,
+            742
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and have ",
+        "bbox": [
+            173,
+            742,
+            235,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/16bc95f905304758115b3feb897893ac17b172a79ebdf389969e72015875c406.jpg",
+        "text": "$$\n\\mathbb { E } _ { q _ { \\phi } ( \\mathbf { z } _ { i } | \\mathbf { x } _ { i } ) } \\left[ \\log p _ { \\theta } ( \\mathbf { x } _ { i } | \\mathbf { z } _ { i } ) + \\log p _ { \\theta } ( \\mathbf { y } _ { i } | \\mathbf { z } _ { i } ) \\right] \\approx \\frac { 1 } { L } \\sum _ { l = 1 } ^ { L } \\log p _ { \\theta } \\left( \\mathbf { x } _ { i } | \\mathbf { z } _ { i } ^ { ( l ) } \\right) + \\log p _ { \\theta } \\left( \\mathbf { y } _ { i } | \\mathbf { z } _ { i } ^ { ( l ) } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            199,
+            755,
+            779,
+            799
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Notice that we parameterized $q _ { \\phi } ( \\mathbf { z } _ { i } | \\mathbf { x } _ { i } )$ above to obtain the VCCA objective; this is useful when the first view is available for downstream tasks, in which case we can directly apply $q _ { \\phi } ( \\mathbf { z } _ { i } | \\mathbf { x } _ { i } )$ to obtain its projection (as features). One could also derive likelihood lower bounds by parameterizing the approximate posteriors $q _ { \\phi } ( \\mathbf { z } _ { i } | \\mathbf { y } _ { i } )$ and $q _ { \\phi } ( \\mathbf { z } _ { i } | \\mathbf { x } _ { i } , \\mathbf { y } _ { i } )$ , and optimize their convex combinations for training. We give a sketch of VCCA in Figure 1 (right). ",
+        "bbox": [
+            173,
+            806,
+            826,
+            878
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/94cf35c9dc267919464e46591d6c5cab4fa1e5a4bd9ed7d9e3549dfe1dfdb48c.jpg",
+        "image_caption": [
+            "Figure 2: VCCA-private: variational CCA with view-specific private variables. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            99,
+            764,
+            275
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Connection to multi-view autoencoder (MVAE) If we use the Gaussian observation models ",
+        "bbox": [
+            171,
+            327,
+            799,
+            343
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/87e01c227bc2a514ef56307696e355c2e6bef372f82511ef58d70f9c127fb14e.jpg",
+        "text": "$$\n\\begin{array} { r } { \\log p _ { \\theta } ( \\mathbf { x } | \\mathbf { z } ) = \\log \\mathcal { N } ( \\mathbf { g } _ { x } ( \\mathbf { z } ; \\theta _ { x } ) , \\mathbf { I } ) , \\qquad \\quad \\log p _ { \\theta } ( \\mathbf { y } | \\mathbf { z } ) = \\log \\mathcal { N } ( \\mathbf { g } _ { y } ( \\mathbf { z } ; \\theta _ { y } ) , \\mathbf { I } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            349,
+            758,
+            368
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "we observe that $\\log p _ { \\pmb { \\theta } } \\left( \\mathbf { x } _ { i } | \\mathbf { z } _ { i } ^ { ( l ) } \\right)$ and $\\log p _ { \\pmb { \\theta } } \\left( \\mathbf { y } _ { i } | \\mathbf { z } _ { i } ^ { ( l ) } \\right)$ measure the reconstruction errors of each view’s inputs from samples z(l)i u sing the two DNNs $\\mathbf { g } _ { x }$ and $\\mathbf { g } _ { y }$ respectively. In this case, maximizing $\\mathcal { L } ( \\mathbf { x } , \\mathbf { y } ; \\pmb { \\theta } , \\phi )$ is equivalent to ",
+        "bbox": [
+            173,
+            376,
+            826,
+            433
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0d81ce915452c0938d5e1002a3d2ce1a071356587b6e587638efd4e99cdc3c6f.jpg",
+        "text": "$$\n\\operatorname* { n i n } _ { \\substack { \\boldsymbol { y } , \\boldsymbol { \\phi } } } \\quad \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } D _ { K L } ( q _ { \\boldsymbol { \\phi } } ( \\mathbf { z } _ { i } | \\mathbf { x } _ { i } ) | | \\boldsymbol { p } ( \\mathbf { z } _ { i } ) ) + \\frac { 1 } { 2 N L } \\sum _ { i = 1 } ^ { N } \\sum _ { l = 1 } ^ { L } \\Big \\| \\mathbf { x } _ { i } - \\mathbf { g } _ { x } \\left( \\mathbf { z } _ { i } ^ { ( l ) } ; \\boldsymbol { \\theta } _ { x } \\right) \\Big \\| ^ { 2 } + \\Big \\| \\mathbf { y } _ { i } - \\mathbf { g } _ { y } \\left( \\mathbf { z } _ { i } ^ { ( l ) } ; \\boldsymbol { \\theta } _ { y } \\right) \\Big \\| ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            439,
+            839,
+            483
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bda58196e9f7df9c7fdea009d29a20a2f66d20ce6bcdb00fb7d4a13b896deb2e.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { z } _ { i } ^ { ( l ) } = \\pmb { \\mu } _ { i } + \\pmb { \\Sigma } _ { i } \\pmb { \\epsilon } ^ { ( l ) } , \\quad \\mathrm { w h e r e } \\ \\pmb { \\epsilon } ^ { ( l ) } \\sim \\mathcal { N } ( \\mathbf { 0 } , \\mathbf { I } ) , \\quad l = 1 , \\dots , L . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            217,
+            500,
+            619,
+            520
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Now, consider the case of $\\Sigma _ { i } \\to \\mathbf { 0 }$ , for $i = 1 , \\ldots , N$ , and we have $\\mathbf { z } _ { i } ^ { ( l ) }  \\pmb { \\mu } _ { i }$ which is a deterministic function of $\\mathbf { x }$ (and there is no need for sampling). In the limit, the second term of (9) reduces to ",
+        "bbox": [
+            174,
+            536,
+            828,
+            569
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/32a03624df023ca21ca7849dc2abcf6933f79b394cc99fcc0cea663b3a52dc61.jpg",
+        "text": "$$\n\\frac { 1 } { 2 N } \\sum _ { i = 1 } ^ { N } \\left\\| \\mathbf { x } _ { i } - \\mathbf { g } _ { x } ( \\mathbf { f } ( \\mathbf { x } _ { i } ; \\boldsymbol { \\phi } _ { z } ) ; \\boldsymbol { \\theta } _ { x } ) \\right\\| ^ { 2 } + \\left\\| \\mathbf { y } _ { i } - \\mathbf { g } _ { y } ( \\mathbf { f } ( \\mathbf { x } _ { i } ; \\boldsymbol { \\phi } _ { z } ) ; \\boldsymbol { \\theta } _ { y } ) \\right\\| ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            574,
+            717,
+            618
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "which is the objective of the multi-view autoencoder (MVAE, Ngiam et al., 2011). Note, however, that $\\Sigma _ { i } \\ \\to \\ 0$ is prevented by the VCCA objective as it results in a large penalty in $D _ { K L } ( q _ { \\phi } ( \\mathbf { z } _ { i } | \\mathbf { x } _ { i } ) | | p ( \\mathbf { z } _ { i } ) )$ . Compared with the MVAE objective, in the VCCA objective we are creating $L$ different “noisy” versions of the latent representation and enforce that these versions reconstruct the original inputs well. The “noise” distribution (the variances $\\Sigma _ { i }$ ) are also learned and regularized by the KL divergence $D _ { K L } ( q _ { \\phi } ( { \\bf z } _ { i } | { \\bf x } _ { i } ) | | p ( { \\bf z } _ { i } ) )$ . Using the VCCA objective, we expect to learn different representations from those of MVAE, due to these regularization effects. ",
+        "bbox": [
+            173,
+            625,
+            825,
+            723
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.1 EXTRACTING PRIVATE VARIABLES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            734,
+            450,
+            750
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "So far, VCCA aims at extracting only the latent variables $\\mathbf { z }$ that are common to both views. A potential disadvantage of this model is that it assumes the common variables are sufficient by themselves to generate the views, which can be too restrictive in practice. Consider the example of audio and articulatory measurements as two views for speech. Although the transcription is a common variable behind the views, it combines with the physical environment and the vocal tract anatomy to generate the individual views. In other words, there might be large variations in the input space that can not be explained by the common variables, making the objective (4) hard to optimize. It may then be beneficial to explicitly model the private variables within each view. ",
+        "bbox": [
+            173,
+            761,
+            825,
+            873
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We therefore propose a new probabilistic graphical model, shown in Figure 2, that we refer to as VCCA-private. We introduce two sets of hidden variables $\\mathbf { h } _ { x } \\in \\mathbb { R } ^ { d _ { h _ { x } } }$ and $\\mathbf { h } _ { y } \\in \\mathbb { R } ^ { d _ { h _ { y } } }$ to explain the aspects of $\\mathbf { x }$ and $\\mathbf { y }$ not captured by the common variables $\\mathbf { z }$ . Under this model, the data likelihood ",
+        "bbox": [
+            176,
+            880,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "is defined by ",
+        "bbox": [
+            173,
+            103,
+            259,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b058bb0762c274e978bcf495156551b55fb4c738fac875cbd7870384637d43f2.jpg",
+        "text": "$$\n\\begin{array} { l } { p _ { \\theta } ( \\mathbf { x } , \\mathbf { y } , \\mathbf { z } , \\mathbf { h } _ { x } , \\mathbf { h } _ { y } ) = p ( \\mathbf { z } ) p ( \\mathbf { h } _ { x } ) p ( \\mathbf { h } _ { y } ) p _ { \\theta } ( \\mathbf { x } | \\mathbf { z } , \\mathbf { h } _ { x } ; \\theta _ { x } ) p _ { \\theta } ( \\mathbf { y } | \\mathbf { z } , \\mathbf { h } _ { y } ; \\theta _ { y } ) , } \\\\ { p _ { \\theta } ( \\mathbf { x } , \\mathbf { y } ) = \\displaystyle \\int \\int \\int p _ { \\theta } ( \\mathbf { x } , \\mathbf { y } , \\mathbf { z } , \\mathbf { h } _ { x } , \\mathbf { h } _ { y } ) d \\mathbf { z } d \\mathbf { h } _ { x } d \\mathbf { h } _ { y } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            123,
+            732,
+            179
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To obtain tractable inference, we introduce the following factored variational posterior ",
+        "bbox": [
+            174,
+            183,
+            740,
+            198
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7bba08efb07fbe20455b22d32338fb2f8fa4667203b70d4c1ee6a4c9d4371ffb.jpg",
+        "text": "$$\n\\begin{array} { r } { q _ { \\phi } ( \\mathbf { z } , \\mathbf { h } _ { x } , \\mathbf { h } _ { y } | \\mathbf { x } , \\mathbf { y } ) = q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ; \\phi _ { z } ) q _ { \\phi } ( \\mathbf { h } _ { x } | \\mathbf { x } ; \\phi _ { x } ) q _ { \\phi } ( \\mathbf { h } _ { y } | \\mathbf { y } ; \\phi _ { y } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            204,
+            700,
+            223
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where each factor is parameterized by a different DNN. Similarly to VCCA, we can derive a variational lower bound on the data likelihood for VCCA-private as ",
+        "bbox": [
+            173,
+            228,
+            823,
+            257
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fcba636306ddfd1c51aa24532d341d213bfbbc5d16b5ac275b8aa35d63f68a93.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad \\log p _ { \\theta } ( \\mathbf { x } , \\mathbf { y } ) } \\\\ & { \\geq \\iint \\int d \\varphi ( \\mathbf { z } , \\mathbf { h } _ { x } , \\mathbf { h } _ { y } | \\mathbf { x } , \\mathbf { y } ) \\log \\frac { p _ { \\theta } ( \\mathbf { x } , \\mathbf { y } , \\mathbf { z } , \\mathbf { h } _ { x } , \\mathbf { h } _ { y } ) } { q _ { \\phi } ( \\mathbf { z } , \\mathbf { h } _ { x } , \\mathbf { h } _ { y } | \\mathbf { x } , \\mathbf { y } ) } d \\mathbf { z } d \\mathbf { h } _ { x } d \\mathbf { h } _ { y } } \\\\ & { = \\iint \\int d \\varphi ( \\mathbf { z } , \\mathbf { h } _ { x } , \\mathbf { h } _ { y } | \\mathbf { x } , \\mathbf { y } ) \\left[ \\log \\frac { p ( \\mathbf { z } ) } { q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) } + \\log \\frac { p ( \\mathbf { h } _ { x } ) } { q _ { \\phi } ( \\mathbf { h } _ { x } | \\mathbf { x } ) } + \\log \\frac { p ( \\mathbf { h } _ { y } ) } { q _ { \\phi } ( \\mathbf { h } _ { y } | \\mathbf { y } ) } \\right. } \\\\ & { \\qquad \\left. + \\log p _ { \\theta } ( \\mathbf { z } | \\mathbf { z } , \\mathbf { h } _ { x } ) + \\log p _ { \\theta } ( \\mathbf { z } | \\mathbf { z } , \\mathbf { h } _ { y } ) \\right] d \\mathbf { z } d \\mathbf { h } _ { x } d \\mathbf { h } _ { y } } \\\\ & { = - D _ { K L } ( q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) | | p ( \\mathbf { z } ) ) - D _ { K L } ( q _ { \\phi } ( \\mathbf { h } _ { x } | \\mathbf { x } ) | | p ( \\mathbf { h } _ { x } ) ) - D _ { K L } ( q _ { \\phi } ( \\mathbf { h } _ { y } | \\mathbf { y } ) | | p ( \\mathbf { h } _ { y } ) ) } \\\\ &  \\quad + \\int \\int q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) q _ { \\phi } ( \\mathbf { h } _ { x } | \\mathbf { x } ) \\log p _ { \\theta } ( \\mathbf { x } | \\mathbf { z } , \\mathbf { h } _ { x } ) d \\mathbf { z } d \\mathbf { h } _ { x } + \\iint q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } ) q _ { \\phi } ( \\mathbf { h } _ { y } | \\mathbf { y } ) \\log p _ { \\theta } ( \\mathbf { y } | \\mathbf { z } , \\mathbf { h } _ { y } ) d \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            173,
+            262,
+            816,
+            460
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As in VCCA, the last two terms of (14) can be approximated by Monte Carlo sampling. For example, we draw samples of $\\mathbf { z }$ and $\\mathbf { h } _ { x }$ from their corresponding approximate posteriors, and concatenate their samples as inputs to the DNN parameterizing $p _ { \\pmb { \\theta } } ( \\mathbf { x } | \\mathbf { z } , \\mathbf { h } _ { x } )$ . In this paper, we use simple Gaussian prior distributions for the private variables, i.e., $\\mathbf { h } _ { x } \\sim \\mathcal { N } ( \\mathbf { 0 } , \\mathbf { I } )$ and $\\mathbf { h } _ { y } \\sim \\mathcal { N } ( \\mathbf { 0 } , \\mathbf { I } )$ . We leave to future work to examine the effect of more sophisticated prior distributions for the latent variables. ",
+        "bbox": [
+            173,
+            465,
+            825,
+            536
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "VCCA-private maximizes this lower bound on the training set, i.e., ",
+        "bbox": [
+            173,
+            541,
+            612,
+            558
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2c6fe1818c43e6f66256cc95b94c97b0f1dc2643a52f22779777ff51a932d44c.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\theta , \\phi } \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\mathcal { L } _ { \\mathrm { p r i v a t e } } ( \\mathbf { x } _ { i } , \\mathbf { y } _ { i } ; \\mathbf { \\boldsymbol { \\theta } } , \\phi ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            564,
+            612,
+            607
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Optimization The objectives (5) and (14) decouple over the training samples and can be trained efficiently using stochastic gradient descent. Enabled by the reparameterization trick, unbiased gradient estimates are obtained by Monte Carlo sampling and the standard backpropagation procedure on minibatches of training samples. We apply the ADAM algorithm (Kingma and Ba, 2015) for optimizing our objectives. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            691
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            705,
+            341,
+            722
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Recently, there has been much interest in unsupervised deep generative models (Kingma and Welling, 2014; Rezende et al., 2014; Goodfellow et al., 2014; Gregor et al., 2015; Makhzani et al., 2016; Burda et al., 2016; Alain et al., 2016). A common motivation behind these models is that, with the expressive power of DNNs, the generative models can capture distributions for complex inputs. Additionally, if we are able to generate realistic samples from the learned distribution, we can infer that we have discovered the underlying structure of the data, which may allow us to reduce the sample complexity for learning for downstream tasks. These previous models have mostly focused on single-view data. Here we focus on the multi-view setting where multiple views of the data are present for feature extraction but only one view is available at test time (in downstream tasks). ",
+        "bbox": [
+            174,
+            734,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Some recent work has explored deep generative models for (semi-)supervised learning. Kingma et al. (2014) built a generative model based on variational autoencoders (VAEs) for semi-supervised classification, where the authors model the input distribution with two set of latent variables: the class label (if it is missing) and another set that models the intra-class variabilities (styles). Sohn et al. (2015) proposed a conditional generative model for structured output prediction, where the authors explicitly model the uncertainty in the input/output using Gaussian latent variables. While there are two set of observations (input and output labels) in these work, their graphical models are different from that of VCCA. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our work is also related to the deep multi-view probabilistic models based on restricted Boltzmann machines (Srivastava and Salakhutdinov, 2014; Sohn et al., 2014). We note that these are undirected graphical models for which both inference and learning are difficult, and one typically resorts to carefully designed variational approximation and Gibbs sampling procedures for training such models. In contrast, our models only require sampling from simple, standard distributions (such as Gaussians), and all parameters can be learned end-to-end by standard stochastic gradient methods. Therefore, our models are more scalable than the previous multi-view probabilistic models. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            263
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, there is a rich literature in modeling multi-view data using the same or similar graphical models behind VCCA/VCCA-private (Wang, 2007; Jia et al., 2010; Salzmann et al., 2010; Virtanen et al., 2011; Memisevic et al., 2012; Klami et al., 2013). Our methods differ from previous work in parameterizing the probability distributions using DNNs. This makes the model more powerful, while still having tractable objectives and efficient end-to-end training using the local reparameterization technique. We note that, unlike earlier work on probabilistic models of linear CCA (Bach and Jordan, 2005), VCCA does not optimize the same criterion, nor produce the same solution, as any linear or nonlinear CCA. However, we retain the terminology in order to clarify the connection with earlier work on probabilistic models for CCA, which we are extending with DNN models for the observations and for the variational posterior distribution approximation. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            410
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            426,
+            416,
+            441
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we compare different multi-view representation learning algorithms on three tasks involving several domains: image-image, speech-articulation, and image-text. The algorithms we choose to compare below are closely related to the proposed model or have been shown to have strong empirical performance under similar settings. ",
+        "bbox": [
+            173,
+            455,
+            825,
+            512
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• Linear CCA: its probabilistic interpretation motivates this work.   \n• Deep CCA (DCCA) (Andrew et al., 2013): see its objective in (1).   \n• Deep canonically correlated autoencoders (DCCAE) (Wang et al., 2015b): combination of the DCCA objective and the reconstruction errors of each view.   \n• Multi-view autoencoder (MVAE) (Ngiam et al., 2011): see its objective in (10).   \n• Multi-view contrastive loss (Hermann and Blunsom, 2014): based on the intuition that the distance between embeddings of paired examples $\\mathbf { x } ^ { + }$ and $\\mathbf { y } ^ { + }$ should be smaller than the distance between embeddings of $\\mathbf { x } ^ { + }$ and an unmatched negative example $\\mathbf { y } ^ { - }$ by a margin: $\\operatorname* { m i n } _ { f , g } \\ \\mathcal { L } _ { c o n t r a s t } : = \\frac { 1 } { N } \\sum _ { i } ^ { N } \\operatorname* { m a x } \\left( 0 , \\ m + d i s \\left( f ( \\mathbf { x } _ { i } ^ { + } ) , g ( \\mathbf { y } _ { i } ^ { + } ) \\right) - d i s \\left( f ( \\mathbf { x } _ { i } ^ { + } ) , g ( \\mathbf { y } _ { i } ^ { - } ) \\right) \\right) ,$ where $\\mathbf { y } _ { i } ^ { - }$ is a randomly sampled view 2 example, and $m$ is a margin hyperparameter. We use the ",
+        "bbox": [
+            165,
+            518,
+            828,
+            756
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "cosine distance $\\begin{array} { r } { d i s \\left( \\mathbf { a } , \\mathbf { b } \\right) = 1 - \\left. \\frac { \\mathbf { a } } { \\| \\mathbf { a } \\| } , \\ \\frac { \\mathbf { b } } { \\| \\mathbf { b } \\| } \\right. } \\end{array}$ . ",
+        "bbox": [
+            183,
+            732,
+            825,
+            772
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 NOISY MNIST DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            785,
+            387,
+            799
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We first demonstrate our algorithms on the noisy MNIST dataset used by Wang et al. (2015b). The dataset is generated using the MNIST dataset (LeCun et al., 1998), which consists of $2 8 \\times 2 8$ grayscale digit images, with $6 0 K / 1 0 K$ images for training/testing. We first linearly rescale the pixel values to the range $[ 0 , 1 ]$ . Then, we randomly rotate the images at angles uniformly sampled from $[ - \\pi / 4 , \\pi / 4 ]$ and the resulting images are used as view 1 inputs. For each view 1 image, we randomly select an image of the same identity (0-9) from the original dataset, add independent random noise uniformly sampled from [0, 1] to each pixel, and truncate the pixel final values to [0, 1] to obtain the corresponding view 2 sample. Selection of input images are given in Figure 3 (left). The original training set is further split into training/tuning sets of size $5 0 K / 1 0 K$ . The data generation process ensures that the digit identity is the only common variable underlying both views. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/4d3e1b453862a4241c4236728c099bbc3bff1644a1b351db312c4630ff24fbe7.jpg",
+        "image_caption": [
+            "Figure 3: Left: Selection of view 1 images (top) and their corresponding view 2 images (bottom) from noisy MNIST. Right: 2D t-SNE visualization of features learned by previous multi-view models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            98,
+            813,
+            367
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            434,
+            820,
+            462
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the amount of class information extracted by different methods, after unsupervised learning of latent representations, we reveal the labels and train a linear SVM on the projected view 1 training data (using the one-versus-all scheme), and use it to classify the projected test set. This experiment simulates the typical usage of multi-view learning methods, which is to extract useful representations for downstream discriminative tasks. ",
+        "bbox": [
+            174,
+            469,
+            823,
+            537
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Note that this synthetic dataset perfectly satisfies the multi-view assumption that the two views are independent given the class label, so the latent representation should contain precisely the class information. This is indeed achieved by CCA-based and contrastive loss-based multi-view approaches. In Figure 3 (right), we show 2D t-SNE (van der Maaten and Hinton, 2008) visualizations of the original view 1 inputs and view 1 projections by various deep multi-view methods. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            616
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use DNNs with 3 hidden layers of 1024 rectified linear units (ReLUs, Nair and Hinton, 2010) each to parameterize the distributions: $q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } )$ , $p _ { \\pmb { \\theta } } ( \\mathbf { x } | \\mathbf { z } )$ , $p _ { \\pmb { \\theta } } ( \\mathbf { y } | \\mathbf { z } )$ in VCCA, and additionally $q _ { \\phi } ( \\mathbf { h } _ { x } | \\mathbf { x } )$ and $q _ { \\phi } ( \\mathbf { h } _ { y } | \\mathbf { y } )$ in VCCA-private. The capacities of these networks are the same as those of their counterparts in DCCA and DCCAE from Wang et al. (2015b). The reconstruction networks $p _ { \\pmb { \\theta } } ( \\mathbf { x } | \\mathbf { z } )$ or $p _ { \\pmb { \\theta } } ( \\mathbf { x } | \\mathbf { z } , \\mathbf { h } _ { x } )$ model each pixel of $\\mathbf { x }$ as an independent Bernoulli variable and parameterize its mean (using a sigmoid activation); $p _ { \\pmb { \\theta } } ( \\mathbf { y } | \\mathbf { z } )$ and $p _ { \\pmb { \\theta } } ( \\mathbf { y } | \\mathbf { z } , \\mathbf { h } _ { y } )$ model $\\mathbf { y }$ with diagonal Gaussians and parameterize the mean (using a sigmoid activation) and standard deviation for each pixel dimension. We tune the dimensionality $d _ { z }$ over $\\{ 1 0 , 2 0 , 3 0 , 4 0 , 5 0 \\}$ , and fix $d _ { h _ { x } } = d _ { h _ { y } } = 3 0$ for VCCA-private. We select the hyperparameter combination that yields the best SVM classification accuracy on the projected tuning set, and report the corresponding accuracy on the projected test set. ",
+        "bbox": [
+            174,
+            622,
+            825,
+            762
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The effect of dropout We add dropout (Srivastava et al., 2014) to all intermediate layers and the input layers and find it to be very useful in our models, with most of the gain coming from dropout applied to the samples of $\\mathbf { z }$ , $\\mathbf { h } _ { x }$ and $\\mathbf { h } _ { y }$ . This is because dropout encourages each latent dimension to reconstruct the inputs well in the absence of other dimensions, and therefore avoids learning coadapted features. Intuitively, in VCCA-private dropout also helps to prevent the degenerate situation where the pathways $\\mathbf { x } \\to \\mathbf { h } _ { x } \\to \\mathbf { x }$ and $\\mathbf { y }  \\mathbf { h } _ { y }  \\mathbf { y }$ achieve good reconstruction while ignoring $\\mathbf { z }$ (e.g., by setting it to a constant). We use the same dropout rate for all layers and tune it over $\\{ 0 , 0 . 1 , 0 . 2 , 0 . 3 , 0 . 4 \\}$ . ",
+        "bbox": [
+            174,
+            776,
+            825,
+            890
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We show the 2D t-SNE embeddings of the common variables $\\mathbf { z }$ learned by VCCA and VCCA-private on test set in Figure 4. We observe that in general, VCCA/VCCA-private tend to separate the classes in the projection well; dropout significantly improves the performance of both VCCA and VCCAprivate, with the latter slightly outperforming the former. While such class separation can also be achieved by DCCA/contrastive loss as well, these methods can not naturally generate samples in the input space. On the other hand, such separation is not achieved by multi-view autoencoders. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/6029ce042a12b82b310d492e7252093b471226c5e8f698c2c263cf4972437533.jpg",
+        "image_caption": [
+            "Figure 4: 2D t-SNE embeddings of the extracted shared variables $\\mathbf { z }$ on the test set by VCCA (top row) and VCCA-private (bottom row) for different dropout rates. $d _ { z } = 4 0$ for both algorithms. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            97,
+            803,
+            303
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/54bac0f2be82393a5938196bd107102f4254ce2324e28451011619fd5cb4d27c.jpg",
+        "image_caption": [
+            "Figure 5: Sample reconstruction of view 2 images from the test set by VCCA and VCCA-private. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            356,
+            831,
+            614
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            661,
+            825,
+            717
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The effect of private variables on reconstructions We show sample reconstructions (mean and standard deviation) by VCCA for the view 2 images from the test set in Figure 5 (columns 2 and 3). We observe that for each input, the mean reconstruction of $\\mathbf { y } _ { i }$ by VCCA is a prototypical image of the same digit, regardless of the individual style in $\\mathbf { y } _ { i }$ . This is to be expected, as $\\mathbf { y } _ { i }$ contains an arbitrary image of the same digit as $\\mathbf { x } _ { i }$ , and the variation in background noise in $\\mathbf { y } _ { i }$ does not appear in $\\mathbf { x } _ { i }$ and can not be reflected in $q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } )$ ; thus the best way for $\\mathbf { p } _ { \\pmb { \\theta } } ( \\mathbf { y } | \\mathbf { z } )$ to model $\\mathbf { y } _ { i }$ is to output a prototypical image of that class to achieve on average small reconstruction error. On the other hand, since $\\mathbf { y } _ { i }$ contains little rotation of the digits, this variation is suppressed to a large extent in $q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } )$ (it is no longer the major variation in $\\mathbf { z }$ as in the original inputs). ",
+        "bbox": [
+            174,
+            736,
+            825,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We show sample reconstructions by VCCA-private for the same set of view 2 images in Figure 5 (columns 4 and 5). With the help of private variables $\\mathbf { h } _ { y }$ (as part of the input to $p _ { \\pmb { \\theta } } ( \\mathbf { y } | \\mathbf { z } , \\mathbf { h } _ { y } ) )$ , the model does a much better job in reconstructing the styles of y. And by disentangling the private variables from the shared variables, $q _ { \\phi } ( \\mathbf { z } | \\mathbf { x } )$ achieves even better class separation than VCCA does. ",
+        "bbox": [
+            174,
+            868,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/bad887a866764dccf57278c7ac2402cef9453295d3f899c3f676cb17d95c56e3.jpg",
+        "table_caption": [
+            "Table 1: Performance of features extracted by different methods for downstream tasks: Classification error rates of linear SVMs on MNIST, mean phone error rate (PER) over 6 folds on XRMB, and mean average precision (mAP) for unimodal retrieval on MIR-Flickr. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Noisy MNIST Error rate (%,↓)</td><td>XRMB PER(%,↓)</td><td>Flickr mAP (↑)</td></tr><tr><td>Original inputs</td><td>13.1</td><td>37.6</td><td>0.480</td></tr><tr><td>CCA</td><td>19.1</td><td>29.4</td><td>0.529</td></tr><tr><td>DCCA</td><td>2.9</td><td>25.4</td><td>0.573</td></tr><tr><td>DCCAE</td><td>2.2</td><td>25.4</td><td>0.573</td></tr><tr><td>Contrastive</td><td>2.7</td><td>24.6</td><td>0.565</td></tr><tr><td>MVAE</td><td>11.7</td><td>29.4</td><td>0.477</td></tr><tr><td>VCCA</td><td>3.0</td><td>28.0</td><td>0.605</td></tr><tr><td>VCCA-private</td><td>2.4</td><td>25.2</td><td>0.609</td></tr></table>",
+        "bbox": [
+            287,
+            150,
+            705,
+            296
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We also note that the standard deviation of the reconstruction is low within the digit and high outside the digit, implying that $p _ { \\pmb { \\theta } } ( \\mathbf { y } | \\mathbf { z } , \\mathbf { h } _ { y } )$ is able to separate the background noise from the digit image. ",
+        "bbox": [
+            174,
+            316,
+            823,
+            344
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Disentanglement of private/shared variables In Figure 6 (in Appendix) we provide the 2D $t$ - SNE embeddings of the shared variables $\\mathbf { z }$ (top row) and the private variables $\\mathbf { h } _ { x }$ (bottom row) learned by VCCA-private. In the embedding of $\\mathbf { h } _ { x }$ , digits with different identities but the same rotation are mapped close together, and the rotation varies smoothly from left to right, confirming that the private variables contain little class information but mainly style information. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            428
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, we give the test error rates of linear SVMs applied to the features learned with different models in Table 1. VCCA-private is comparable in performance to the best previous approach (DCCAE), while having the advantage that it can also generate. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            477
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2 XRMB SPEECH-ARTICULATION DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            491,
+            500,
+            503
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We now consider the task of learning acoustic features for speech recognition. We use data from the Wisconsin $\\mathrm { X }$ -ray microbeam (XRMB) corpus (Westbury, 1994), which contains simultaneously recorded speech and articulatory measurements from 47 American English speakers. We follow the setup of Wang et al. (2015a,b) and use the learned features for speaker-independent phonetic recognition.2 The two input views are standard 39D acoustic features $\\lvert 1 3 \\ \\mathrm { m e l }$ frequency cepstral coefficients (MFCCs) and their first and second derivatives) and 16D articulatory features (horizontal/vertical displacement of 8 pellets attached to several parts of the vocal tract), each then concatenated over a 7-frame window around each frame to incorporate context. The speakers are split into disjoint sets of 35/8/2/2 speakers for feature learning/recognizer training/tuning/testing. The 35 speakers for feature learning are fixed; the remaining 12 are used in a 6-fold experiment (recognizer training on 8 speakers, tuning on 2 speakers, and testing on the remaining 2 speakers). Each speaker has roughly $5 0 K$ frames. We remove the per-speaker mean and variance of the articulatory measurements for each training speaker, and remove the mean of the acoustic measurements for each utterance. All learned feature types are used in a “tandem” speech recognizer (Hermansky et al., 2000), i.e., they are appended to the original 39D features and used in a standard hidden Markov model (HMM)-based recognizer with Gaussian mixture observation distributions. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            739
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Each algorithm uses up to 3 ReLU hidden layers, each of 1500 units, for the projection and reconstruction mappings. For VCCA/VCCA-private, we use Gaussian observation models as the inputs are real-valued. In contrast to the MNIST experiments, we do not learn the standard deviations of each output dimension on training data, as this leads to poor downstream task performance. Instead, we use isotropic covariances for each view, and tune the standard deviations by grid search. The best model uses a smaller standard deviation (0.1) for the view 2 than for view 1 (1.0), effectively putting more emphasis on the reconstruction of articulatory measurements. Our best performing VCCA model uses $d _ { z } = 7 0$ , while the best performing VCCA-private model uses $d _ { z } = 7 0$ and $d _ { h _ { x } } = d _ { h _ { y } } = 1 0$ . ",
+        "bbox": [
+            173,
+            746,
+            825,
+            871
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The mean phone error rates (PER) over 6 folds obtained by different algorithms are given in Table 1.   \nOur methods achieve competitive performance in comparison to previous deep multi-view methods. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.3 MIR-FLICKR DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            150,
+            375,
+            164
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Finally, we consider the task of learning cross-modality features for topic classification on the MIRFlickr database (Huiskes and Lew, 2008). The Flickr database contains 1 million images accompanied by user tags, among which 25000 images are labeled with 38 topic classes (each image may be categorized as multiple topics). We use the same image and text features as in previous work (Srivastava and Salakhutdinov, 2014; Sohn et al., 2014): the image feature is 3857 dimensional real-valued vector, composed of Pyramid Histogram of Words (PHOW) (Bosch et al., 2007), GIST (Oliva and Torralba, 2001), and MPEG-7 descriptors (Manjunath et al., 2001), while the text feature is a 2000-dimensional binary vector of frequent tags. ",
+        "bbox": [
+            174,
+            178,
+            825,
+            290
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Following the same protocol as Sohn et al. (2014), we train multi-view representations using the unlabelled data,3 and use projected image features of the labeled data (further divided into splits of 10000/5000/10000 samples for training/tuning/testing) for training and evaluating a classifier that predicts the topic labels, corresponding to the unimodal query task in Srivastava and Salakhutdinov (2014); Sohn et al. (2014). For each algorithm, we select the model which achieves the highest mean average precision (mAP) on the validation set, and report its performance on the test set. ",
+        "bbox": [
+            174,
+            296,
+            825,
+            381
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Each algorithm uses up to 4 ReLU hidden layers, each of 1024 units, for the projection and reconstruction mappings. For VCCA/VCCA-private, we use Gaussian observation models with isotropic covariance for image features, with standard deviation tuned by grid search, and a Bernoulli model for text features. In this experiment, we also found it helpful to tune an additional trade-off parameter for the text-view likelihood (cross-entropy); the best VCCA/VCCA-private models prefer a large trade-off parameter of the level $1 0 ^ { 4 }$ , emphasizing the reconstruction of the sparse text-view inputs. Our best performing VCCA model uses $d _ { z } = 1 0 2 4$ , while the best performing VCCA-private model uses $d _ { z } = 1 0 2 4$ and $d _ { h _ { x } } = d _ { h _ { y } } = 1 6$ . ",
+        "bbox": [
+            174,
+            387,
+            825,
+            501
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 1, VCCA/VCCA-private achieve significantly higher mAPs than other methods considered here. Being much easier to train, the performance of our methods are competitive with the previous state-of-the-art mAP result of 0.607 achieved by the multi-view RBMs of Sohn et al. (2014) under the same setting. ",
+        "bbox": [
+            176,
+            506,
+            825,
+            561
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            582,
+            328,
+            598
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have proposed variational canonical correlation analysis (VCCA), a deep generative method for multi-view representation learning. Our method embodies a natural idea for multi-view learning: the multiple views can be generated from a small set of shared latent variables. VCCA is parameterized by DNNs and can be trained efficiently by backpropagation, and is therefore scalable. We have also shown that, by modeling the private variables that are specific to each view, the VCCA-private variant can disentangle shared/private variables and provide higher-quality reconstructions. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            696
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In the future, we will explore other prior distributions such as mixtures of Gaussians or discrete random variables, which may enforce clustering in the latent space and in turn work better for discriminative tasks. We will also explore other observation models, including replacing the autoencoder objective with that of adversarial networks (Goodfellow et al., 2014; Makhzani et al., 2016; Chen et al., 2016). Another direction is to explicitly incorporate the structure of the inputs, such as the sequence structure of speech and text and the spatial structure of images. ",
+        "bbox": [
+            174,
+            704,
+            825,
+            787
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            809,
+            354,
+            823
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This research was supported by NSF grant IIS-1321015. The opinions expressed in this work are those of the authors and do not necessarily reflect the views of the funding agency. This research used GPUs donated by NVIDIA Corporation. ",
+        "bbox": [
+            176,
+            839,
+            823,
+            881
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            285,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nS. Akaho. A kernel method for canonical correlation analysis. In Proceedings of the International Meeting of the Psychometric Society (IMPS2001), 2001.   \nG. Alain, Y. Bengio, L. Yao, J. Yosinski, E. Thibodeau-Laufer, S. Zhang, and P. Vincent. GSNs: Generative stochastic networks. Information and Inference, 5(2):210–249, 2016.   \nG. Andrew, R. Arora, J. Bilmes, and K. Livescu. Deep canonical correlation analysis. In Int. Conf. Machine Learning, pages 1247–1255, 2013.   \nF. R. Bach and M. I. Jordan. Kernel independent component analysis. Journal of Machine Learning Research, 3:1–48, 2002.   \nF. R. Bach and M. I. Jordan. A probabilistic interpretation of canonical correlation analysis. Technical Report 688, Dept. of Statistics, University of California, Berkeley, 2005.   \nA. Bosch, A. Zisserman, and X. Munoz. Image classification using random forests and ferns. In 2007 IEEE 11th International Conference on Computer Vision, pages 1–8. IEEE, 2007.   \nY. Burda, R. Grosse, and R. Salakhutdinov. Importance weighted autoencoders. 2016.   \nX. Chen, Y. Duan, R. Houthooft, J. Schulman, I. Sutskever, and P. Abbeel. InfoGAN: Interpretable representation learning by information maximizing generative adversarial nets. arXiv:1606.03657 [cs.LG], 2016.   \nI. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial nets. pages 2672–2680, 2014.   \nK. Gregor, I. Danihelka, A. Graves, D. J. Rezende, and D. Wierstra. DRAW: A recurrent neural network for image generation. In Int. Conf. Machine Learning, pages 1462–1471, 2015.   \nK. M. Hermann and P. Blunsom. Multilingual distributed representations without word alignment. In Int. Conf. Learning Representations, 2014. arXiv:1312.6173 [cs.CL].   \nH. Hermansky, D. P. W. Ellis, and S. Sharma. Tandem connectionist feature extraction for conventional HMM systems. In IEEE Int. Conf. Acoustics, Speech and Sig. Proc., pages 1635–1638, 2000.   \nH. Hotelling. Relations between two sets of variates. Biometrika, 28(3/4):321–377, 1936.   \nM. J. Huiskes and M. S. Lew. The mir flickr retrieval evaluation. In Proceedings of the 1st ACM International Conference on Multimedia Information Retrieval, pages 39–43, 2008. doi: 10.1145/ 1460096.1460104. URL http://doi.acm.org/10.1145/1460096.1460104.   \nY. Jia, M. Salzmann, and T. Darrell. Factorized latent spaces with structured sparsity. pages 982– 990, 2010.   \nD. Kingma and J. Ba. ADAM: A method for stochastic optimization. In Int. Conf. Learning Representations, 2015.   \nD. P. Kingma and M. Welling. Auto-encoding variational Bayes. arXiv:1312.6114 [stat.ML], 2014.   \nD. P. Kingma, S. Mohamed, D. J. Rezende, and M. Welling. Semi-supervised learning with deep generative models. pages 3581–3589, 2014.   \nA. Klami, S. Virtanen, and S. Kaski. Bayesian canonical correlation analysis. Journal of Machine Learning Research, pages 965–1003, 2013.   \nP. L. Lai and C. Fyfe. Kernel and nonlinear canonical correlation analysis. Int. J. Neural Syst., 10 (5):365–377, 2000.   \nY. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proc. IEEE, 86(11):2278–2324, 1998.   \nA. Lu, W. Wang, M. Bansal, K. Gimpel, and K. Livescu. Deep multilingual correlation for improved word embeddings. In The 2015 Conference of the North American Chapter of the Association for Computational Linguistics - Human Language Technologies (NAACL-HLT 2015), 2015.   \nA. Makhzani, J. Shlens, N. Jaitly, and I. Goodfellow. Adversarial autoencoders. In Int. Conf. Learning Representations, 2016.   \nB. S. Manjunath, J.-R. Ohm, V. V. Vasudevan, and A. Yamada. Color and texture descriptors. IEEE Transactions on circuits and systems for video technology, 11(6):703–715, 2001.   \nT. Melzer, M. Reiter, and H. Bischof. Nonlinear feature extraction using generalized canonical correlation analysis. In Int. Conf. Artificial Neural Networks, pages 353–360, 2001.   \nR. Memisevic, L. Sigal, and D. J. Fleet. Shared kernel information embedding for discriminative inference. IEEE Trans. Pattern Analysis and Machine Intelligence, 34(4):778–790, 2012.   \nV. Nair and G. E. Hinton. Rectified linear units improve restricted Boltzmann machines. In Int. Conf. Machine Learning, pages 807–814, 2010.   \nJ. Ngiam, A. Khosla, M. Kim, J. Nam, H. Lee, and A. Ng. Multimodal deep learning. In Int. Conf. Machine Learning, pages 689–696, 2011.   \nA. Oliva and A. Torralba. Modeling the shape of the scene: A holistic representation of the spatial envelope. International journal of computer vision, 42(3):145–175, 2001.   \nD. Povey, A. Ghoshal, G. Boulianne, L. Burget, O. Glembek, N. Goel, M. Hannemann, P. Motlicek, Y. Qian, P. Schwarz, J. Silovsky, G. Stemmer, and K. Vesely. The Kaldi speech recognition toolkit. In IEEE Workshop on Automatic Speech Recognition and Understanding, 2011.   \nD. J. Rezende, S. Mohamed, and D. Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Int. Conf. Machine Learning, pages 1278–1286, 2014.   \nM. Salzmann, C. H. Ek, R. Urtasun, and T. Darrell. Factorized orthogonal latent spaces. In Int. Workshop on Artificial Intelligence and Statistics, pages 701–708, 2010.   \nK. Sohn, W. Shang, and H. Lee. Improved multimodal deep learning with variation of information. pages 2141–2149, 2014.   \nK. Sohn, H. Lee, and X. Yan. Learning structured output representation using deep conditional generative models. pages 3465–3473, 2015.   \nN. Srivastava and R. Salakhutdinov. Multimodal learning with deep boltzmann machines. Journal of Machine Learning Research, 15:2949–2980, 2014.   \nN. Srivastava, G. E. Hinton, A. Krizhevsky, I. Sutskever, and R. R. Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15:1929–1958, 2014.   \nL. J. P. van der Maaten and G. E. Hinton. Visualizing data using $t$ -SNE. Journal of Machine Learning Research, 9:2579–2605, 2008.   \nS. Virtanen, A. Klami, and S. Kaski. Bayesian CCA via group sparsity. In Int. Conf. Machine Learning, pages 457–464, 2011.   \nC. Wang. Variational Bayesian approach to canonical correlation analysis. IEEE Trans. Neural Networks, 18(3):905–910, 2007.   \nW. Wang and K. Livescu. Large-scale approximate kernel canonical correlation analysis. In Int. Conf. Learning Representations, 2016. arXiv:1511.04773 [cs.LG].   \nW. Wang, R. Arora, K. Livescu, and J. Bilmes. Unsupervised learning of acoustic features via deep canonical correlation analysis. In IEEE Int. Conf. Acoustics, Speech and Sig. Proc., 2015a.   \nW. Wang, R. Arora, K. Livescu, and J. Bilmes. On deep multi-view representation learning. In Int. Conf. Machine Learning, pages 1083–1092, 2015b. ",
+        "bbox": [
+            168,
+            108,
+            828,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            95,
+            828,
+            928
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "J. R. Westbury. X-Ray Microbeam Speech Production Database User’s Handbook Version 1.0, 1994. F. Yan and K. Mikolajczyk. Deep correlation for matching images and text. In IEEE Computer Society Conf. Computer Vision and Pattern Recognition, pages 3441–3450, 2015. S. J. Young, D. Kernshaw, J. Odell, D. Ollason, V. Valtchev, and P. Woodland. The HTK book version 2.2. Technical report, Entropic, Ltd., 1999. ",
+        "bbox": [
+            169,
+            101,
+            826,
+            194
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A ADDITIONAL T-SNE VISUALIZATION OF NOISY MNIST ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            213,
+            671,
+            231
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/75fc2d64d13d742f31a2eb39292512368c0b88e3d21db40621c9404dee6e5307.jpg",
+        "image_caption": [
+            "Figure 6: 2D $t$ -SNE embedding of the shared variables $\\mathbf { z } \\in \\mathbb { R } ^ { 4 0 }$ (top) and private variables $\\mathbf { h } _ { x } \\in \\mathbb { R } ^ { 3 0 }$ (bottom). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            256,
+            241,
+            745,
+            856
+        ],
+        "page_idx": 12
+    }
+]

parse/train/H1eH4n09KX/H1eH4n09KX.md

@@ -0,0 +1,268 @@
+# ADVERSARIAL AUDIO SUPER-RESOLUTION WITH UNSUPERVISED FEATURE LOSSES
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Neural network-based methods have recently demonstrated state-of-the-art results on image synthesis and super-resolution tasks, in particular by using variants of generative adversarial networks (GANs) with supervised feature losses. Nevertheless, previous feature loss formulations rely on the availability of large auxiliary classifier networks, and labeled datasets that enable such classifiers to be trained. Furthermore, there has been comparatively little work to explore the applicability of GAN-based methods to domains other than images and video. In this work we explore a GAN-based method for audio processing, and develop a convolutional neural network architecture to perform audio super-resolution. In addition to several new architectural building blocks for audio processing, a key component of our approach is the use of an autoencoder-based loss that enables training in the GAN framework, with feature losses derived from unlabeled data. We explore the impact of our architectural choices, and demonstrate significant improvements over previous works in terms of both objective and perceptual quality.
+
+# 1 INTRODUCTION
+
+Deep convolutional neural networks (CNNs) have become a cornerstone in modern solutions for image and audio analysis. Such networks have excelled at supervised discrimination tasks, for instance on ImageNet (Deng et al., 2009; Simonyan & Zisserman, 2014), where image classifier networks are trained on a large corpus of labeled data. More recently, CNNs have successfully been applied to data synthesis problems in the context of generative adversarial networks (GANs) (Goodfellow et al., 2014). In the GAN framework, a neural network is used to synthesize new instances from a modeled distribution, or resolve missing details given lossy observations. In the latter case, the GANs have been shown to greatly improve reconstruction of fine texture details for images, compared to standalone sample-space losses that result in overly smoothed outputs (Dosovitskiy & Brox, 2016; Isola et al., 2017; Ledig et al., 2017). However, GANs are notoriously hard to train, and the use of conventional sample-space objectives in conjunction with an adversarial loss either de-stabilizes training, or results in outputs with significant artifacts (Figure 1).
+
+To address the smoothness problem described above, previous works typically augment or replace conventional sample-space losses with a feature loss (also called a perceptual loss) (Dosovitskiy & Brox, 2016; Ledig et al., 2017; Johnson et al., 2016). Instead of distance in raw sample-space, such feature losses reflect distance in terms of the feature maps of an auxiliary neural network. While classifier-based feature losses are effective, they require either a pre-trained neural network that is applicable to the problem domain (e.g., synthesizing images of cats), or a labeled dataset that is amenable to training a relevant classifier. Training new classifiers for use in a feature loss can be non-trivial for numerous reasons. Besides the difficulty of training large classifiers that are commonly used for feature losses, such as VGG (Simonyan & Zisserman, 2014), creating a labeled dataset that is sufficiently large and diverse is often infeasible.
+
+In this work, we sidestep the difficulty of training auxiliary classifiers by developing a feature loss that is unsupervised. In particular, we focus on an audio modeling task called super-resolution, where the goal is to generate high-quality audio given down-sampled, low-resolution input. Inspired by previous work on audio and image super-resolution, we develop a neural network architecture for end-to-end super-resolution that operates on raw audio. In addition to providing new algorithms to model audio, our work suggests new techniques to improve GAN-based methods in other domains such as images and video. Specifically, our contributions are as follows:
+
+![](images/1fb78758bb93c0993cb3e0b11918e1a6d3b405bd9508da262a985658f7e7a085.jpg)  
+Figure 1: (a) High-resolution, (b) low-resolution, (c) and super-resolution spectrograms. The superresolution spectrogram corresponds to audio generated by the GAN described in Section 3, trained only with an adversarial loss and conventional $L 2$ loss. Training tends to either diverge, or results in audio with persistent high-frequency tones and alias-like artifacts.
+
+1. We formulate a new, general-purpose feature loss that is fully unsupervised and circumvents the need for problematic classifier-based models.   
+2. We successfully adapt the adversarial framework for audio processing, and provide solutions to previously unsolved problems associated with the application of GANs to audio.   
+3. We demonstrate our methods in an end-to-end architecture for audio super-resolution, with stateof-the-art results on both speech and music tasks.   
+4. We analyze important architectural parameters of our model, and in particular discover previously-unobserved behavior with effective receptive field sizes.
+
+# 2 BACKGROUND & RELATED WORK
+
+Audio super-resolution Audio super-resolution is the task of constructing a high-resolution audio signal from a low-resolution signal that contains a fraction of the original samples. Concretely, given a low-resolution sequence of audio samples $x _ { l } \ = \ ( x _ { 1 / R _ { l } } , \ldots , x _ { R _ { l } T / R _ { l } } )$ , we wish to synthesize a high-resolution audio signal $x _ { h } = ( x _ { 1 / R _ { h } } , \ldots , x _ { R _ { h } T / R _ { h } } )$ , where $R _ { l }$ and $R _ { h }$ are the sampling rates of the low and high-resolution signals, respectively. We denote $R = { { R } _ { h } } / { { R } _ { l } }$ as the upsampling ratio, which ranges from 2 to 6 in this work. Thus, the audio super-resolution problem is equivalent to reconstructing the missing frequency content between frequencies $R _ { l } / 2$ and $R _ { h } / 2$ .
+
+There is a vast body of prior work on audio super-resolution in the signal and audio processing communities under the term artificial bandwidth extension (Larsen & Aarts, 2004). Neural networkbased methods in this domain generally apply a DNN on top of hand-crafted features as part of complex bandwidth extension systems (Liu et al., 2015; Abel & Fingscheidt, 2018). Gaussian mixture and hidden Markov models have also been used (Bachhav et al., 2017; Tokuda et al., 2013), but these methods generally perform worse compared to neural networks (Abel & Fingscheidt, 2018). In contrast with the works above, our method does not rely on hand-crafted features (e.g., transformations or cepstrum coefficients), and is not specific to problems in speech modeling.
+
+Audio modeling with neural networks Learning-based approaches for audio have also been explored in the largely in the context of representation learning, generative modeling, and text-tospeech (TTS) systems. Unsupervised methods such as convolutional deep belief networks (Lee et al., 2009) and bottleneck CNNs (Aytar et al., 2016) have been shown to learn useful representations from audio, such as phonemes and sound textures. Stacked autoencoders (Vincent et al., 2010) and variational autoencoders (Kingma & Welling, 2014; Sonderby et al., 2016) have been used for denoising, image generation, and music synthesis (Sarroff & Casey, 2014). Bottleneck-like CNNs have also demonstrated significant improvements for audio super-resolution in supervised settings compared to previous DNN and spline-based methods (Kuleshov et al., 2017). Donahue et al. (2018) is among the first to develop methods for raw audio synthesis with GANs. Notably, Donahue et al.
+
+(2018) show that non-trivial modifications of GAN architectures are required to generative diverse and plausible audio outputs. We build on the works above by developing a GAN framework for audio super-resolution with an improved bottleneck-style generator, and show that leveraging representations learned from unsupervised training greatly aid the super-resolution task. Autoregressive probabilistic models have recently demonstrated state-of-the-art results for generation of music (Engel et al., 2017), general audio (van den Oord et al., 2016; Mehri et al., 2017), and for parametric TTS systems (Sotelo et al., 2017). Several works have leveraged model distillation (van den Oord et al., 2018; ClariNet, 2019)1 to mitigate the overhead of autoregressive methods, making them feasible for real-time audio generation. In general, our work can be used to augment existing speech synthesis systems, including those that employ autoregressive methods. For instance, the unsupervised feature loss proposed in our work could be used as a drop-in replacement for the classifier-based feature loss used by van den Oord et al. (2018). While we are not aware of any efforts that explore autoregressive modeling for audio super-resolution, we believe it may be a promising future direction.
+
+Generative adversarial networks for images Generative methods have been extensively explored for image generation and super-resolution. Building upon the original formulation of Goodfellow et al. (2014), GANs have been continuously improved to generate plausible, high-fidelity images (Radford et al., 2015; Denton et al., 2015; Berthelot et al., 2017; Karras et al., 2018). GAN variants conditioned on class labels or object sketches have also demonstrated promising results on tasks such as in-painting and style transfer (Mirza & Osindero, 2014; Isola et al., 2017).
+
+# 3 METHOD
+
+GANs for Super-Resolution GANs developed for super-resolution tasks have several important differences compared to the original formulation of Goodfellow et al. (2014). When used to generate new instances from a data distribution $p _ { \mathrm { d a t a } }$ , the generator $( G )$ parameterized by $\theta _ { G }$ learns the mapping to data space as $G ( z ; \theta _ { G } )$ , where $_ { z }$ is a latent noise prior. The discriminator $( D )$ parameterized by $\theta _ { D }$ then estimates the probability that $G ( z ; \theta _ { G } )$ was drawn from $p _ { \mathrm { d a t a } }$ rather than the generator distribution $p _ { g }$ . In contrast, for super-resolution, $G$ is no longer conditioned on noise and learns the mapping to high-resolution data space $p _ { h }$ as $G ( \pmb { x } \imath ; \theta _ { G } )$ , where $_ { x \iota }$ is drawn from the low-resolution data distribution $p _ { l }$ . The task of $D$ is to discriminate between samples from the high-resolution and super-resolution (generator) distributions $p _ { h }$ and $p _ { g }$ , respectively. Since low-resolution data $_ { x \iota }$ corresponds directly to a downsampled version of $\scriptstyle { \mathbf { 2 } } ( { \mathbf { 2 } } )$ during training, we expect ${ \cal G } ( { \pmb x } _ { l } ; \theta _ { G } ) \approx { \pmb x } _ { h }$ . $G$ and $D$ are optimized according to the two-player minimax problem:
+
+$$
+\operatorname* { m i n } _ { \theta _ { G } } \operatorname* { m a x } _ { \theta _ { D } } \mathbb { E } _ { { \mathbf { x } } _ { h } \sim p _ { h } ( { \mathbf { x } } _ { h } ) } \left[ \log D \left( { \mathbf { x } } _ { h } ; \theta _ { D } \right) \right] + \mathbb { E } _ { { \mathbf { x } } _ { l } \sim p _ { l } ( { \mathbf { x } } _ { l } ) } \left[ \log \left( 1 - D \left( G \left( { \mathbf { x } } _ { l } ; \theta _ { G } \right) \right) \right) \right]
+$$
+
+This framework enables the joint optimization of two neural networks - $G$ generates super-resolution data with the goal of fooling $D$ , and $D$ is trained to distinguish between real and super-resolved data. Thus, the GAN approach encourages $G$ to learn solutions that are hard to distinguish from real, highresolution datum.
+
+Architecture overview MU-GAN (Multiscale U-net GAN) is composed of three models that all operate on raw audio2 - a generator $( G )$ , discriminator $( D )$ , and convolutional autoencoder $( A )$ (Figure 2). The generator’s task is to learn the mapping between the low and high-resolution data spaces, corresponding to signals $_ { x \iota }$ and $\scriptstyle { \mathbf { \mathcal { X } } } _ { h }$ , respectively. The discriminator’s task is then to classify whether presented data instances are real, or produced by the generator. In addition to $G$ and $D$ , the autoencoder extracts perceptually-relevant features from both real and super-resolved data for use in feature-space loss functions. The use of $A$ is crucial in the GAN framework, as generators trained solely on L2 or other sample-space losses suffer from training instability or output artifacts (Ledig et al., 2017).
+
+Multiscale convolutional layers In comparison to images, audio signals are inherently periodic with time-scales on the order of 10’s to 100’s of samples. As a consequence, filters with very large
+
+![](images/854c3bcc676018e0fdf23e5b7464449e58772c24a1965d6b3794d0a92c80e33f.jpg)  
+Figure 2: Overview of the model architecture and corresponding loss terms.
+
+![](images/d610c2182c452a0624bfc544e407b88edda293f6085cb4761b47ac1bf308f101.jpg)  
+Figure 3: Subpixel and superpixel layers for increasing and decreasing spatial resolution, respectively.
+
+# Generator
+
+![](images/ee84ede16153483e6f85a614168a1e57980e5d46f3944e1f798dcf67e0456e81.jpg)  
+Figure 4: Generator and discriminator models.
+
+receptive fields are required to create high quality raw audio (Donahue et al., 2018; van den Oord et al., 2016). Previous work with classifier models also suggests that varying the filter size within a network helps capture information at multiple scales (Szegedy et al., 2015). Leveraging these observations, we use a multiscale convolutional building block composed of concatenated 3x1, 9x1, $2 7 \mathrm { x } 1$ , and $8 1 \mathbf { x } 1$ filters. In practice, and with a fixed number of parameters for a given layer, we found that filters larger than 81x1 provided no additional benefit, while omitting large filter sizes resulted in significantly degraded audio quality. We interpret the poor performance of small filters as being a byproduct of their frequency selectivity; it is well known from signal processing theory that the resolution of an FIR filter’s frequency response is proportional to the length of the filter.
+
+Superpixel layers Recently, it has been shown that pooling and strided convolutions tend to induce periodic “checkerboard” artifacts (Odena et al., 2016; Donahue et al., 2018). Shi et al. (2016) developed a subpixel layer to increase spatial resolution, and showed that it is less prone to checkerboard artifacts. While the subpixel layer was subsequently adopted by several works (Kuleshov et al., 2017), no efforts have evaluated the performance of the inverse operation for decreasing spatial resolution. Concretely, the inverse subpixel operator interleaves samples from the time dimension into the channel dimension, and thus reduces the spatial resolution by an integer factor. We refer to this simple inverse operation as a superpixel layer (Figure 3), and use it as a drop-in replacement for strided convolution and pooling layers.
+
+Generator network The high-level architecture for the generator network (Figure 4, top) is inspired by autoencoder-like U-net models (Ronneberger et al., 2015; Isola et al., 2017; Kuleshov et al., 2017). In a U-net-style model, the first half of the network consists of $B$ downsampling blocks (D-blocks) that perform feature extraction at multiple scales and resolutions 3. The second half the model consists of $B$ upsampling blocks (U-blocks), which successively increase the spatial resolution of the signal. We use multi-scale convolutional layers throughput the generator network, and replace all strided convolutions with superpixel layers.
+
+Discriminator network The discriminator (Figure 4, bottom) is used during training to differentiate between real, high-resolution audio and super-resolved signals produced by the generator. Our design is loosely based on the recommendations of Radford et al. (2015), and the image discriminator from Ledig et al. (2017). All discriminator activations are LeakyReLU (Maas et al., 2013) with $\alpha = 0 . 2$ . As with the generator, we use multi-scale convolutions, and the superpixel layer described above instead of strided convolutions to minimize artifacts in the loss gradients (Odena et al., 2016).
+
+Autoencoder network The autoencoder $A$ is used to extract perceptually relevant features from the low and high-resolution signals. The features extracted by $A$ are incorporated in the generator’s feature loss $\mathcal { L } _ { f }$ , which is described in more detail in following sections. For the specific implementation of $A$ , we use a modified version of the generator model that excludes all additive and stacking skip connections. Hence, the model for $A$ is a convolutional autoencoder, augmented with multiscale convolutional layers, and super/subpixel layers for down/up-sampling.
+
+Loss functions MU-GAN incorporates several loss terms for training the generator and discriminator. The first term in the generator loss is the sample-space L2 loss, given by4
+
+$$
+\mathcal { L } _ { L 2 } = \frac { 1 } { W } \sum _ { i = 1 } ^ { W } \left. \pmb { x } _ { h , i } - G ( \pmb { x } _ { l } ) _ { i } \right. _ { 2 } ^ { 2 } .
+$$
+
+We found that using only the sample-space and adversarial losses either resulted in little to no improvement over the baseline non-GAN model, or introduced persistent audible artifacts (e.g., high-frequency tones, Figure 1). These findings are in line with those of Ledig et al. (2017), who experience similar issues with images 5. As described in Section 2, the use of a feature loss with GAN training encourages the generator to learn solutions that incorporate perceptually relevant texture details. Given the autoencoder $A$ , we denote the output feature tensor at the bottleneck of the autoencoder as $\phi$ . The feature loss $\mathcal { L } _ { f }$ is then given by
+
+$$
+\mathcal { L } _ { f } = \frac { 1 } { C _ { f } W _ { f } } \sum _ { c = 1 } ^ { C _ { f } } \sum _ { i = 1 } ^ { W _ { f } } \left. \phi ( \pmb { x _ { h } } ) _ { i , c } - \phi ( G ( \pmb { x _ { l } } ) ) _ { i , c } \right. _ { 2 } ^ { 2 } ,
+$$
+
+where $W _ { f }$ and $C _ { f }$ denote the width and channel dimensions for the feature maps of autoencoder bottleneck. The adversarial loss $\mathcal { L } _ { a d v }$ is determined by discriminator’s ability to discern whether data produced by the generator is real or fake. We use the gradient-friendly formulation originally posed in Goodfellow et al. (2014), given by
+
+$$
+\mathcal { L } _ { a d v } = - \log D ( G ( \pmb { x } \imath ) ) .
+$$
+
+The composite loss $\mathcal { L } _ { G }$ for the generator is then given by the sum of the losses above, and the discriminator loss $\mathcal { L } _ { D }$ derives directly from the GAN optimization objective in Equation 1, i.e.,
+
+$$
+\mathcal { L } _ { G } = \mathcal { L } _ { L 2 } + \lambda _ { f } \mathcal { L } _ { f } + \lambda _ { a d v } \mathcal { L } _ { a d v } ,
+$$
+
+$$
+\mathcal { L } _ { D } = - \left[ \log D ( \pmb { x } _ { h } ) + \log ( 1 - D ( G ( \pmb { x } _ { l } ) ) \right] ,
+$$
+
+where $\lambda _ { f }$ and $\lambda _ { a d v }$ are constant scaling factors.
+
+# 4 EXPERIMENTS
+
+Datasets We evaluate our methods on three super-resolution tasks derived from the VCTK Corpus (Yamagishi), and the non-vocal music dataset from Mehri et al. (2017). For speech from VCTK, we compose a dataset with recordings from a single speaker (the Speaker1 task), and a dataset with recordings from multiple speakers (the Speaker99 task). Speaker1 consists of the first 223 recordings from VCTK speaker 225 for training, and the final 8 recordings for testing. Speaker99 uses all recordings from the first 99 VCTK speakers for training, and recordings from the last 10 speakers for testing. Piano uses the standard $8 8 \% - 6 \% - 6 \%$ train/validation/test split. For all tasks, the dataset is created by first applying an anti-aliasing lowpass filter, and then sampling random patches of fixed length from the resulting audio. Note that for the sake of direct comparison, the datasets above are the same as those used in Kuleshov et al. (2017).
+
+Training methodology For Speaker1, we instantiate variants of MU-GAN and train for 400 epochs. For the larger datasets Speaker99 and Piano, models are trained for 150 epochs. The epoch number is empirically selected based on observed convergence, and performance saturation on the validation set. For all models, we use the ADAM optimizer with learning rate 1e-4, $\beta _ { 1 } = 0 . 9$ , $\beta _ { 2 } ~ = ~ 0 . 9 9 9$ , and a batch size of 32. For the autoencoder feature losses, we instantiate a model with $L = 4$ , and train for 400 epochs on the same dataset as its associated GAN model. The loss scaling factors $\lambda _ { f }$ and $\lambda _ { a d v }$ are fixed at 1.0 and 0.001, respectively. Additional details on model hyperparameters can be found in Appendix A.1.
+
+Performance metrics We use three metrics to assess the quality of super-resolved audio: (1) signal-to-noise ratio (SNR), (2) log-spectral distance (LSD), and (3) mean opinion score (MOS). The SNR is a standard metric in signal processing communities, defined as
+
+$$
+\begin{array} { r } { \mathrm { S N R } \left( x , x _ { r e f } \right) = 1 0 \log _ { 1 0 } \frac { \left\| x _ { r e f } \right\| _ { 2 } ^ { 2 } } { \left\| x - x _ { r e f } \right\| _ { 2 } ^ { 2 } } , } \end{array}
+$$
+
+where $x$ is an approximation of reference signal $x _ { r e f }$ . LSD (Gray & Markel, 1976) measures differences between signal frequencies, and has better correlation with perceptual quality compared to SNR (Jie et al., 2014; Kuleshov et al., 2017). Given short-time discrete Fourier transforms $X$ and $X _ { r e f }$ , the LSD is given by
+
+$$
+\begin{array} { r } { \mathrm { L S D } \left( X , X _ { r e f } \right) = \frac { 1 } { W } \sum _ { w = 1 } ^ { W } \sqrt { \frac { 1 } { K } \sum _ { k = 1 } ^ { N } \left( \log _ { 1 0 } \frac { | X ( w , k ) | ^ { 2 } } { | X _ { r e f } ( w , k ) | ^ { 2 } } \right) ^ { 2 } } , } \end{array}
+$$
+
+where $w$ and $k$ are the window and frequency bin indices, respectively6. Perceptual evaluation of speech quality (PESQ) (ITU-T, 2001) is an industry-standard methodology for the assessment of speech communication systems. Given reference and degraded audio signals, PESQ models the mean opinion score (MOS) of a group of listeners. Specifically, we use PESQ to produce MOS-LQO (listening quality objective) scores (ITU-T, 2003), which range from 1 to 5.
+
+Impact of superpixel layers We find that the use of superpixel layers results in ${\sim } 1 4 \%$ improvement in training time across model sizes, with insignificant differences in terms of objective quality metrics. Differences in audio produced by the two methods were also imperceptible in informal selfblinded listening tests. This indicates that superpixel layers may be a suitable replacement for conventional strided convolutions, while offering improvements in training time without performance loss. Additional details are provided in Appendix A.2.
+
+Objective performance evaluation Table 1 shows the quantitative performance of MU-GAN against other recent works. We denote MU-GAN8 as an instance of MU-GAN with a depth parameter of $L = 8$ , i.e., with 8 downsampling and 8 upsampling blocks. $U _ { ☉ }$ -net4 is the model with $L = 4$ from Kuleshov et al. (2017). To eliminate depth as a factor in the performance comparison, we reimplement the architecture from Kuleshov et al. (2017) with $L = 8$ , denoted as $U$ -net8.
+
+Table 1 shows that MU-GAN8 often performs worse in terms of SNR compared to the baseline models, but has lower LSD and higher MOS-LQO. This indicates that while MU-GAN8 produces reconstructions with lower SNR, deviating in terms of sample-wise distance results in synthesis of more perceptually-relevant frequency content. The exception is with the Piano task, where MUGAN8 performs orders of magnitude better than the U-net baseline in terms of SNR. In general, we also find that performance on the speech tasks generally saturates at $R = 2$ for both $U$ -net8 and $M U .$ GAN8. Informal listening tests confirm that there are minimal differences at $R = 2$ , indicating that more difficult up-sampling ratios (i.e., $R = 4$ , 6) are better suited for grounds of further comparison.
+
+Table 1: Objective comparison with baseline super-resolution networks†.   
+
+<table><tr><td rowspan="2" colspan="2"></td><td colspan="3">Up. Ratio R=2</td><td colspan="3">Up. Ratio R =4</td><td colspan="3">Up. Ratio R = 6</td></tr><tr><td>U-net4</td><td>U-net8</td><td>MU-GAN8</td><td>U-net4</td><td>U-net8</td><td>MU-GAN8</td><td>U-net4</td><td>U-net8</td><td>MU-GAN8</td></tr><tr><td rowspan="3">Speaker1</td><td>SNR</td><td>21.1</td><td>21.94</td><td>21.40</td><td>17.1</td><td>18.68</td><td>17.72</td><td>14.4</td><td>14.85</td><td>13.98</td></tr><tr><td>LSD</td><td>3.2</td><td>2.24</td><td>1.63</td><td>3.6</td><td>2.34</td><td>1.92</td><td>3.4</td><td>2.92</td><td>1.95</td></tr><tr><td>MOS-LQO</td><td>1</td><td>4.54</td><td>4.54</td><td>-</td><td>3.81</td><td>3.79</td><td>-</td><td>2.97</td><td>3.21</td></tr><tr><td rowspan="3">Speaker99</td><td>SNR</td><td>20.7</td><td>20.05</td><td>20.01</td><td>16.1</td><td>14.30</td><td>14.03</td><td>10.0</td><td>11.11</td><td>10.92</td></tr><tr><td>LSD</td><td>3.1</td><td>2.22</td><td>2.14</td><td>3.5</td><td>2.92</td><td>2.72</td><td>3.7</td><td>3.23</td><td>2.97</td></tr><tr><td>MOS-LQ0</td><td>1</td><td>3.68</td><td>3.75</td><td>-</td><td>2.68</td><td>2.93</td><td>1</td><td>2.44</td><td>2.69</td></tr><tr><td rowspan="2">Piano</td><td>SNR</td><td>30.1</td><td>44.98</td><td>52.03</td><td>23.5</td><td>31.71</td><td>32.28</td><td>16.1</td><td>22.53</td><td>24.71</td></tr><tr><td>LSD</td><td>3.4</td><td>1.12</td><td>0.90</td><td>3.6</td><td>1.35</td><td>1.30</td><td>4.4</td><td>1.53</td><td>1.41</td></tr></table>
+
+† Metrics for $U$ -net4 are taken directly from Kuleshov et al. (2017); those for $U$ -net8 are from our reimplementation.
+
+Table 2: A/B test user study scores.   
+
+<table><tr><td></td><td colspan="2">Piano</td><td colspan="4">Speaker99</td></tr><tr><td></td><td>#1</td><td>#2</td><td>#1</td><td>#2</td><td>#3</td><td>#4</td></tr><tr><td>MU-GAN8</td><td>9</td><td>15</td><td>14</td><td>11</td><td>15</td><td>10</td></tr><tr><td>U-net8 (baseline)</td><td>5</td><td>3</td><td>4</td><td>6</td><td>4</td><td>8</td></tr><tr><td>No preference</td><td>8</td><td>4</td><td>4</td><td>5</td><td>3</td><td>4</td></tr><tr><td colspan="7">R=4:Piano #1,Speaker99 #1,#3 R = 6: Piano #2,Speaker99 #2,#4</td></tr></table>
+
+Table 3: Speaker1 objective metrics for $M U .$ - GAN8 trained with the speech classifierbased loss, and proposed loss $( \mathcal { L } _ { f , S V } , \mathcal { L } _ { f } )$ .   
+
+<table><tr><td></td><td colspan="2">R=2</td><td colspan="2">R=4</td><td colspan="2">R=6</td></tr><tr><td></td><td>Lf,sV</td><td>Lf</td><td>Lf.sv</td><td>Lf</td><td>Lf.sv</td><td>Lf</td></tr><tr><td>SNR</td><td>21.28</td><td>21.40</td><td>17.57</td><td>17.72</td><td>13.85</td><td>13.98</td></tr><tr><td>LSD</td><td>1.65</td><td>1.63</td><td>1.92</td><td>1.92</td><td>1.99</td><td>1.95</td></tr><tr><td>MOS-LQO</td><td>4.54</td><td>4.54</td><td>3.67</td><td>3.79</td><td>3.24</td><td>3.21</td></tr></table>
+
+Subjective quality analysis To evaluate the performance of $M U  – G A N$ with real listeners, we perform a randomized, single-blinded user study with 22 participants (Table 2). The study presents pairs of audio clips produced by MU-GAN8 and the best baseline model $U _ { ☉ }$ -net8, and asks participants to select a preferred clip, or “No preference.” We present two clips from Piano, and four sonically diverse clips from Speaker99. Table 2 shows that in all cases, listeners prefer audio produced by MU-GAN8 over the baseline method.
+
+In general, we observe that audio produced by MU-GAN has greater clarity compared to audio produced by the baseline networks. The quality difference is most apparent during consonant sounds, which have more high-frequency content compared to typical vowel sounds. For instance, in the phrase “Ask her to bring these things from the store,” (Figure 5, bottom row) the consonant sounds in ‘Ask,’ ‘things,’ and ‘store’ have noticeably better articulation. In contrast, audio from the best baseline, $U _ { ☉ }$ -net8, sounds relatively dull and “muffled” in comparison. Note that on some audio clips super-resolved at $R = 4 , 6$ , we observe intermittent, audible noise that is not present in the baseline reconstructions. To ensure a fair analysis, we include audio clips in the user study where this noise is apparent. Additional comments on spurious noise can be found in Appendix A.3.
+
+Comparison with classifier-based feature loss We compare the proposed unsupervised feature loss with the classifier-based loss from Germain et al. (2018) 7. Germain et al. (2018) use a VGGbased (Simonyan & Zisserman, 2014) network as a feature loss for speech denoising, and train the loss network on classification and audio tagging tasks from DCASE 2016 (Mesaros et al., 2018). Table 3 shows objective results obtained using the proposed loss $\mathcal { L } _ { f }$ and the classifier-based loss $\mathcal { L } _ { f , S V }$ on the Speaker1 task. Across all up-sampling ratios, the proposed unsupervised method performs on-par (and slightly better in some cases) compared to the classifier-based loss. Thus, our results suggest that using a domain-specific classifier-based loss may not provide any advantage in terms of performance. Given the issues related to training classifier models on general audio (Section 1), our method may be an attractive solution that does not compromise audio quality.
+
+![](images/018841657e88744424ff34773eeafb70aef86bcaa2078e54ff5cccd9d3a6ae4e.jpg)  
+Figure 5: Spectrograms from the Speaker1 task at $R = 2$ (top row, Speaker 225), and Speaker99 task at $R = 4$ (bottom row, Speaker 360). (a-d) high-resolution, (b-e) super-resolved with $U _ { ☉ }$ -net8, and (c-f) super-resolved with MU-GAN8. Increased synthesis of high-frequency content by MU-GAN8 becomes more pronounced at difficult up-sampling ratios.
+
+Table 4: MOS-LQO for ablated models on the Speaker1 task.   
+
+<table><tr><td rowspan="2"></td><td colspan="6">Configuration</td></tr><tr><td>MU-GAN4 Up. Ratio -Lf-Ladu</td><td>MU-GAN4 -Ladu(+Lf)</td><td>MU-GAN4 (+Ladu+Lf)</td><td>MU-GAN8 -Lf-Ladu</td><td>MU-GAN8 -Ladu(+Lf)</td><td>MU-GAN8 (+Ladv+Lf)</td></tr><tr><td>R=2</td><td>3.53</td><td>4.54</td><td>4.54</td><td>4.54</td><td>4.54</td><td>4.54</td></tr><tr><td>R=4</td><td>3.15</td><td>3.55</td><td>3.62</td><td>3.74</td><td>3.79</td><td>3.79</td></tr><tr><td>R=6</td><td>2.78</td><td>3.07</td><td>3.12</td><td>3.15</td><td>3.17</td><td>3.21</td></tr></table>
+
+Ablation Analysis Table 4 shows the MOS-LQO metrics for the MU-GAN architecture with ablated model parameters. While almost all variations perform similarly well at $R = 2$ , adding depth (i.e., from $L = 4$ to $L = 8$ ) and additional loss terms improves performance on harder up-sampling ratios. Furthermore, adding the adversarial loss and unsupervised feature loss terms improve MOSLQO monotonically. For MU-GAN8, we see diminishing returns from adding the additional loss terms; much of the improvement over MU-GAN4 appears to come from the additional depth. On the other hand, adding the $\mathcal { L } _ { f }$ and $\mathcal { L } _ { a d v }$ losses to the MU-GAN4 variant yields significant benefits, such that its performance is comparable to that of MU-GAN8. This indicates that the feature and adversarial losses may be particularly useful to mitigate underfitting, or to decrease model size iso-performance.
+
+Receptive Field Analysis While previous works have stressed the importance of large receptive fields (van den Oord et al., 2016; Luo et al., 2016; Yu & Koltun, 2016), little work exists to quantify receptive field sizes on practical problems. We use the methods of Luo et al. (2016) to measure the effective receptive field (ERF)8 of our model on different tasks with varying architectural hyperparameters. Notably, we find that while the theoretical receptive field of our network is on the order of hundreds of milliseconds (thousands of samples), measured ERF’s are generally no wider than 100 samples. Furthermore, we find that ERF size is strongly correlated with problem difficulty, rather than architectural hyperparameters such as depth and specific loss terms. While Luo et al. (2016) found that ERF size always increased compared to the ERF at initialization, we find that ERF decreases in many cases (Figure 6). Our findings imply that there may be subtle but important tradeoffs involved with receptive field size (for instance, ERF size versus noise rejection), and suggest promising avenues for deeper investigation of architectures that rely on large receptive fields.
+
+![](images/9a4e8a7a8743ac09b4593279b7ffd6c5c45278e0ff6a707cee8520c2fa985c50.jpg)  
+Figure 6: Measured gradient magnitude at the model input and associated Gaussian fit with $M U .$ GAN4 for (a-c) $R = 2$ , 4, 6, respectively. (d) $2 \sigma$ ERF trend, compared to ERF at initialization.
+
+# 5 CONCLUSION
+
+In this work we develop methods to enable the application of GANs to audio processing, in particular with classifier-free feature losses. In addition to several new model building blocks, we show that a convolutional autoencoder can be used to implement a high-performance feature loss in the context of audio super-resolution. Demonstrated on several speech and music super-resolution tasks, we show that our architecture achieves state-of-the-art performance in both objective and subjective metrics. We perform a detailed analysis of our model, and also show that effective receptive field size may be an important property that is not well-explored. Finally, our work raises new possibilities for the design and analysis of neural network-based synthesis methods in important problem domains beyond audio processing.
+
+# REFERENCES
+
+Johannes Abel and Tim Fingscheidt. Artificial speech bandwidth extension using deep neural networks for wideband spectral envelope estimation. IEEE/ACM Transactions on Audio, Speech, and Language Processing, 26(1):71–83, 2018.   
+Yusuf Aytar, Carl Vondrick, and Antonio Torralba. Soundnet: Learning sound representations from unlabeled video. In NIPS, 2016.   
+Pramod Bachhav, Massimiliano Todisco, Moctar Mossi, Christophe Beaugeant, and Nicholas Evans. Artificial bandwidth extension using the constant q transform. In IEEE International Conference on Acoustics, Speech and Signal Processing, pp. 5550–5554, 2017.   
+David Berthelot, Tom Schumm, and Luke Metz. BEGAN: boundary equilibrium generative adversarial networks. CoRR, abs/1703.10717, 2017.   
+ClariNet. Clarinet: Parallel wave generation in end-to-end text-to-speech. In Submitted to International Conference on Learning Representations, 2019. URL https://openreview.net/ forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ HklY120cYm. under review.   
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR, 2009.   
+Emily L Denton, Soumith Chintala, Arthur Szlam, and Rob Fergus. Deep generative image models using a laplacian pyramid of adversarial networks. In NIPS, pp. 1486–1494. 2015.   
+Chris Donahue, Julian McAuley, and Miller Puckette. Synthesizing audio with generative adversarial networks. CoRR, abs/1802.04208, 2018.   
+Alexey Dosovitskiy and Thomas Brox. Generating images with perceptual similarity metrics based on deep networks. In NIPS, pp. 658–666. 2016.   
+Jesse Engel, Cinjon Resnick, Adam Roberts, Sander Dieleman, Douglas Eck, Karen Simonyan, and Mohammad Norouzi. Neural audio synthesis of musical notes with wavenet autoencoders. CoRR, abs/1704.01279, 2017.
+
+Francois G Germain, Qifeng Chen, and Vladlen Koltun. Speech denoising with deep feature losses. CoRR, 2018.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, pp. 2672–2680. 2014.
+
+Augustine Gray and John Markel. Distance measures for speech processing. IEEE Transactions on Acoustics, Speech, and Signal Processing, 24(5):380–391, 1976.
+
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. In CVPR, pp. 5967–5976, 2017.
+
+ITU-T. Perceptual evaluation of speech quality, an objective method for end-to-end speech quality assessment of narrowband telephone networks and speech codecs. ITU-T Rec. P.862, 2001.
+
+ITU-T. Mapping function for transforming p.862 raw result scores to MOS-LQO. ITU-T Rec. P.862.1, 2003.
+
+Zhang Jie, Xiaoqun Zhao, Jingyun Xu, and Zhang Yang. Suitability of speech quality evaluation measures in speech enhancement. In International Conference on Audio, Language and Image Processing, pp. 22–26, 2014.
+
+Justin Johnson, Alexandre Alahi, and Fei-Fei Li. Perceptual losses for real-time style transfer and super-resolution. CoRR, abs/1603.08155, 2016.
+
+Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of gans for improved quality, stability, and variation. International Conference on Representation Learning, abs/1710.10196, 2018.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. ICLR, 2014.
+
+Volodymyr Kuleshov, S. Zayd Enam, and Stefano Ermon. Audio super resolution using neural networks. ICLR, abs/1708.00853, 2017.
+
+Erik R. Larsen and Ronald M. Aarts. Audio Bandwidth Extension: Application of Psychoacoustics, Signal Processing and Loudspeaker Design. John Wiley & Sons, Inc., 2004. ISBN 0470858648.
+
+Christian Ledig, Lucas Theis, Ferenc Huszar, Jose Caballero, Andrew Cunningham, Alejandro Acosta, Andrew P. Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, and Wenzhe Shi. Photorealistic single image super-resolution using a generative adversarial network. In CVPR, pp. 105–114, 2017.
+
+Honglak Lee, Peter Pham, Yan Largman, and Andrew Y. Ng. Unsupervised feature learning for audio classification using convolutional deep belief networks. In NIPS, pp. 1096–1104. 2009.
+
+Bin Liu, Jianhua Tao, Zhengqi Wen, Ya Li, and Danish Bukhari. A novel method of artificial bandwidth extension using deep architecture. In INTERSPEECH, 2015.
+
+Wenjie Luo, Yujia Li, Raquel Urtasun, and Richard Zemel. Understanding the effective receptive field in deep convolutional neural networks. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), NIPS, pp. 4898–4906. 2016.
+
+Andrew L Maas, Awni Y Hannun, and Andrew Y Ng. Rectifier nonlinearities improve neural network acoustic models. In ICML, volume 30, pp. 3, 2013.
+
+Soroush Mehri, Kundan Kumar, Ishaan Gulrajani, Rithesh Kumar, Shubham Jain, Jose Sotelo, Aaron C. Courville, and Yoshua Bengio. Samplernn: An unconditional end-to-end neural audio generation model. ICLR, 2017.
+
+Annamaria Mesaros, Toni Heittola, Emmanouil Benetos, Peter Foster, Mathieu Lagrange, Tuomos Virtanen, and Mark D. Plumbley. Detection and classification of acoustic scenes and events: Outcome of the dcase 2016 challenge. IEEE/ACM Transactions on Audio, Speech, and Language Processing, 26(2):379–393, 2018.
+
+Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. CoRR, abs/1411.1784, 2014.
+
+Augustus Odena, Vincent Dumoulin, and Chris Olah. Deconvolution and checkerboard artifacts. Distill, 2016. URL http://distill.pub/2016/deconv-checkerboard.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. ICLR, 2015.
+
+Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In Medical Image Computing and Computer-Assisted Intervention, pp. 234–241, 2015.
+
+Andy M Sarroff and Michael A Casey. Musical audio synthesis using autoencoding neural nets. In International Computer Music Conference, 2014.
+
+Wenzhe Shi, Jose Caballero, Ferenc Huszar, Johannes Totz, Andrew P. Aitken, Rob Bishop, Daniel ´ Rueckert, and Zehan Wang. Real-time single image and video super-resolution using an efficient sub-pixel convolutional neural network. In CVPR, pp. 1874–1883, 2016.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014.
+
+Casper Kaae Sonderby, Tapani Raiko, Lars Maaloe, Soren Kaae Sonderby, and Ole Winther. Ladder variational autoencoders. In NIPS, pp. 3738–3746. 2016.
+
+Jose Sotelo, Soroush Mehri, Kundan Kumar, Joo F. Santos, Kyle Kastner, Aaron Courville, and Yoshua Bengio. Char2Wav: End-to-end speech synthesis. In ICLR, 2017.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In CVPR, pp. 1–9, 2015.
+
+Keiichi Tokuda, Yoshihiko Nankaku, Tomoki Toda, Heiga Zen, Junichi Yamagishi, and Keiichiro Oura. Speech synthesis based on hidden markov models. Proceedings of the IEEE, 101(5): 1234–1252, 2013.
+
+Aaron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, ¨ Nal Kalchbrenner, Andrew W. Senior, and Koray Kavukcuoglu. Wavenet: A generative model for raw audio. CoRR, abs/1609.03499, 2016.
+
+Aaron van den Oord, Yazhe Li, Igor Babuschkin, Karen Simonyan, Oriol Vinyals, Koray Kavukcuoglu, George van den Driessche, Edward Lockhart, Luis Cobo, Florian Stimberg, Norman Casagrande, Dominik Grewe, Seb Noury, Sander Dieleman, Erich Elsen, Nal Kalchbrenner, Heiga Zen, Alex Graves, Helen King, Tom Walters, Dan Belov, and Demis Hassabis. Parallel WaveNet: Fast high-fidelity speech synthesis. In ICML, volume 80, pp. 3918–3926, 2018.
+
+Pascal Vincent, Hugo Larochelle, Isabelle Lajoie, Yoshua Bengio, and Pierre-Antoine Manzagol. Stacked denoising autoencoders: Learning useful representations in a deep network with a local denoising criterion. JMLR, 11:3371–3408, 2010.
+
+Junichi Yamagishi. CSTR VCTK corpus. http://homepages.inf.ed.ac.uk/ jyamagis/page3/page58/page58.html.
+
+Fisher Yu and Vladlen Koltun. Multi-scale context aggregation by dilated convolutions. ICLR, abs/1511.07122, 2016.
+
+# A APPENDIX
+
+A.1 MODEL PARAMETERS
+
+# A.2 EVALUATION OF SUPERPIXEL LAYERS
+
+We evaluate the impact of the superpixel layer proposed in Section 3 by comparing a baseline multiscale U-net with strided convolutions (Strided) against a multiscale U-net with superpixel layers (Super). We halve the number of convolutional kernels in each downsampling layer for Super such that the output feature map dimensions at each downsampling and upsampling layer are identical to those in Strided. Both model types are trained with the baseline $L 2$ loss for 400 epochs on the Speaker1 task.
+
+Table 5: Comparison of superpixel and strided convolutional layers.   
+(b) Quality metrics   
+
+<table><tr><td rowspan="2"></td><td rowspan="2"></td><td colspan="3">Upsampling I Ratio</td></tr><tr><td>R=2</td><td>R=4</td><td>R=6</td></tr><tr><td rowspan="2">SNR</td><td>Strided</td><td>21.67</td><td>18.45</td><td>14.91</td></tr><tr><td>Super</td><td>21.75</td><td>18.41</td><td>14.89</td></tr><tr><td rowspan="2">LSD</td><td>Strided</td><td>1.67</td><td>2.20</td><td>2.73</td></tr><tr><td>Super</td><td>1.70</td><td>2.08</td><td>2.39</td></tr><tr><td rowspan="2">MOS-LQ0</td><td>Strided</td><td>3.57</td><td>3.13</td><td>2.71</td></tr><tr><td>Super</td><td>3.53</td><td>3.15</td><td>2.78</td></tr></table>
+
+(a) Training time per minibatch   
+
+<table><tr><td rowspan="2"></td><td colspan="2">Depth Parameter</td></tr><tr><td>L=4</td><td>L=8</td></tr><tr><td>Strided</td><td>149.8 s</td><td>195.1 s</td></tr><tr><td>Super</td><td>128.1 s</td><td>168.0 s</td></tr><tr><td>Speedup</td><td>14.5%</td><td>13.8%</td></tr></table>
+
+# A.3 NOTE ON INTERMITTENT SPURIOUS NOISE
+
+As described in Section 4, some audio clips super-resolved at $R = 4 , 6$ exhibit intermittent, audible noise that is not present in the baseline reconstructions. We find that this noise is not inherent to our specific feature loss, and is present if we replace the unsupervised feature loss with a classifierbased feature loss. The spurious noise is also unrelated to the use of $\mathcal { L } _ { a d v }$ , as it is present in audio generated by models trained only with $\mathcal { L } _ { f }$ . While a deeper investigation is planned for future work, we hypothesize that such noise stems from phase ambiguity in missing high-frequency content.

parse/train/H1eH4n09KX/H1eH4n09KX_content_list.json

@@ -0,0 +1,1330 @@
+[
+    {
+        "type": "text",
+        "text": "ADVERSARIAL AUDIO SUPER-RESOLUTION WITH UNSUPERVISED FEATURE LOSSES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            699,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural network-based methods have recently demonstrated state-of-the-art results on image synthesis and super-resolution tasks, in particular by using variants of generative adversarial networks (GANs) with supervised feature losses. Nevertheless, previous feature loss formulations rely on the availability of large auxiliary classifier networks, and labeled datasets that enable such classifiers to be trained. Furthermore, there has been comparatively little work to explore the applicability of GAN-based methods to domains other than images and video. In this work we explore a GAN-based method for audio processing, and develop a convolutional neural network architecture to perform audio super-resolution. In addition to several new architectural building blocks for audio processing, a key component of our approach is the use of an autoencoder-based loss that enables training in the GAN framework, with feature losses derived from unlabeled data. We explore the impact of our architectural choices, and demonstrate significant improvements over previous works in terms of both objective and perceptual quality. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            462
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            491,
+            334,
+            507
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep convolutional neural networks (CNNs) have become a cornerstone in modern solutions for image and audio analysis. Such networks have excelled at supervised discrimination tasks, for instance on ImageNet (Deng et al., 2009; Simonyan & Zisserman, 2014), where image classifier networks are trained on a large corpus of labeled data. More recently, CNNs have successfully been applied to data synthesis problems in the context of generative adversarial networks (GANs) (Goodfellow et al., 2014). In the GAN framework, a neural network is used to synthesize new instances from a modeled distribution, or resolve missing details given lossy observations. In the latter case, the GANs have been shown to greatly improve reconstruction of fine texture details for images, compared to standalone sample-space losses that result in overly smoothed outputs (Dosovitskiy & Brox, 2016; Isola et al., 2017; Ledig et al., 2017). However, GANs are notoriously hard to train, and the use of conventional sample-space objectives in conjunction with an adversarial loss either de-stabilizes training, or results in outputs with significant artifacts (Figure 1). ",
+        "bbox": [
+            174,
+            523,
+            825,
+            689
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To address the smoothness problem described above, previous works typically augment or replace conventional sample-space losses with a feature loss (also called a perceptual loss) (Dosovitskiy & Brox, 2016; Ledig et al., 2017; Johnson et al., 2016). Instead of distance in raw sample-space, such feature losses reflect distance in terms of the feature maps of an auxiliary neural network. While classifier-based feature losses are effective, they require either a pre-trained neural network that is applicable to the problem domain (e.g., synthesizing images of cats), or a labeled dataset that is amenable to training a relevant classifier. Training new classifiers for use in a feature loss can be non-trivial for numerous reasons. Besides the difficulty of training large classifiers that are commonly used for feature losses, such as VGG (Simonyan & Zisserman, 2014), creating a labeled dataset that is sufficiently large and diverse is often infeasible. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            835
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we sidestep the difficulty of training auxiliary classifiers by developing a feature loss that is unsupervised. In particular, we focus on an audio modeling task called super-resolution, where the goal is to generate high-quality audio given down-sampled, low-resolution input. Inspired by previous work on audio and image super-resolution, we develop a neural network architecture for end-to-end super-resolution that operates on raw audio. In addition to providing new algorithms to model audio, our work suggests new techniques to improve GAN-based methods in other domains such as images and video. Specifically, our contributions are as follows: ",
+        "bbox": [
+            176,
+            843,
+            823,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/1fb78758bb93c0993cb3e0b11918e1a6d3b405bd9508da262a985658f7e7a085.jpg",
+        "image_caption": [
+            "Figure 1: (a) High-resolution, (b) low-resolution, (c) and super-resolution spectrograms. The superresolution spectrogram corresponds to audio generated by the GAN described in Section 3, trained only with an adversarial loss and conventional $L 2$ loss. Training tends to either diverge, or results in audio with persistent high-frequency tones and alias-like artifacts. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            101,
+            815,
+            218
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            313,
+            825,
+            354
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We formulate a new, general-purpose feature loss that is fully unsupervised and circumvents the need for problematic classifier-based models.   \n2. We successfully adapt the adversarial framework for audio processing, and provide solutions to previously unsolved problems associated with the application of GANs to audio.   \n3. We demonstrate our methods in an end-to-end architecture for audio super-resolution, with stateof-the-art results on both speech and music tasks.   \n4. We analyze important architectural parameters of our model, and in particular discover previously-unobserved behavior with effective receptive field sizes. ",
+        "bbox": [
+            169,
+            366,
+            826,
+            497
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND & RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            517,
+            491,
+            534
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Audio super-resolution Audio super-resolution is the task of constructing a high-resolution audio signal from a low-resolution signal that contains a fraction of the original samples. Concretely, given a low-resolution sequence of audio samples $x _ { l } \\ = \\ ( x _ { 1 / R _ { l } } , \\ldots , x _ { R _ { l } T / R _ { l } } )$ , we wish to synthesize a high-resolution audio signal $x _ { h } = ( x _ { 1 / R _ { h } } , \\ldots , x _ { R _ { h } T / R _ { h } } )$ , where $R _ { l }$ and $R _ { h }$ are the sampling rates of the low and high-resolution signals, respectively. We denote $R = { { R } _ { h } } / { { R } _ { l } }$ as the upsampling ratio, which ranges from 2 to 6 in this work. Thus, the audio super-resolution problem is equivalent to reconstructing the missing frequency content between frequencies $R _ { l } / 2$ and $R _ { h } / 2$ . ",
+        "bbox": [
+            173,
+            549,
+            825,
+            650
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There is a vast body of prior work on audio super-resolution in the signal and audio processing communities under the term artificial bandwidth extension (Larsen & Aarts, 2004). Neural networkbased methods in this domain generally apply a DNN on top of hand-crafted features as part of complex bandwidth extension systems (Liu et al., 2015; Abel & Fingscheidt, 2018). Gaussian mixture and hidden Markov models have also been used (Bachhav et al., 2017; Tokuda et al., 2013), but these methods generally perform worse compared to neural networks (Abel & Fingscheidt, 2018). In contrast with the works above, our method does not rely on hand-crafted features (e.g., transformations or cepstrum coefficients), and is not specific to problems in speech modeling. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            768
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Audio modeling with neural networks Learning-based approaches for audio have also been explored in the largely in the context of representation learning, generative modeling, and text-tospeech (TTS) systems. Unsupervised methods such as convolutional deep belief networks (Lee et al., 2009) and bottleneck CNNs (Aytar et al., 2016) have been shown to learn useful representations from audio, such as phonemes and sound textures. Stacked autoencoders (Vincent et al., 2010) and variational autoencoders (Kingma & Welling, 2014; Sonderby et al., 2016) have been used for denoising, image generation, and music synthesis (Sarroff & Casey, 2014). Bottleneck-like CNNs have also demonstrated significant improvements for audio super-resolution in supervised settings compared to previous DNN and spline-based methods (Kuleshov et al., 2017). Donahue et al. (2018) is among the first to develop methods for raw audio synthesis with GANs. Notably, Donahue et al. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(2018) show that non-trivial modifications of GAN architectures are required to generative diverse and plausible audio outputs. We build on the works above by developing a GAN framework for audio super-resolution with an improved bottleneck-style generator, and show that leveraging representations learned from unsupervised training greatly aid the super-resolution task. Autoregressive probabilistic models have recently demonstrated state-of-the-art results for generation of music (Engel et al., 2017), general audio (van den Oord et al., 2016; Mehri et al., 2017), and for parametric TTS systems (Sotelo et al., 2017). Several works have leveraged model distillation (van den Oord et al., 2018; ClariNet, 2019)1 to mitigate the overhead of autoregressive methods, making them feasible for real-time audio generation. In general, our work can be used to augment existing speech synthesis systems, including those that employ autoregressive methods. For instance, the unsupervised feature loss proposed in our work could be used as a drop-in replacement for the classifier-based feature loss used by van den Oord et al. (2018). While we are not aware of any efforts that explore autoregressive modeling for audio super-resolution, we believe it may be a promising future direction. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            284
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Generative adversarial networks for images Generative methods have been extensively explored for image generation and super-resolution. Building upon the original formulation of Goodfellow et al. (2014), GANs have been continuously improved to generate plausible, high-fidelity images (Radford et al., 2015; Denton et al., 2015; Berthelot et al., 2017; Karras et al., 2018). GAN variants conditioned on class labels or object sketches have also demonstrated promising results on tasks such as in-painting and style transfer (Mirza & Osindero, 2014; Isola et al., 2017). ",
+        "bbox": [
+            174,
+            300,
+            823,
+            383
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            405,
+            281,
+            420
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "GANs for Super-Resolution GANs developed for super-resolution tasks have several important differences compared to the original formulation of Goodfellow et al. (2014). When used to generate new instances from a data distribution $p _ { \\mathrm { d a t a } }$ , the generator $( G )$ parameterized by $\\theta _ { G }$ learns the mapping to data space as $G ( z ; \\theta _ { G } )$ , where $_ { z }$ is a latent noise prior. The discriminator $( D )$ parameterized by $\\theta _ { D }$ then estimates the probability that $G ( z ; \\theta _ { G } )$ was drawn from $p _ { \\mathrm { d a t a } }$ rather than the generator distribution $p _ { g }$ . In contrast, for super-resolution, $G$ is no longer conditioned on noise and learns the mapping to high-resolution data space $p _ { h }$ as $G ( \\pmb { x } \\imath ; \\theta _ { G } )$ , where $_ { x \\iota }$ is drawn from the low-resolution data distribution $p _ { l }$ . The task of $D$ is to discriminate between samples from the high-resolution and super-resolution (generator) distributions $p _ { h }$ and $p _ { g }$ , respectively. Since low-resolution data $_ { x \\iota }$ corresponds directly to a downsampled version of $\\scriptstyle { \\mathbf { 2 } } ( { \\mathbf { 2 } } )$ during training, we expect ${ \\cal G } ( { \\pmb x } _ { l } ; \\theta _ { G } ) \\approx { \\pmb x } _ { h }$ . $G$ and $D$ are optimized according to the two-player minimax problem: ",
+        "bbox": [
+            173,
+            435,
+            825,
+            590
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/daf4e52a03e65133f8770254279dc47bd0e9d9075986bc07649022689c38662f.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta _ { G } } \\operatorname* { m a x } _ { \\theta _ { D } } \\mathbb { E } _ { { \\mathbf { x } } _ { h } \\sim p _ { h } ( { \\mathbf { x } } _ { h } ) } \\left[ \\log D \\left( { \\mathbf { x } } _ { h } ; \\theta _ { D } \\right) \\right] + \\mathbb { E } _ { { \\mathbf { x } } _ { l } \\sim p _ { l } ( { \\mathbf { x } } _ { l } ) } \\left[ \\log \\left( 1 - D \\left( G \\left( { \\mathbf { x } } _ { l } ; \\theta _ { G } \\right) \\right) \\right) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            608,
+            758,
+            635
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This framework enables the joint optimization of two neural networks - $G$ generates super-resolution data with the goal of fooling $D$ , and $D$ is trained to distinguish between real and super-resolved data. Thus, the GAN approach encourages $G$ to learn solutions that are hard to distinguish from real, highresolution datum. ",
+        "bbox": [
+            174,
+            643,
+            823,
+            700
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Architecture overview MU-GAN (Multiscale U-net GAN) is composed of three models that all operate on raw audio2 - a generator $( G )$ , discriminator $( D )$ , and convolutional autoencoder $( A )$ (Figure 2). The generator’s task is to learn the mapping between the low and high-resolution data spaces, corresponding to signals $_ { x \\iota }$ and $\\scriptstyle { \\mathbf { \\mathcal { X } } } _ { h }$ , respectively. The discriminator’s task is then to classify whether presented data instances are real, or produced by the generator. In addition to $G$ and $D$ , the autoencoder extracts perceptually-relevant features from both real and super-resolved data for use in feature-space loss functions. The use of $A$ is crucial in the GAN framework, as generators trained solely on L2 or other sample-space losses suffer from training instability or output artifacts (Ledig et al., 2017). ",
+        "bbox": [
+            173,
+            715,
+            825,
+            842
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multiscale convolutional layers In comparison to images, audio signals are inherently periodic with time-scales on the order of 10’s to 100’s of samples. As a consequence, filters with very large ",
+        "bbox": [
+            174,
+            858,
+            820,
+            886
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/854c3bcc676018e0fdf23e5b7464449e58772c24a1965d6b3794d0a92c80e33f.jpg",
+        "image_caption": [
+            "Figure 2: Overview of the model architecture and corresponding loss terms. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            99,
+            464,
+            183
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/d610c2182c452a0624bfc544e407b88edda293f6085cb4761b47ac1bf308f101.jpg",
+        "image_caption": [
+            "Figure 3: Subpixel and superpixel layers for increasing and decreasing spatial resolution, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            503,
+            101,
+            794,
+            167
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Generator ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            233,
+            240,
+            244
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/ee84ede16153483e6f85a614168a1e57980e5d46f3944e1f798dcf67e0456e81.jpg",
+        "image_caption": [
+            "Figure 4: Generator and discriminator models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            242,
+            808,
+            470
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "receptive fields are required to create high quality raw audio (Donahue et al., 2018; van den Oord et al., 2016). Previous work with classifier models also suggests that varying the filter size within a network helps capture information at multiple scales (Szegedy et al., 2015). Leveraging these observations, we use a multiscale convolutional building block composed of concatenated 3x1, 9x1, $2 7 \\mathrm { x } 1$ , and $8 1 \\mathbf { x } 1$ filters. In practice, and with a fixed number of parameters for a given layer, we found that filters larger than 81x1 provided no additional benefit, while omitting large filter sizes resulted in significantly degraded audio quality. We interpret the poor performance of small filters as being a byproduct of their frequency selectivity; it is well known from signal processing theory that the resolution of an FIR filter’s frequency response is proportional to the length of the filter. ",
+        "bbox": [
+            173,
+            521,
+            825,
+            646
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Superpixel layers Recently, it has been shown that pooling and strided convolutions tend to induce periodic “checkerboard” artifacts (Odena et al., 2016; Donahue et al., 2018). Shi et al. (2016) developed a subpixel layer to increase spatial resolution, and showed that it is less prone to checkerboard artifacts. While the subpixel layer was subsequently adopted by several works (Kuleshov et al., 2017), no efforts have evaluated the performance of the inverse operation for decreasing spatial resolution. Concretely, the inverse subpixel operator interleaves samples from the time dimension into the channel dimension, and thus reduces the spatial resolution by an integer factor. We refer to this simple inverse operation as a superpixel layer (Figure 3), and use it as a drop-in replacement for strided convolution and pooling layers. ",
+        "bbox": [
+            174,
+            661,
+            825,
+            786
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Generator network The high-level architecture for the generator network (Figure 4, top) is inspired by autoencoder-like U-net models (Ronneberger et al., 2015; Isola et al., 2017; Kuleshov et al., 2017). In a U-net-style model, the first half of the network consists of $B$ downsampling blocks (D-blocks) that perform feature extraction at multiple scales and resolutions 3. The second half the model consists of $B$ upsampling blocks (U-blocks), which successively increase the spatial resolution of the signal. We use multi-scale convolutional layers throughput the generator network, and replace all strided convolutions with superpixel layers. ",
+        "bbox": [
+            174,
+            803,
+            825,
+            900
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Discriminator network The discriminator (Figure 4, bottom) is used during training to differentiate between real, high-resolution audio and super-resolved signals produced by the generator. Our design is loosely based on the recommendations of Radford et al. (2015), and the image discriminator from Ledig et al. (2017). All discriminator activations are LeakyReLU (Maas et al., 2013) with $\\alpha = 0 . 2$ . As with the generator, we use multi-scale convolutions, and the superpixel layer described above instead of strided convolutions to minimize artifacts in the loss gradients (Odena et al., 2016). ",
+        "bbox": [
+            173,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Autoencoder network The autoencoder $A$ is used to extract perceptually relevant features from the low and high-resolution signals. The features extracted by $A$ are incorporated in the generator’s feature loss $\\mathcal { L } _ { f }$ , which is described in more detail in following sections. For the specific implementation of $A$ , we use a modified version of the generator model that excludes all additive and stacking skip connections. Hence, the model for $A$ is a convolutional autoencoder, augmented with multiscale convolutional layers, and super/subpixel layers for down/up-sampling. ",
+        "bbox": [
+            174,
+            202,
+            825,
+            287
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Loss functions MU-GAN incorporates several loss terms for training the generator and discriminator. The first term in the generator loss is the sample-space L2 loss, given by4 ",
+        "bbox": [
+            171,
+            301,
+            821,
+            330
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a6f47364ce5354745f368da6d90f490ea39ca0ca56a13c57135364472da18b39.jpg",
+        "text": "$$\n\\mathcal { L } _ { L 2 } = \\frac { 1 } { W } \\sum _ { i = 1 } ^ { W } \\left. \\pmb { x } _ { h , i } - G ( \\pmb { x } _ { l } ) _ { i } \\right. _ { 2 } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            345,
+            614,
+            390
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We found that using only the sample-space and adversarial losses either resulted in little to no improvement over the baseline non-GAN model, or introduced persistent audible artifacts (e.g., high-frequency tones, Figure 1). These findings are in line with those of Ledig et al. (2017), who experience similar issues with images 5. As described in Section 2, the use of a feature loss with GAN training encourages the generator to learn solutions that incorporate perceptually relevant texture details. Given the autoencoder $A$ , we denote the output feature tensor at the bottleneck of the autoencoder as $\\phi$ . The feature loss $\\mathcal { L } _ { f }$ is then given by ",
+        "bbox": [
+            173,
+            398,
+            825,
+            497
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/23270b9dd2f5090371aebc4a8643c9e6234ddf8ba1107ef0bb5a1dfb90eda183.jpg",
+        "text": "$$\n\\mathcal { L } _ { f } = \\frac { 1 } { C _ { f } W _ { f } } \\sum _ { c = 1 } ^ { C _ { f } } \\sum _ { i = 1 } ^ { W _ { f } } \\left. \\phi ( \\pmb { x _ { h } } ) _ { i , c } - \\phi ( G ( \\pmb { x _ { l } } ) ) _ { i , c } \\right. _ { 2 } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            513,
+            666,
+            559
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { f }$ and $C _ { f }$ denote the width and channel dimensions for the feature maps of autoencoder bottleneck. The adversarial loss $\\mathcal { L } _ { a d v }$ is determined by discriminator’s ability to discern whether data produced by the generator is real or fake. We use the gradient-friendly formulation originally posed in Goodfellow et al. (2014), given by ",
+        "bbox": [
+            173,
+            568,
+            825,
+            625
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7edc7a2473996a7666f46cced58595d478820697e7766b3de49baa9a9573e000.jpg",
+        "text": "$$\n\\mathcal { L } _ { a d v } = - \\log D ( G ( \\pmb { x } \\imath ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            643,
+            584,
+            661
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The composite loss $\\mathcal { L } _ { G }$ for the generator is then given by the sum of the losses above, and the discriminator loss $\\mathcal { L } _ { D }$ derives directly from the GAN optimization objective in Equation 1, i.e., ",
+        "bbox": [
+            173,
+            670,
+            828,
+            699
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cafbc308bb977cef964411f9a3b8813b2f5c34ba05031cd629dadaabe941d2fc.jpg",
+        "text": "$$\n\\mathcal { L } _ { G } = \\mathcal { L } _ { L 2 } + \\lambda _ { f } \\mathcal { L } _ { f } + \\lambda _ { a d v } \\mathcal { L } _ { a d v } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            718,
+            607,
+            737
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1b1b8191f539000101ecf39e08b1f5159f7037ee7b7931c989671643742a7e29.jpg",
+        "text": "$$\n\\mathcal { L } _ { D } = - \\left[ \\log D ( \\pmb { x } _ { h } ) + \\log ( 1 - D ( G ( \\pmb { x } _ { l } ) ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            751,
+            645,
+            768
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda _ { f }$ and $\\lambda _ { a d v }$ are constant scaling factors. ",
+        "bbox": [
+            176,
+            779,
+            485,
+            794
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            813,
+            326,
+            829
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Datasets We evaluate our methods on three super-resolution tasks derived from the VCTK Corpus (Yamagishi), and the non-vocal music dataset from Mehri et al. (2017). For speech from VCTK, we compose a dataset with recordings from a single speaker (the Speaker1 task), and a dataset with recordings from multiple speakers (the Speaker99 task). Speaker1 consists of the first 223 recordings from VCTK speaker 225 for training, and the final 8 recordings for testing. Speaker99 uses all recordings from the first 99 VCTK speakers for training, and recordings from the last 10 speakers for testing. Piano uses the standard $8 8 \\% - 6 \\% - 6 \\%$ train/validation/test split. For all tasks, the dataset is created by first applying an anti-aliasing lowpass filter, and then sampling random patches of fixed length from the resulting audio. Note that for the sake of direct comparison, the datasets above are the same as those used in Kuleshov et al. (2017). ",
+        "bbox": [
+            176,
+            844,
+            825,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training methodology For Speaker1, we instantiate variants of MU-GAN and train for 400 epochs. For the larger datasets Speaker99 and Piano, models are trained for 150 epochs. The epoch number is empirically selected based on observed convergence, and performance saturation on the validation set. For all models, we use the ADAM optimizer with learning rate 1e-4, $\\beta _ { 1 } = 0 . 9$ , $\\beta _ { 2 } ~ = ~ 0 . 9 9 9$ , and a batch size of 32. For the autoencoder feature losses, we instantiate a model with $L = 4$ , and train for 400 epochs on the same dataset as its associated GAN model. The loss scaling factors $\\lambda _ { f }$ and $\\lambda _ { a d v }$ are fixed at 1.0 and 0.001, respectively. Additional details on model hyperparameters can be found in Appendix A.1. ",
+        "bbox": [
+            173,
+            217,
+            825,
+            329
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Performance metrics We use three metrics to assess the quality of super-resolved audio: (1) signal-to-noise ratio (SNR), (2) log-spectral distance (LSD), and (3) mean opinion score (MOS). The SNR is a standard metric in signal processing communities, defined as ",
+        "bbox": [
+            174,
+            344,
+            825,
+            387
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f52a794bbed0f5b655d85d592a56eae281b9c56a03262b60d7cf66ac74f10d0b.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathrm { S N R } \\left( x , x _ { r e f } \\right) = 1 0 \\log _ { 1 0 } \\frac { \\left\\| x _ { r e f } \\right\\| _ { 2 } ^ { 2 } } { \\left\\| x - x _ { r e f } \\right\\| _ { 2 } ^ { 2 } } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            405,
+            620,
+            433
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $x$ is an approximation of reference signal $x _ { r e f }$ . LSD (Gray & Markel, 1976) measures differences between signal frequencies, and has better correlation with perceptual quality compared to SNR (Jie et al., 2014; Kuleshov et al., 2017). Given short-time discrete Fourier transforms $X$ and $X _ { r e f }$ , the LSD is given by ",
+        "bbox": [
+            174,
+            443,
+            825,
+            501
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ee7fb820193217f4ba6239c28d10a7d0e4aec382803e439ee8480ade3714931f.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathrm { L S D } \\left( X , X _ { r e f } \\right) = \\frac { 1 } { W } \\sum _ { w = 1 } ^ { W } \\sqrt { \\frac { 1 } { K } \\sum _ { k = 1 } ^ { N } \\left( \\log _ { 1 0 } \\frac { | X ( w , k ) | ^ { 2 } } { | X _ { r e f } ( w , k ) | ^ { 2 } } \\right) ^ { 2 } } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            517,
+            709,
+            553
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $w$ and $k$ are the window and frequency bin indices, respectively6. Perceptual evaluation of speech quality (PESQ) (ITU-T, 2001) is an industry-standard methodology for the assessment of speech communication systems. Given reference and degraded audio signals, PESQ models the mean opinion score (MOS) of a group of listeners. Specifically, we use PESQ to produce MOS-LQO (listening quality objective) scores (ITU-T, 2003), which range from 1 to 5. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            636
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Impact of superpixel layers We find that the use of superpixel layers results in ${\\sim } 1 4 \\%$ improvement in training time across model sizes, with insignificant differences in terms of objective quality metrics. Differences in audio produced by the two methods were also imperceptible in informal selfblinded listening tests. This indicates that superpixel layers may be a suitable replacement for conventional strided convolutions, while offering improvements in training time without performance loss. Additional details are provided in Appendix A.2. ",
+        "bbox": [
+            173,
+            651,
+            823,
+            736
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Objective performance evaluation Table 1 shows the quantitative performance of MU-GAN against other recent works. We denote MU-GAN8 as an instance of MU-GAN with a depth parameter of $L = 8$ , i.e., with 8 downsampling and 8 upsampling blocks. $U _ { ☉ }$ -net4 is the model with $L = 4$ from Kuleshov et al. (2017). To eliminate depth as a factor in the performance comparison, we reimplement the architecture from Kuleshov et al. (2017) with $L = 8$ , denoted as $U$ -net8. ",
+        "bbox": [
+            174,
+            751,
+            823,
+            820
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows that MU-GAN8 often performs worse in terms of SNR compared to the baseline models, but has lower LSD and higher MOS-LQO. This indicates that while MU-GAN8 produces reconstructions with lower SNR, deviating in terms of sample-wise distance results in synthesis of more perceptually-relevant frequency content. The exception is with the Piano task, where MUGAN8 performs orders of magnitude better than the U-net baseline in terms of SNR. In general, we also find that performance on the speech tasks generally saturates at $R = 2$ for both $U$ -net8 and $M U .$ GAN8. Informal listening tests confirm that there are minimal differences at $R = 2$ , indicating that more difficult up-sampling ratios (i.e., $R = 4$ , 6) are better suited for grounds of further comparison. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            898
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/67b1d9435ce432eaa21e78d54e0c287987823a82be6a15222fdc6b17e357efc4.jpg",
+        "table_caption": [
+            "Table 1: Objective comparison with baseline super-resolution networks†. "
+        ],
+        "table_footnote": [
+            "† Metrics for $U$ -net4 are taken directly from Kuleshov et al. (2017); those for $U$ -net8 are from our reimplementation. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\" colspan=\"2\"></td><td colspan=\"3\">Up. Ratio R=2</td><td colspan=\"3\">Up. Ratio R =4</td><td colspan=\"3\">Up. Ratio R = 6</td></tr><tr><td>U-net4</td><td>U-net8</td><td>MU-GAN8</td><td>U-net4</td><td>U-net8</td><td>MU-GAN8</td><td>U-net4</td><td>U-net8</td><td>MU-GAN8</td></tr><tr><td rowspan=\"3\">Speaker1</td><td>SNR</td><td>21.1</td><td>21.94</td><td>21.40</td><td>17.1</td><td>18.68</td><td>17.72</td><td>14.4</td><td>14.85</td><td>13.98</td></tr><tr><td>LSD</td><td>3.2</td><td>2.24</td><td>1.63</td><td>3.6</td><td>2.34</td><td>1.92</td><td>3.4</td><td>2.92</td><td>1.95</td></tr><tr><td>MOS-LQO</td><td>1</td><td>4.54</td><td>4.54</td><td>-</td><td>3.81</td><td>3.79</td><td>-</td><td>2.97</td><td>3.21</td></tr><tr><td rowspan=\"3\">Speaker99</td><td>SNR</td><td>20.7</td><td>20.05</td><td>20.01</td><td>16.1</td><td>14.30</td><td>14.03</td><td>10.0</td><td>11.11</td><td>10.92</td></tr><tr><td>LSD</td><td>3.1</td><td>2.22</td><td>2.14</td><td>3.5</td><td>2.92</td><td>2.72</td><td>3.7</td><td>3.23</td><td>2.97</td></tr><tr><td>MOS-LQ0</td><td>1</td><td>3.68</td><td>3.75</td><td>-</td><td>2.68</td><td>2.93</td><td>1</td><td>2.44</td><td>2.69</td></tr><tr><td rowspan=\"2\">Piano</td><td>SNR</td><td>30.1</td><td>44.98</td><td>52.03</td><td>23.5</td><td>31.71</td><td>32.28</td><td>16.1</td><td>22.53</td><td>24.71</td></tr><tr><td>LSD</td><td>3.4</td><td>1.12</td><td>0.90</td><td>3.6</td><td>1.35</td><td>1.30</td><td>4.4</td><td>1.53</td><td>1.41</td></tr></table>",
+        "bbox": [
+            173,
+            127,
+            825,
+            266
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/b3fbd1019fd459509f6840ca15811bee82d917875c8d84fac3186550a9a5809c.jpg",
+        "table_caption": [
+            "Table 2: A/B test user study scores. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">Piano</td><td colspan=\"4\">Speaker99</td></tr><tr><td></td><td>#1</td><td>#2</td><td>#1</td><td>#2</td><td>#3</td><td>#4</td></tr><tr><td>MU-GAN8</td><td>9</td><td>15</td><td>14</td><td>11</td><td>15</td><td>10</td></tr><tr><td>U-net8 (baseline)</td><td>5</td><td>3</td><td>4</td><td>6</td><td>4</td><td>8</td></tr><tr><td>No preference</td><td>8</td><td>4</td><td>4</td><td>5</td><td>3</td><td>4</td></tr><tr><td colspan=\"7\">R=4:Piano #1,Speaker99 #1,#3 R = 6: Piano #2,Speaker99 #2,#4</td></tr></table>",
+        "bbox": [
+            173,
+            319,
+            460,
+            425
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/91c86180c13595bfec234e41a308137b18555001453b1184a70ac55b689def0a.jpg",
+        "table_caption": [
+            "Table 3: Speaker1 objective metrics for $M U .$ - GAN8 trained with the speech classifierbased loss, and proposed loss $( \\mathcal { L } _ { f , S V } , \\mathcal { L } _ { f } )$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">R=2</td><td colspan=\"2\">R=4</td><td colspan=\"2\">R=6</td></tr><tr><td></td><td>Lf,sV</td><td>Lf</td><td>Lf.sv</td><td>Lf</td><td>Lf.sv</td><td>Lf</td></tr><tr><td>SNR</td><td>21.28</td><td>21.40</td><td>17.57</td><td>17.72</td><td>13.85</td><td>13.98</td></tr><tr><td>LSD</td><td>1.65</td><td>1.63</td><td>1.92</td><td>1.92</td><td>1.99</td><td>1.95</td></tr><tr><td>MOS-LQO</td><td>4.54</td><td>4.54</td><td>3.67</td><td>3.79</td><td>3.24</td><td>3.21</td></tr></table>",
+        "bbox": [
+            470,
+            353,
+            823,
+            425
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            453,
+            821,
+            496
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Subjective quality analysis To evaluate the performance of $M U  – G A N$ with real listeners, we perform a randomized, single-blinded user study with 22 participants (Table 2). The study presents pairs of audio clips produced by MU-GAN8 and the best baseline model $U _ { ☉ }$ -net8, and asks participants to select a preferred clip, or “No preference.” We present two clips from Piano, and four sonically diverse clips from Speaker99. Table 2 shows that in all cases, listeners prefer audio produced by MU-GAN8 over the baseline method. ",
+        "bbox": [
+            174,
+            513,
+            823,
+            597
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In general, we observe that audio produced by MU-GAN has greater clarity compared to audio produced by the baseline networks. The quality difference is most apparent during consonant sounds, which have more high-frequency content compared to typical vowel sounds. For instance, in the phrase “Ask her to bring these things from the store,” (Figure 5, bottom row) the consonant sounds in ‘Ask,’ ‘things,’ and ‘store’ have noticeably better articulation. In contrast, audio from the best baseline, $U _ { ☉ }$ -net8, sounds relatively dull and “muffled” in comparison. Note that on some audio clips super-resolved at $R = 4 , 6$ , we observe intermittent, audible noise that is not present in the baseline reconstructions. To ensure a fair analysis, we include audio clips in the user study where this noise is apparent. Additional comments on spurious noise can be found in Appendix A.3. ",
+        "bbox": [
+            173,
+            603,
+            825,
+            728
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Comparison with classifier-based feature loss We compare the proposed unsupervised feature loss with the classifier-based loss from Germain et al. (2018) 7. Germain et al. (2018) use a VGGbased (Simonyan & Zisserman, 2014) network as a feature loss for speech denoising, and train the loss network on classification and audio tagging tasks from DCASE 2016 (Mesaros et al., 2018). Table 3 shows objective results obtained using the proposed loss $\\mathcal { L } _ { f }$ and the classifier-based loss $\\mathcal { L } _ { f , S V }$ on the Speaker1 task. Across all up-sampling ratios, the proposed unsupervised method performs on-par (and slightly better in some cases) compared to the classifier-based loss. Thus, our results suggest that using a domain-specific classifier-based loss may not provide any advantage in terms of performance. Given the issues related to training classifier models on general audio (Section 1), our method may be an attractive solution that does not compromise audio quality. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            886
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/018841657e88744424ff34773eeafb70aef86bcaa2078e54ff5cccd9d3a6ae4e.jpg",
+        "image_caption": [
+            "Figure 5: Spectrograms from the Speaker1 task at $R = 2$ (top row, Speaker 225), and Speaker99 task at $R = 4$ (bottom row, Speaker 360). (a-d) high-resolution, (b-e) super-resolved with $U _ { ☉ }$ -net8, and (c-f) super-resolved with MU-GAN8. Increased synthesis of high-frequency content by MU-GAN8 becomes more pronounced at difficult up-sampling ratios. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            99,
+            816,
+            330
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/6e72b299f68afb87af8c592a52a0656439db7a969f0c31e3ca7396afbb1c2e09.jpg",
+        "table_caption": [
+            "Table 4: MOS-LQO for ablated models on the Speaker1 task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"6\">Configuration</td></tr><tr><td>MU-GAN4 Up. Ratio -Lf-Ladu</td><td>MU-GAN4 -Ladu(+Lf)</td><td>MU-GAN4 (+Ladu+Lf)</td><td>MU-GAN8 -Lf-Ladu</td><td>MU-GAN8 -Ladu(+Lf)</td><td>MU-GAN8 (+Ladv+Lf)</td></tr><tr><td>R=2</td><td>3.53</td><td>4.54</td><td>4.54</td><td>4.54</td><td>4.54</td><td>4.54</td></tr><tr><td>R=4</td><td>3.15</td><td>3.55</td><td>3.62</td><td>3.74</td><td>3.79</td><td>3.79</td></tr><tr><td>R=6</td><td>2.78</td><td>3.07</td><td>3.12</td><td>3.15</td><td>3.17</td><td>3.21</td></tr></table>",
+        "bbox": [
+            236,
+            444,
+            754,
+            523
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ablation Analysis Table 4 shows the MOS-LQO metrics for the MU-GAN architecture with ablated model parameters. While almost all variations perform similarly well at $R = 2$ , adding depth (i.e., from $L = 4$ to $L = 8$ ) and additional loss terms improves performance on harder up-sampling ratios. Furthermore, adding the adversarial loss and unsupervised feature loss terms improve MOSLQO monotonically. For MU-GAN8, we see diminishing returns from adding the additional loss terms; much of the improvement over MU-GAN4 appears to come from the additional depth. On the other hand, adding the $\\mathcal { L } _ { f }$ and $\\mathcal { L } _ { a d v }$ losses to the MU-GAN4 variant yields significant benefits, such that its performance is comparable to that of MU-GAN8. This indicates that the feature and adversarial losses may be particularly useful to mitigate underfitting, or to decrease model size iso-performance. ",
+        "bbox": [
+            173,
+            555,
+            825,
+            694
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Receptive Field Analysis While previous works have stressed the importance of large receptive fields (van den Oord et al., 2016; Luo et al., 2016; Yu & Koltun, 2016), little work exists to quantify receptive field sizes on practical problems. We use the methods of Luo et al. (2016) to measure the effective receptive field (ERF)8 of our model on different tasks with varying architectural hyperparameters. Notably, we find that while the theoretical receptive field of our network is on the order of hundreds of milliseconds (thousands of samples), measured ERF’s are generally no wider than 100 samples. Furthermore, we find that ERF size is strongly correlated with problem difficulty, rather than architectural hyperparameters such as depth and specific loss terms. While Luo et al. (2016) found that ERF size always increased compared to the ERF at initialization, we find that ERF decreases in many cases (Figure 6). Our findings imply that there may be subtle but important tradeoffs involved with receptive field size (for instance, ERF size versus noise rejection), and suggest promising avenues for deeper investigation of architectures that rely on large receptive fields. ",
+        "bbox": [
+            173,
+            718,
+            825,
+            886
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/9a4e8a7a8743ac09b4593279b7ffd6c5c45278e0ff6a707cee8520c2fa985c50.jpg",
+        "image_caption": [
+            "Figure 6: Measured gradient magnitude at the model input and associated Gaussian fit with $M U .$ GAN4 for (a-c) $R = 2$ , 4, 6, respectively. (d) $2 \\sigma$ ERF trend, compared to ERF at initialization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            98,
+            816,
+            212
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            276,
+            318,
+            292
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work we develop methods to enable the application of GANs to audio processing, in particular with classifier-free feature losses. In addition to several new model building blocks, we show that a convolutional autoencoder can be used to implement a high-performance feature loss in the context of audio super-resolution. Demonstrated on several speech and music super-resolution tasks, we show that our architecture achieves state-of-the-art performance in both objective and subjective metrics. We perform a detailed analysis of our model, and also show that effective receptive field size may be an important property that is not well-explored. Finally, our work raises new possibilities for the design and analysis of neural network-based synthesis methods in important problem domains beyond audio processing. ",
+        "bbox": [
+            174,
+            309,
+            825,
+            434
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            457,
+            285,
+            472
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Johannes Abel and Tim Fingscheidt. Artificial speech bandwidth extension using deep neural networks for wideband spectral envelope estimation. IEEE/ACM Transactions on Audio, Speech, and Language Processing, 26(1):71–83, 2018.   \nYusuf Aytar, Carl Vondrick, and Antonio Torralba. Soundnet: Learning sound representations from unlabeled video. In NIPS, 2016.   \nPramod Bachhav, Massimiliano Todisco, Moctar Mossi, Christophe Beaugeant, and Nicholas Evans. Artificial bandwidth extension using the constant q transform. In IEEE International Conference on Acoustics, Speech and Signal Processing, pp. 5550–5554, 2017.   \nDavid Berthelot, Tom Schumm, and Luke Metz. BEGAN: boundary equilibrium generative adversarial networks. CoRR, abs/1703.10717, 2017.   \nClariNet. Clarinet: Parallel wave generation in end-to-end text-to-speech. In Submitted to International Conference on Learning Representations, 2019. URL https://openreview.net/ forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ HklY120cYm. under review.   \nJia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR, 2009.   \nEmily L Denton, Soumith Chintala, Arthur Szlam, and Rob Fergus. Deep generative image models using a laplacian pyramid of adversarial networks. In NIPS, pp. 1486–1494. 2015.   \nChris Donahue, Julian McAuley, and Miller Puckette. Synthesizing audio with generative adversarial networks. CoRR, abs/1802.04208, 2018.   \nAlexey Dosovitskiy and Thomas Brox. Generating images with perceptual similarity metrics based on deep networks. In NIPS, pp. 658–666. 2016.   \nJesse Engel, Cinjon Resnick, Adam Roberts, Sander Dieleman, Douglas Eck, Karen Simonyan, and Mohammad Norouzi. Neural audio synthesis of musical notes with wavenet autoencoders. CoRR, abs/1704.01279, 2017. ",
+        "bbox": [
+            169,
+            477,
+            826,
+            925
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Francois G Germain, Qifeng Chen, and Vladlen Koltun. Speech denoising with deep feature losses. CoRR, 2018. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "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 NIPS, pp. 2672–2680. 2014. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Augustine Gray and John Markel. Distance measures for speech processing. IEEE Transactions on Acoustics, Speech, and Signal Processing, 24(5):380–391, 1976. ",
+        "bbox": [
+            171,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. In CVPR, pp. 5967–5976, 2017. ",
+        "bbox": [
+            171,
+            229,
+            825,
+            261
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ITU-T. Perceptual evaluation of speech quality, an objective method for end-to-end speech quality assessment of narrowband telephone networks and speech codecs. ITU-T Rec. P.862, 2001. ",
+        "bbox": [
+            169,
+            268,
+            823,
+            297
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ITU-T. Mapping function for transforming p.862 raw result scores to MOS-LQO. ITU-T Rec. P.862.1, 2003. ",
+        "bbox": [
+            176,
+            306,
+            820,
+            335
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhang Jie, Xiaoqun Zhao, Jingyun Xu, and Zhang Yang. Suitability of speech quality evaluation measures in speech enhancement. In International Conference on Audio, Language and Image Processing, pp. 22–26, 2014. ",
+        "bbox": [
+            173,
+            343,
+            826,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Alexandre Alahi, and Fei-Fei Li. Perceptual losses for real-time style transfer and super-resolution. CoRR, abs/1603.08155, 2016. ",
+        "bbox": [
+            173,
+            395,
+            820,
+            425
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of gans for improved quality, stability, and variation. International Conference on Representation Learning, abs/1710.10196, 2018. ",
+        "bbox": [
+            173,
+            433,
+            825,
+            477
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational bayes. ICLR, 2014. ",
+        "bbox": [
+            174,
+            484,
+            732,
+            501
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Kuleshov, S. Zayd Enam, and Stefano Ermon. Audio super resolution using neural networks. ICLR, abs/1708.00853, 2017. ",
+        "bbox": [
+            174,
+            508,
+            823,
+            539
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Erik R. Larsen and Ronald M. Aarts. Audio Bandwidth Extension: Application of Psychoacoustics, Signal Processing and Loudspeaker Design. John Wiley & Sons, Inc., 2004. ISBN 0470858648. ",
+        "bbox": [
+            173,
+            546,
+            825,
+            577
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Ledig, Lucas Theis, Ferenc Huszar, Jose Caballero, Andrew Cunningham, Alejandro Acosta, Andrew P. Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, and Wenzhe Shi. Photorealistic single image super-resolution using a generative adversarial network. In CVPR, pp. 105–114, 2017. ",
+        "bbox": [
+            173,
+            584,
+            825,
+            641
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Honglak Lee, Peter Pham, Yan Largman, and Andrew Y. Ng. Unsupervised feature learning for audio classification using convolutional deep belief networks. In NIPS, pp. 1096–1104. 2009. ",
+        "bbox": [
+            171,
+            650,
+            823,
+            680
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bin Liu, Jianhua Tao, Zhengqi Wen, Ya Li, and Danish Bukhari. A novel method of artificial bandwidth extension using deep architecture. In INTERSPEECH, 2015. ",
+        "bbox": [
+            173,
+            688,
+            825,
+            718
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wenjie Luo, Yujia Li, Raquel Urtasun, and Richard Zemel. Understanding the effective receptive field in deep convolutional neural networks. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), NIPS, pp. 4898–4906. 2016. ",
+        "bbox": [
+            174,
+            726,
+            823,
+            768
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew L Maas, Awni Y Hannun, and Andrew Y Ng. Rectifier nonlinearities improve neural network acoustic models. In ICML, volume 30, pp. 3, 2013. ",
+        "bbox": [
+            168,
+            777,
+            823,
+            808
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Soroush Mehri, Kundan Kumar, Ishaan Gulrajani, Rithesh Kumar, Shubham Jain, Jose Sotelo, Aaron C. Courville, and Yoshua Bengio. Samplernn: An unconditional end-to-end neural audio generation model. ICLR, 2017. ",
+        "bbox": [
+            176,
+            815,
+            825,
+            858
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Annamaria Mesaros, Toni Heittola, Emmanouil Benetos, Peter Foster, Mathieu Lagrange, Tuomos Virtanen, and Mark D. Plumbley. Detection and classification of acoustic scenes and events: Outcome of the dcase 2016 challenge. IEEE/ACM Transactions on Audio, Speech, and Language Processing, 26(2):379–393, 2018. ",
+        "bbox": [
+            176,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. CoRR, abs/1411.1784, 2014. ",
+        "bbox": [
+            169,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Augustus Odena, Vincent Dumoulin, and Chris Olah. Deconvolution and checkerboard artifacts. Distill, 2016. URL http://distill.pub/2016/deconv-checkerboard. ",
+        "bbox": [
+            173,
+            147,
+            825,
+            176
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. ICLR, 2015. ",
+        "bbox": [
+            169,
+            190,
+            825,
+            220
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In Medical Image Computing and Computer-Assisted Intervention, pp. 234–241, 2015. ",
+        "bbox": [
+            173,
+            234,
+            825,
+            277
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andy M Sarroff and Michael A Casey. Musical audio synthesis using autoencoding neural nets. In International Computer Music Conference, 2014. ",
+        "bbox": [
+            171,
+            292,
+            823,
+            321
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wenzhe Shi, Jose Caballero, Ferenc Huszar, Johannes Totz, Andrew P. Aitken, Rob Bishop, Daniel ´ Rueckert, and Zehan Wang. Real-time single image and video super-resolution using an efficient sub-pixel convolutional neural network. In CVPR, pp. 1874–1883, 2016. ",
+        "bbox": [
+            174,
+            337,
+            825,
+            380
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014. ",
+        "bbox": [
+            173,
+            395,
+            823,
+            422
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Casper Kaae Sonderby, Tapani Raiko, Lars Maaloe, Soren Kaae Sonderby, and Ole Winther. Ladder variational autoencoders. In NIPS, pp. 3738–3746. 2016. ",
+        "bbox": [
+            171,
+            438,
+            825,
+            468
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jose Sotelo, Soroush Mehri, Kundan Kumar, Joo F. Santos, Kyle Kastner, Aaron Courville, and Yoshua Bengio. Char2Wav: End-to-end speech synthesis. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            482,
+            823,
+            511
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In CVPR, pp. 1–9, 2015. ",
+        "bbox": [
+            174,
+            526,
+            823,
+            569
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Keiichi Tokuda, Yoshihiko Nankaku, Tomoki Toda, Heiga Zen, Junichi Yamagishi, and Keiichiro Oura. Speech synthesis based on hidden markov models. Proceedings of the IEEE, 101(5): 1234–1252, 2013. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            626
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, ¨ Nal Kalchbrenner, Andrew W. Senior, and Koray Kavukcuoglu. Wavenet: A generative model for raw audio. CoRR, abs/1609.03499, 2016. ",
+        "bbox": [
+            174,
+            641,
+            823,
+            684
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Yazhe Li, Igor Babuschkin, Karen Simonyan, Oriol Vinyals, Koray Kavukcuoglu, George van den Driessche, Edward Lockhart, Luis Cobo, Florian Stimberg, Norman Casagrande, Dominik Grewe, Seb Noury, Sander Dieleman, Erich Elsen, Nal Kalchbrenner, Heiga Zen, Alex Graves, Helen King, Tom Walters, Dan Belov, and Demis Hassabis. Parallel WaveNet: Fast high-fidelity speech synthesis. In ICML, volume 80, pp. 3918–3926, 2018. ",
+        "bbox": [
+            173,
+            699,
+            825,
+            770
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pascal Vincent, Hugo Larochelle, Isabelle Lajoie, Yoshua Bengio, and Pierre-Antoine Manzagol. Stacked denoising autoencoders: Learning useful representations in a deep network with a local denoising criterion. JMLR, 11:3371–3408, 2010. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            828
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junichi Yamagishi. CSTR VCTK corpus. http://homepages.inf.ed.ac.uk/ jyamagis/page3/page58/page58.html. ",
+        "bbox": [
+            171,
+            842,
+            821,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fisher Yu and Vladlen Koltun. Multi-scale context aggregation by dilated convolutions. ICLR, abs/1511.07122, 2016. ",
+        "bbox": [
+            173,
+            887,
+            823,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 MODEL PARAMETERS ",
+        "bbox": [
+            176,
+            133,
+            369,
+            148
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 EVALUATION OF SUPERPIXEL LAYERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            159,
+            478,
+            174
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the impact of the superpixel layer proposed in Section 3 by comparing a baseline multiscale U-net with strided convolutions (Strided) against a multiscale U-net with superpixel layers (Super). We halve the number of convolutional kernels in each downsampling layer for Super such that the output feature map dimensions at each downsampling and upsampling layer are identical to those in Strided. Both model types are trained with the baseline $L 2$ loss for 400 epochs on the Speaker1 task. ",
+        "bbox": [
+            174,
+            185,
+            825,
+            268
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/9bdd42911c186fc68a8c014907acb59f21a32b435f74c8c7b114554dd2773087.jpg",
+        "table_caption": [
+            "Table 5: Comparison of superpixel and strided convolutional layers. ",
+            "(b) Quality metrics "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td rowspan=\"2\"></td><td colspan=\"3\">Upsampling I Ratio</td></tr><tr><td>R=2</td><td>R=4</td><td>R=6</td></tr><tr><td rowspan=\"2\">SNR</td><td>Strided</td><td>21.67</td><td>18.45</td><td>14.91</td></tr><tr><td>Super</td><td>21.75</td><td>18.41</td><td>14.89</td></tr><tr><td rowspan=\"2\">LSD</td><td>Strided</td><td>1.67</td><td>2.20</td><td>2.73</td></tr><tr><td>Super</td><td>1.70</td><td>2.08</td><td>2.39</td></tr><tr><td rowspan=\"2\">MOS-LQ0</td><td>Strided</td><td>3.57</td><td>3.13</td><td>2.71</td></tr><tr><td>Super</td><td>3.53</td><td>3.15</td><td>2.78</td></tr></table>",
+        "bbox": [
+            450,
+            328,
+            802,
+            486
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/1617e96587fad8082d26e9674bace640df0a482f724a7f3e3f63d7c44f482a76.jpg",
+        "table_caption": [
+            "(a) Training time per minibatch "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">Depth Parameter</td></tr><tr><td>L=4</td><td>L=8</td></tr><tr><td>Strided</td><td>149.8 s</td><td>195.1 s</td></tr><tr><td>Super</td><td>128.1 s</td><td>168.0 s</td></tr><tr><td>Speedup</td><td>14.5%</td><td>13.8%</td></tr></table>",
+        "bbox": [
+            196,
+            328,
+            408,
+            426
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.3 NOTE ON INTERMITTENT SPURIOUS NOISE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            511,
+            513,
+            523
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "As described in Section 4, some audio clips super-resolved at $R = 4 , 6$ exhibit intermittent, audible noise that is not present in the baseline reconstructions. We find that this noise is not inherent to our specific feature loss, and is present if we replace the unsupervised feature loss with a classifierbased feature loss. The spurious noise is also unrelated to the use of $\\mathcal { L } _ { a d v }$ , as it is present in audio generated by models trained only with $\\mathcal { L } _ { f }$ . While a deeper investigation is planned for future work, we hypothesize that such noise stems from phase ambiguity in missing high-frequency content. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            619
+        ],
+        "page_idx": 11
+    }
+]

parse/train/S1HlA-ZAZ/S1HlA-ZAZ.md

@@ -0,0 +1,356 @@
+# THE KANERVA MACHINE: A GENERATIVE DISTRIBUTED MEMORY
+
+Yan Wu, Greg Wayne, Alex Graves, Timothy Lillicrap DeepMind {yanwu,gregwayne,gravesa,countzero}@google.com
+
+# ABSTRACT
+
+We present an end-to-end trained memory system that quickly adapts to new data and generates samples like them. Inspired by Kanerva’s sparse distributed memory, it has a robust distributed reading and writing mechanism. The memory is analytically tractable, which enables optimal on-line compression via a Bayesian update-rule. We formulate it as a hierarchical conditional generative model, where memory provides a rich data-dependent prior distribution. Consequently, the top-down memory and bottom-up perception are combined to produce the code representing an observation. Empirically, we demonstrate that the adaptive memory significantly improves generative models trained on both the Omniglot and CIFAR datasets. Compared with the Differentiable Neural Computer (DNC) and its variants, our memory model has greater capacity and is significantly easier to train.
+
+# 1 INTRODUCTION
+
+Recent work in machine learning has examined a variety of novel ways to augment neural networks with fast memory stores. However, the basic problem of how to most efficiently use memory remains an open question. For instance, the slot-based external memory in models like Differentiable Neural Computers (DNCs Graves et al. (2016)) often collapses reading and writing into single slots, even though the neural network controller can in principle learn more distributed strategies. As as result, information is not shared across memory slots, and additional slots have to be recruited for new inputs, even if they are redundant with existing memories. Similarly, Matching Networks (Vinyals et al., 2016; Bartunov & Vetrov, 2016) and the Neural Episodic Controller (Pritzel et al., 2017) directly store embeddings of data. They therefore require the volume of memory to increase with the number of samples stored. In contrast, the Neural Statistician (Edwards & Storkey, 2016) summarises a dataset by averaging over their embeddings. The resulting “statistics” are conveniently small, but a large amount of information may be dropped by the averaging process, which is at odds with the desire to have large memories that can capture details of past experience.
+
+Historically developed associative memory architectures provide insight into how to design efficient memory structures that store data in overlapping representations. For example, the Hopfield Net (Hopfield, 1982) pioneered the idea of storing patterns in low-energy states in a dynamic system. This type of model is robust, but its capacity is limited by the number of recurrent connections, which is in turn constrained by the dimensionality of the input patterns. The Boltzmann Machine (Ackley et al., 1985) lifts this constraint by introducing latent variables, but at the cost of requiring slow reading and writing mechanisms (i.e. via Gibbs sampling). This issue is resolved by Kanerva’s sparse distributed memory model (Kanerva, 1988), which affords fast reads and writes and dissociates capacity from the dimensionality of input by introducing addressing into a distributed memory store whose size is independent of the dimension of the data1.
+
+In this paper, we present a conditional generative memory model inspired by Kanerva’s sparse distributed memory. We generalise Kanerva’s original model through learnable addresses and reparametrised latent variables (Rezende et al., 2014; Kingma & Welling, 2013; Bornschein et al., 2017). We solve the challenging problem of learning an effective memory writing operation by exploiting the analytic tractability of our memory model — we derive a Bayesian memory update rule that optimally trades-off preserving old content and storing new content. The resulting hierarchical generative model has a memory dependent prior that quickly adapts to new data, providing top-down knowledge in addition to bottom-up perception from the encoder to form the latent code representing data. As a generative model, our proposal provides a novel way of enriching the often over-simplified priors in VAE-like models (Rezende et al., 2016) through a adaptive memory. As a memory system, our proposal offers an effective way to learn online distributed writing which provides effective compression and storage of complex data.
+
+# 2 BACKGROUND: VARIATIONAL AUTOENCODERS
+
+Our memory architecture can be viewed as an extension of the variational autoencoder (VAE) (Rezende et al., 2014; Kingma & Welling, 2013), where the prior is derived from an adaptive memory store. A VAE has an observable variable $x$ and a latent variable $z$ . Its generative model is specified by a prior distribution $p _ { \theta } \left( z \right)$ and the conditional distribution $p _ { \theta } \left( x | z \right)$ . The intractable posterior $p _ { \theta }$ $( z | x )$ is approximated by a parameterised inference model $q _ { \phi } \left( z | x \right)$ . Throughout this paper, we use $\theta$ to represent the generative model’s parameters, and $\phi$ to represent the inference model’s parameters. All parameterised distributions are implemented as multivariate Gaussian distributions with diagonal covariance matrices, whose means and variances are outputs from neural networks as in (Rezende et al., 2014; Kingma & Welling, 2013).
+
+We assume a dataset with independently and identically distributed (iid) samples $\begin{array} { r l } { \mathcal { D } } & { { } = } \end{array}$ $\{ x _ { 1 } , \ldots , x _ { n } , \ldots , x _ { N } \}$ . The objective of training a VAE is to maximise its log-likelihood $\mathbb { E } _ { x \sim \mathcal { D } } \left[ \ln p _ { \theta } \left( x \right) \right]$ . This can be achieved by jointly optimising $\theta$ and $\phi$ for a variational lower-bound of the likelihood (omitting the expectation over all $x$ for simplicity):
+
+$$
+\mathcal { L } = \mathbb { E } _ { q _ { \phi } ( z | x ) } \left[ \ln p _ { \theta } \left( x | z \right) \right] - \operatorname { D } _ { \mathrm { K L } } \left( q _ { \phi } \left( z | x \right) \| p _ { \theta } \left( z \right) \right)
+$$
+
+where the first term can be interpreted as the negative reconstruction loss for reconstructing $x$ using its approximated posterior sample from $q _ { \phi } \left( z | x \right)$ , and the second term as a regulariser that encourages the approximated posterior to be near the prior of $z$ .
+
+# 3 THE KANERVA MACHINE
+
+To introduce our model, we use the concept of an exchangeable episode: $\begin{array} { r l } { X } & { { } = } \end{array}$ $\{ x _ { 1 } , \dotsc , x _ { t } , \dotsc , x _ { T } \} \subset { \mathcal { D } }$ is a subset of the entire dataset whose order does not matter. The objective of training is the expected conditional log-likelihood (Bornschein et al., 2017),
+
+$$
+\mathcal { I } = \int p ( X , M ) \ln p _ { \theta } \left( X \mid M \right) \mathrm { d } M \mathrm { d } X = \int p ( X ) p ( M \mid X ) \sum _ { t = 1 } ^ { T } \ln p _ { \theta } \left( x _ { t } \mid M \right) \mathrm { d } M \mathrm { d } X
+$$
+
+The equality utilises the conditional independence of $x _ { t }$ given the memory $M$ , which is equivalent to the assumption of an exchangeable episode $X$ (Aldous, 1985). We factorise the joint distribution of $p ( X , M )$ into the marginal distribution $p ( X )$ and the posterior $p ( M | X )$ , so that computing $p ( M | X )$ can be naturally interpreted as writing $X$ into the memory.
+
+We propose this scenario as a general and principled way of formulating memory-based generative models, since $\mathcal { I }$ is directly related to the mutual information $I ( X ; M )$ through $I ( { \dot { X } } ; M ) { \stackrel { \textstyle = } { = } } H ( X ) -$ $\begin{array} { r } { H ( X | M ) = H ( X ) + \int p ( X , M ) \ln p _ { \theta } \left( X | M \right) \mathrm { d } X \mathrm { d } M = H ( X ) + \mathcal { I } . } \end{array}$ As the entropy of the data $H ( X )$ is a constant, maximising $\mathcal { I }$ is equivalent to maximising $I ( X ; M )$ , the mutual information between the memory and the episode to store.
+
+# 3.1 THE GENERATIVE MODEL
+
+We write the collection of latent variables corresponding to the observed episode $X$ as $Y =$ $\{ y _ { 1 } , . . . , y _ { t } , . . . , y _ { T } \}$ and $Z = \{ z _ { 1 } , \dots , z _ { t } , \dots , z _ { T } \}$ . As illustrated in Fig. 1 (left), the joint distribution of the generative model can be factorised as
+
+$$
+p _ { \theta } \left( X , Y , Z | M \right) = \prod _ { t = 1 } ^ { T } p _ { \theta } \left( x _ { t } , y _ { t } , z _ { t } | M \right) = \prod _ { t = 1 } ^ { T } p _ { \theta } \left( x _ { t } | z _ { t } \right) p _ { \theta } \left( z _ { t } | y _ { t } , M \right) p _ { \theta } \left( y _ { t } \right)
+$$
+
+The first equality uses the conditional independence of $z _ { t } , y _ { t } , x _ { t }$ given $M$ , shown by the "plates" in Fig. 1 (left). The memory $M$ is a $K \times C$ random matrix with the matrix variate Gaussian distribution (Gupta & Nagar, 1999):
+
+$$
+p ( M ) = { \mathcal { M N } } ( R , U , V )
+$$
+
+![](images/d4411ed2a4ad6cc73cbb39e9c325ac517355a41aa46592f038190c85b2228c65.jpg)  
+Figure 1: The probabilistic graphical model for the Kanerva Machine. Left: the generative model; Central: reading inference model. Right: writing inference model; Dotted lines show approximate inference and dashed lines represent exact inference.
+
+where $R$ is a $K \times C$ matrix as the mean of $M , U$ is a $K \times K$ matrix that provides the covariance between rows of $M$ , and $V$ is a $C \times C$ matrix providing covariances between columns of $M$ . This distribution is equivalent to the multivariate Gaussian distribution of vectorised $M$ : $p ( \operatorname { v e c } ( M ) ) = \mathcal { N } ( \operatorname { v e c } ( M ) | \operatorname { \bar { v e c } } ( R ) , V \otimes U )$ , where vec $( \cdot )$ is the vectorisation operator and $\otimes$ denotes the Kronecker product. We assume independence between the columns but not the rows of $M$ , by fixing $V$ to be the identity matrix $I _ { C }$ and allow the full degree of freedom for $U$ . Since our experiments suggest the covariance between rows is useful for coordinating memory access, this setting balances simplicity and performance (Fig. 10).
+
+Accompanying $M$ are the addresses $A$ , a $K \times S$ real-value matrix that is randomly initialised and is optimised through back-propagation. To avoid degeneracy, rows of $A$ are normalised to have L2-norms of 1. The addressing variable $y _ { t }$ is used to compute the weights controlling memory access. As in VAEs, the prior $p _ { \theta } \left( y _ { t } \right)$ is an isotropic Gaussian distribution $\bar { \mathcal { N } } ( \mathbf { 0 } , \mathbf { 1 } )$ . A learned projection $b _ { t } = f ( y _ { t } )$ then transforms $y _ { t }$ into a $S \times 1$ key vector. The $K \times 1$ vector $w _ { t }$ , as weights across the rows of $M$ , is computed via the product:
+
+$$
+w _ { t } = b _ { t } \mathsf { \bar { r } } \cdot A = f ( y _ { t } ) \mathsf { \bar { r } } \cdot A
+$$
+
+The projection $f$ is implemented as a multi-layer perception (MLP), which transforms the distribution of $y _ { t }$ , as well as $w _ { t }$ , to potentially non-Gaussian distributions that may better suit addressing.
+
+The code $z _ { t }$ is a learned representation that generates samples of $x _ { t }$ through the parametrised conditional distribution $p _ { \theta } \left( x _ { t } | z _ { t } \right)$ . This distribution is tied for all $t \in \{ 1 \ldots T \}$ . Importantly, instead of the isotropic Gaussian prior, $z _ { t }$ has a memory dependent prior:
+
+$$
+p _ { \theta } ( z _ { t } | y _ { t } , M ) = \mathcal { N } \left( z _ { t } \middle | w _ { t } ^ { \textsf { T } } \cdot M , \sigma ^ { 2 } I _ { C } \right)
+$$
+
+whose mean is a linear combination of memory rows, with the noise covariance matrix fixed as an identity matrix by setting $\sigma ^ { 2 } = 1$ . This prior results in a much richer marginal distribution, because of its dependence on memory and the addressing variable $y _ { t }$ through $p _ { \theta } ( z _ { t } | M ) =$ $\begin{array} { r } { \int p _ { \theta } ( z _ { t } | y _ { t } , M ) p _ { \theta } ( y _ { t } ) \bar { \mathrm { d } } y _ { t } } \end{array}$ .
+
+In our hierarchical model, $M$ is a global latent variable for an episode that captures statistics of the entire episode (Bartunov & Vetrov, 2016; Edwards & Storkey, 2016), while the local latent variables $y _ { t }$ and $z _ { t }$ capture local statistics for data $x _ { t }$ within an episode. To generate an episode of length $T$ , we first sample $M$ once, then sample $y _ { t } , z _ { t }$ , and $x _ { t }$ sequentially for each of the $T$ samples.
+
+# 3.2 THE READING INFERENCE MODEL
+
+As illustrated in Fig. 1 (central), the approximated posterior distribution is factorised using the conditional independence:
+
+$$
+q _ { \phi } \left( Y , Z | X , M \right) = \prod _ { t = 1 } ^ { T } q _ { \phi } \left( y _ { t } , z _ { t } | x _ { t } , M \right) = \prod _ { t = 1 } ^ { T } q _ { \phi } \left( z _ { t } | x _ { t } , y _ { t } , M \right) q _ { \phi } \left( y _ { t } | x _ { t } \right)
+$$
+
+where $q _ { \phi } \left( y _ { t } | x _ { t } \right)$ is a parameterised approximate posterior distribution. The posterior distribution $q _ { \phi } \left( z _ { t } | x _ { t } , y _ { t } , M \right)$ refines the (conditional) prior distribution $p _ { \theta } ( z _ { t } | y _ { t } , M )$ with additional evidence from $x _ { t }$ . This parameterised posterior takes the concatenation of $x _ { t }$ and the mean of $p _ { \theta } ( z _ { t } | y _ { t } , M )$ (eq. 6) as input. The constant variance of $p _ { \theta } ( z _ { t } | y _ { t } , M )$ is omitted. Similar to the generative model, $q _ { \phi } \left( y _ { t } | x _ { t } \right)$ is shared for all $t \in \{ 1 \ldots T \}$ .
+
+# 3.3 THE WRITING INFERENCE MODEL
+
+A central difficulty in updating memory is the trade-off between preserving old information and writing new information. It is well known that this trade-off can be balanced optimally through Bayes’ rule MacKay (2003). From the generative model perspective (eq. 2), it is natural to interpret memory writing as inference — computing the posterior distribution of memory $p ( M | X )$ . This section considers both batch inference — directly computing $p ( M | X )$ and on-line inference — sequentially accumulating evidence from $x _ { 1 } , \ldots , x _ { T }$ .
+
+Following Fig. 1 (right), the approximated posterior distribution of memory can be written as
+
+$$
+\begin{array} { l } { q _ { \phi } \left( M | X \right) = \displaystyle \int p _ { \theta } \left( M , Y , Z | X \right) \mathrm { d } Z \mathrm { d } Y } \\ { \displaystyle \qquad = \int p _ { \theta } ( M | \{ y _ { 1 } , \dots , y _ { T } \} , \{ z _ { 1 } , \dots , z _ { T } \} ) \prod _ { t = 1 } ^ { T } q _ { \phi } ( z _ { t } | x _ { t } ) q _ { \phi } ( y _ { t } | x _ { t } ) \mathrm { d } z _ { t } \mathrm { d } y _ { t } } \\ { \displaystyle \qquad \approx p _ { \theta } \left( M | \{ y _ { 1 } , \dots , y _ { T } \} , \{ z _ { 1 } , \dots , z _ { T } \} \right) \Big | _ { y _ { t } \sim q _ { \phi } ( y _ { t } | x _ { t } ) , z _ { t } \sim q _ { \phi } ( z _ { t } | x _ { t } ) } } \end{array}
+$$
+
+The last line uses one sample of $y _ { t } , \ x _ { t }$ to approximate the intractable integral. The posterior of the addressing variable $q _ { \phi } \left( y _ { t } | x _ { t } \right)$ is the same as in section 3.2, and the posterior of code $q _ { \phi } \left( z _ { t } | x _ { t } \right)$ is a parameterised distribution. We use the short-hand $p _ { \theta }$ $_ { 9 } \left( M | Y , Z \right)$ for $p _ { \theta } \left( M | \{ y _ { 1 } , \dots , y _ { T } \} , \{ z _ { 1 } , \dots , z _ { T } \} \right)$ when $Y , Z$ are sampled as described here. We abuse notation in this section and use $Z =$ $\big ( z _ { 1 } { \boldsymbol { \mathsf { \mathsf { \mathsf { \Pi } } } } } ; \qquad \ldots , ; z _ { T } { \boldsymbol { \mathsf { \mathsf { \mathsf { \Pi } } } } } ^ { \mathsf { \mathsf { \mathsf { \mathsf { \mathsf { \mathsf { \mathsf { \Pi } } } } } } } } \big )$ as a $T \times C$ matrix with all the observations in an episode, and $W = ( w _ { 1 } \mathsf { \bar { r } } ; \dots ; w _ { T } \mathsf { \bar { r } } )$ as a $T \times K$ matrix with all corresponding weights for addressing.
+
+Given the linear Gaussian model (eq. 6), the posterior of memory $p _ { \theta } \left( M | Y , Z \right)$ is analytically tractable, and its parameters $R$ and $U$ can be updated as follows:
+
+$$
+\begin{array} { r l r l } & { \Delta  Z - W R } \\ & { \Sigma _ { c }  W U } \\ & { R  R + \Sigma _ { c } \mathbf { \bar { T } } \Sigma _ { z } ^ { - 1 } \Delta } & & { U  U - \Sigma _ { c } \mathbf { \bar { T } } \Sigma _ { z } ^ { - 1 } \Sigma _ { c } } \end{array}
+$$
+
+where $\Delta$ is the prediction error before updating the memory, $\Sigma _ { c }$ is a $T \times K$ matrix providing the cross-covariance between $Z$ and $M$ , $\Sigma _ { \xi }$ is a $T \times T$ diagonal matrix whose diagonal elements are the noise variance $\sigma ^ { 2 }$ and $\Sigma _ { z }$ is a $T \times T$ matrix that encodes the covariance for $z _ { 1 } , \dots , z _ { T }$ . This update rule is derived from applying Bayes’ rule to the linear Gaussian model (Appendix E). The prior parameters of $p ( M )$ , $R _ { 0 }$ and $U _ { 0 }$ are trained through back-propagation. Therefore, the prior of $M$ can learn the general structure of the entire dataset, while the posterior is left to adapt to features presented in a subset of data observed within a given episode.
+
+The main cost of the update rule comes from inverting $\Sigma _ { z }$ , which has a complexity of $\mathcal { O } ( T ^ { 3 } )$ . One may reduce the per-step cost via on-line updating, by performing the update rule using one sample at a time — when $X = x _ { t }$ , $\Sigma _ { z }$ is a scalar which can be inverted trivially. According to Bayes’ rule, updating using the entire episode at once is equivalent to performing the one-sample/on-line update iteratively for all observations in the episode. Similarly, one can perform intermediate updates using mini-batch with size between 1 and $T$ .
+
+Another major cost in the update rule is the storage and multiplication of the memory’s row-covariance matrix $U$ , with the complexity of $\mathcal { O } ( K ^ { 2 } )$ . Although restricting this covariance to diagonal can reduce this cost to $\mathcal O ( K )$ , our experiments suggested this covariance is useful for coordinating memory accessing (Fig. 10). Moreover, the cost of $\mathcal { O } ( K ^ { 2 } )$ is usually small, since parameters of the model are dominated by the encoder and decoder. Nevertheless, a future direction is to investigating low-rank approximation of $U$ that better balance cost and performance.
+
+# 3.4 TRAINING
+
+To train this model, we optimise a variational lower-bound of the conditional likelihood $J$ (eq. 2), which can be derived in a fashion similar to standard VAEs:
+
+$$
+\begin{array} { l } { \displaystyle \mathcal { L } = \mathbb { E } _ { q _ { \phi } ( M | X ) p ( X ) } \sum _ { t = 1 } ^ { T } \left\{ \mathbb { E } _ { q _ { \phi } ( y _ { t } , z _ { t } | x _ { t } , M ) } \left[ \ln p _ { \theta } \left( x _ { t } | z _ { t } \right) \right] \right. } \\ { \displaystyle \left. - \mathrm { D } _ { \mathrm { K L } } \left( q _ { \phi } \left( y _ { t } | x _ { t } \right) \| p _ { \theta } \left( y _ { t } \right) \right) - \mathrm { D } _ { \mathrm { K L } } \left( q _ { \phi } \left( z _ { t } | x _ { t } , y _ { t } , M \right) \| p _ { \theta } \left( z _ { t } | y _ { t } , M \right) \right) \right\} } \end{array}
+$$
+
+To maximise this lower bound, we sample $y _ { t } , z _ { t }$ from $q _ { \phi } \left( y _ { t } , z _ { t } | x _ { t } , M \right)$ to approximate the inner expectation. For computational efficiency, we use a mean-field approximation for the memory — using the mean $R$ in the place of memory samples (since directly sampling $M$ requires expensive Cholesky decomposition of the non-diagonal matrix $U$ ). Alternatively, we can further exploit the analytical tractability of the Gaussian distribution to obtain distribution-based reading and writing operations (Appendix F).
+
+Inside the bracket, the first term is the usual VAE reconstruction error. The first KL-divergence penalises complex addresses, and the second term penalises deviation of the code $z _ { t }$ from the memory-based prior. In this way, the memory learns useful representations that do not rely on complex addresses, and the bottom-up evidence only corrects top-down memory reading when necessary.
+
+# 3.5 ITERATIVE SAMPLING
+
+An important feature of Kanerva’s sparse distributed memory is its iterative reading mechanism, by which output from the model is fed back as input for several iterations. Kanerva proved that the dynamics of iterative reading will decrease errors when the initial error is within a generous range, converging to a stored memory (Kanerva, 1988). A similar iterative process is also available in our model, by repeatedly feeding-back the reconstruction $\hat { x } _ { t }$ . This Gibbs-like sampling follows the loop in Fig. 1 (central). While we cannot prove convergence, in our experiments iterative reading reliably improves denoising and sampling.
+
+To understand this process, notice that knowledge about memory is helpful in reading, which suggests using $q _ { \phi } \left( y _ { t } | x _ { t } , M \right)$ instead of $q _ { \phi } \left( y _ { t } | x _ { t } \right)$ for addressing (section 3.2). Unfortunately, training a parameterised model with the whole matrix $M$ as input can be prohibitively costly. Nevertheless, it is well-known in the coding literature that such intractable posteriors that usually arise in non-tree graphs (as in Fig. 1) can be approximated efficiently by loopy belief-propagation, as has been used in algorithms like Turbo coding (Frey & MacKay, 1998). Similarly, we believe iterative reading works in our model because $q _ { \phi } \left( y _ { t } | x _ { t } \right)$ models the local coupling between $x _ { t }$ and $y _ { t }$ well enough, so iterative sampling with the rest of the model is likely to converge to the true posterior $q _ { \phi } \left( y _ { t } | x _ { t } , M \right)$ Future research will seek to better understand this process.
+
+# 4 EXPERIMENTS
+
+Details of our model implementation are described in Appendix C. We use straightforward encoder and decoder models in order to focus on evaluating the improvements provided by an adaptive memory. In particular, we use the same model architecture for all experiments with both Omniglot and CIFAR dataset, changing only the the number of filters in the convolutional layers, memory size, and code size. We always use the on-line version of the update rule (section 3.3). The Adam optimiser was used for all training and required minimal tuning for our model (Kingma & Ba, 2014). In all experiments, we report the value of variational lower bound (eq. 12) $L$ divided by the length of episode $T$ , so the per-sample value can be compared with the likelihood from existing models.
+
+We first used the Omniglot dataset to test our model. This dataset contains images of hand-written characters with 1623 different classes and 20 examples in each class (Lake et al., 2015). This large variation creates challenges for models trying to capture the entire complex distribution. We use a $6 4 \times 1 0 0$ memory $M$ , and a smaller $6 4 \times 5 0$ address matrix $A$ . For simplicity, we always randomly sample 32 images from the entire training set to form an “episode”, and ignore the class labels. This represents a worst case scenario since the images in an episode will tend to have relatively little redundant information for compression. We use a mini-batch size of 16, and optimise the variational lower-bound (eq. 12) using Adam with learning rate $1 \times 1 0 ^ { - 4 }$ .
+
+We also tested our model with the CIFAR dataset, in which each $3 2 \times 3 2 \times 3$ real-valued colour image contains much more information than a binary omniglot pattern. Again, we discard all the label information and test our model in the unsupervised setting. To accommodate the increased complexity of CIFAR, we use convolutional coders with 32 features at each layer, use a code size of 200, and a $1 2 8 \times 2 0 0$ memory with $1 2 8 \times 5 0$ address matrix. All other settings are identical to experiments with Omniglot.
+
+# 4.1 COMPARISON WITH VAES
+
+We first use the $2 8 \times 2 8$ binary Omniglot from Burda et al. (2015) and follow the same split of 24,345 training and 8,070 test examples. We first compare the training process of our model with a baseline
+
+VAE model using the exact same encoder and decoder. Note that there is only a modest increase of parameters in the Kanerva Machine compared the VAE since the encoder and decoder dominates the model parameters.
+
+![](images/a7640fe61542670684263b9ea7459e9848a00156fc88073eea9cda8eaad6a189.jpg)  
+Figure 2: The negative variational lower bound (left), reconstruction loss (central), and KL-Divergence (right) during learning. The dip in the KL-divergence suggests that our model has learned to use the memory.
+
+Fig. 2 shows learning curves for our model along with those for the VAE trained on the Omniglot dataset. We plot 4 randomly initialised instances for each model. The training is stable and insensitive to initialisation. Fig. 2 (left) shows that our model reached a significantly lower negative variational lower-bound versus the VAE. Fig. 2 (central) and (right) further shows that the Kanerva Machine achieved better reconstruction and KL-divergence. In particular, the KL-divergence of our model “dips” sharply from about the 2000th step, implying our model learned to use the memory to induce a more informative prior. Fig. 11 confirms this: the KL-divergence for $z _ { t }$ has collapsed to near zero, showing that the top-down prior from memory $q _ { \phi } \left( z _ { t } | y _ { t } , M \right)$ provides most of the information for the code. This rich prior is achieved at the cost of an additional KL-divergence for $y _ { t }$ (Fig. 11, right) which is still much lower than the KL-divergence for $z _ { t }$ in a VAE. Similar training curves are observed for CIFAR training (Fig. 12). Gemici et al. (2017) also observed such KL-divergence dips with a memory model. They report that the reduction in KL-divergence, rather than the reduction in reconstruction loss, was particularly important for improving sample quality, which we also observed in our experiments with Omniglot and CIFAR.
+
+At the end of training, our VAE reached a negative log-likelihood (NLL) of $\leq 1 1 2 . 7$ (the lower-bound of likelihood), which is worse than the state-of-the-art unconditioned generation that is achieved by rolling out 80 steps of a DRAW model (NLL of 95.5, Rezende et al., 2016), but comparable to results with IWAE training (NLL of 103.4, Burda et al., 2015). In contrast, with the same encoder and decoders, the Kanerva Machine achieve conditional NLL of 68.3. It is not fair to directly compare our results with unconditional generative models since our model has the advantage of its memory contents. Nevertheless, the dramatic improvement of NLL demonstrates the power of incorporating an adaptive memory into generative models. Fig. 3 (left) shows examples of reconstruction at the end of training; as a signature of our model, the weights were well distributed over the memory, illustrating that patterns written into the memory were superimposed on others.
+
+![](images/1ba4e39eebfe9297d7e79c43b7a5f9b9ac9a4508dfe5cb6a919bf8403823a287.jpg)  
+Figure 3: Left: reconstruction of inputs and the weights used in reconstruction, where each bin represents the weight over one memory slot. Weights are widely distributed across memory slots. Right: denoising through iterative reading. In each panel: the first column shows the original pattern, the second column (in boxes) shows the corrupted pattern, and the following columns show the reconstruction after 1, 2 and 3 iterations.
+
+# 4.2 ONE-SHOT GENERATION
+
+We generalise “one-shot” generation from a single image (Rezende et al., 2016), or a few sample images from a limited set of classes (Edwards & Storkey, 2016; Bartunov & Vetrov, 2016), to a batch of images with many classes and samples. To better illustrate how samples are shaped by the conditioning data, in this section we use the same trained models, but test them using episodes with samples from only 2, 4 or 12 classes (omniglot characters)2. Fig. 4 compares samples from the VAE and the Kanerva Machine. While initial samples from our model (left most columns) are visually about as good as those from the VAE, the sample quality improved in consecutive iterations and the final samples clearly reflects the statistics of the conditioning patterns. Most samples did not change much after the 6th iteration, suggesting the iterative sampling had converged. Similar conditional samples from CIFAR are shown in Fig. 5. Notice that this approach, however, does not apply to VAEs, since VAEs do not have the structure we discussed in section 3.5. This is illustrated in Figure 8 by feeding back output from VAEs as input to the next iteration, which shows the sample quality did not improve after iterations.
+
+![](images/e956a39900751590a52da07813b359778c839a9848a67753f95a0e3e838470d7.jpg)  
+Figure 4: One-shot generation given a batch of examples. The first panel shows reference samples from the matched VAE. Samples from our model conditioned on 12 random examples from the specified number of classes. Conditioning examples are shown above the samples. The 5 columns show samples after 0, 2, 4, 6, and 8 iterations.
+
+![](images/65614c70c89ba0071ffe40253ff93802c1baafbec3ead3791d79d1fe42d14f93.jpg)  
+Figure 5: Comparison of samples from CIFAR. The 24 conditioning images (top-right) are randomly sampled from the entire CIFAR dataset, so they contains a mix of many classes. Samples from the matched VAE are blurred and lack meaningful local structure. On the other hand, samples from the Kanerva Machine have clear local structures, despite using the same encoder and decoder as the VAE. The 5 columns show samples after 0, 2, 4, 6, and 8 iterations.
+
+# 4.3 DENOISING AND INTERPOLATION
+
+To further examine generalisation, we input images corrupted by randomly positioned $1 2 \times 1 2$ blocks, and tested whether our model can recover the original image through iterative reading. Our model was not trained on this task, but Fig. 3 (right) shows that, over several iterations, input images can be recovered. Due to high ambiguity, some cases (e.g., the second and last) ended up producing incorrect but still reasonable patterns.
+
+The structure of our model affords interpretability of internal representations in memory. Since representations of data $x$ are obtained from a linear combination of memory slots (eq. 6), we expect linear interpolations between address weights to be meaningful. We examined interpolations by computing 2 weight vectors from two random input images, and then linearly interpolating between these two vectors. These vectors were then used to read $z _ { t }$ from memory (eq. 6), which is then decoded to produce the interpolated images. Fig. 7 in Appendix A shows that interpolating between these access weights indeed produces meaningful and smoothly changing images.
+
+![](images/d444b6eb0da9213ad80d81e1e5b94a53b4173d3cd1c3c084b68c6a1618ac343d.jpg)  
+4.4 COMPARISON WITH DIFFERENTIABLE NEURAL COMPUTERS   
+Figure 6: Left: the training curves of DNC and Kanerva machine both shows 6 instances with the best hyperparameter configuration for each model found via grid search. DNCs were more sensitive to random initilisation, slower, and plateaued with larger error. Right: the test variational lower-bounds of a DNC (dashed lines) and a Kanerva Machine as a function of different episode sizes and different sample classes.
+
+This section compares our model with the Differentiable Neural Computer (DNC, Graves et al., 2016), and a variant of it, the Least Recently Used Architecture (LRUA, Santoro et al., 2016). We test these using the same episode storage and retrieval task as in previous experiments with Omniglot data. For a fair comparison, we fit the DNC models into the same framework, as detailed in Appendix D. Fig. 6 (left) illustrates the process of training the DNC and the Kanerva Machine. The LRUA did not passed the loss level of 150, so we did not include it in the figure. The DNC reached a test loss close to 100, but was very sensitive to hyper-parameters and random initialisation: only 2 out of 6 instances with the best hyper-parameter configuration (batch size $= 1 6$ , learning rate= ${ \dot { 3 } } \times 1 0 ^ { - 4 }$ ) found by grid search reached this level. On the other hand, the Kanerva Machine was robust to these hyper-parameters, and worked well with batch sizes between 8 and 64, and learning rates between $3 \times 1 0 ^ { - 5 }$ and $3 \times 1 0 ^ { - 4 }$ . The Kanerva Machine trained fastest with batch size 16 and learning rate $1 \times 1 0 ^ { - 4 }$ and eventually converged below 70 test loss with all tested configurations. Therefore, the Kanerva Machine is significantly easier to train, thanks to principled reading and writing operations that do not depend on any model parameter.
+
+We next analysed the capacity of our model versus the DNC by examining the lower bound of then likelihood when storing and then retrieving patterns from increasingly large episodes. As above, these models are still trained with episodes containing 32 samples, but are tested on much larger episodes. We tested our model with episodes containing different numbers of classes and thus varying amounts of redundancy. Fig. 6 (right) shows both models are able to exploit this redundancy, since episodes with fewer classes (but the same number of images) have lower reconstruction losses. Overall, the Kanerva Machine generalises well to larger episodes, and maintained a clear advantage over the DNC (as measured by the variational lower-bound).
+
+# 5 DISCUSSION
+
+In this paper, we present the Kanerva Machine, a novel memory model that combines slow-learning neural networks and a fast-adapting linear Gaussian model as memory. While our architecture is inspired by Kanerva’s seminal model, we have removed the assumption of a uniform data distribution by training a generative model that flexibly learns the observed data distribution. By implementing memory as a generative model, we can retrieve unseen patterns from the memory through sampling. This phenomenon is consistent with the observation of constructive memory neuroscience experiments (Hassabis et al., 2007).
+
+Probabilistic interpretations of Kanerva’s model have been developed in previous works: Anderson (1989) explored a conditional probability interpretation of Kanerva’s sparse distributed memory, and generalised binary data to discrete data with more than two values. Abbott et al. (2013) provides an approximate Bayesian interpretation based on importance sampling. To our knowledge, our model is the first to generalise Kanerva’s memory model to continuous, non-uniform data while maintaining an analytic form of Bayesian inference. Moreover, we demonstrate its potential in modern machine learning through integration with deep neural networks.
+
+Other models have combined memory mechanisms with neural networks in a generative setting. For example, Li et al. (2016) used attention to retrieve information from a set of trainable parameters in a memory matrix. Notably, the memory in this model is not updated following learning. As a result, the memory does not quickly adapt to new data as in our model, and so is not suited to the kind of episode-based learning explored here. Bornschein et al. (2017) used discrete (categorical) random variables to address an external memory, and train the addressing mechanism, together with the rest of the generative model, though a variational objective. However, the memory in their model is populated by storing images in the form of raw pixels. Although this provides a mechanism for fast adaptation, the cost of storing raw pixels may be overwhelming for large data sets. Our model learns to to store information in a compressed form by taking advantage of statistical regularity in the images via the encoder at the perceptual level, the learned addresses, and Bayes’ rule for memory updates.
+
+Central to an effective memory model is the efficient updating of memory. While various approaches to learning such updating mechanisms have been examined recently (Graves et al., 2016; Edwards & Storkey, 2016; Santoro et al., 2016), we designed our model to employ an exact Bayes’ update-rule without compromising the flexibility and expressive power of neural networks. The compelling performance of our model and its scalable architecture suggests combining classical statistical models and neural networks may be a promising direction for novel memory models in machine learning.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Sergey Bartunov, Charles Blundell, Jörg Bornschein, Karol Gregor, Shakir Mohamed, and Benigno Uria for helpful discussions, and to thank Dillon Graham and Jascha Sohl-Dickstein for pointing out mistakes in earlier manuscripts.
+
+# REFERENCES
+
+Joshua T Abbott, Jessica B Hamrick, Thomas L Griffiths, et al. Approximating bayesian inference with a sparse distributed memory system. In Proceedings of the 35th annual conference of the cognitive science society, pp. 1686–1691, 2013.   
+David H Ackley, Geoffrey E Hinton, and Terrence J Sejnowski. A learning algorithm for boltzmann machines. Cognitive science, 9(1):147–169, 1985.   
+David J Aldous. Exchangeability and related topics. In École d’Été de Probabilités de Saint-Flour XIII—1983, pp. 1–198. Springer, 1985.   
+Charles H Anderson. A conditional probability interpretation of kanerva’s sparse distributed memory. Jet Propulsion, 1000:23–100, 1989.   
+Sergey Bartunov and Dmitry P Vetrov. Fast adaptation in generative models with generative matching networks. arXiv preprint arXiv:1612.02192, 2016.   
+Jörg Bornschein, Andriy Mnih, Daniel Zoran, and Danilo J Rezende. Variational memory addressing in generative models. arXiv preprint arXiv:1709.07116, 2017.   
+Yuri Burda, Roger Grosse, and Ruslan Salakhutdinov. Importance weighted autoencoders. arXiv preprint arXiv:1509.00519, 2015.
+
+Harrison Edwards and Amos Storkey. Towards a neural statistician. arXiv preprint arXiv:1606.02185, 2016.
+
+Brendan J Frey and David JC MacKay. A revolution: Belief propagation in graphs with cycles. In Advances in neural information processing systems, pp. 479–485, 1998.
+
+Mevlana Gemici, Chia-Chun Hung, Adam Santoro, Greg Wayne, Shakir Mohamed, Danilo J Rezende, David Amos, and Timothy Lillicrap. Generative temporal models with memory. arXiv preprint arXiv:1702.04649, 2017.
+
+Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka GrabskaBarwinska, Sergio Gómez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, et al. ´ Hybrid computing using a neural network with dynamic external memory. Nature, 538(7626): 471–476, 2016.
+
+Arjun K Gupta and Daya K Nagar. Matrix variate distributions, volume 104. CRC Press, 1999.
+
+Demis Hassabis, Dharshan Kumaran, Seralynne D Vann, and Eleanor A Maguire. Patients with hippocampal amnesia cannot imagine new experiences. Proceedings of the National Academy of Sciences, 104(5):1726–1731, 2007.
+
+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.
+
+John J Hopfield. Neural networks and physical systems with emergent collective computational abilities. Proceedings of the national academy of sciences, 79(8):2554–2558, 1982.
+
+Pentti Kanerva. Sparse distributed memory. MIT press, 1988.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. In Proceedings of the 2nd International Conference on Learning Representations (ICLR), 2013.
+
+Brenden M Lake, Ruslan Salakhutdinov, and Joshua B Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015.
+
+Chongxuan Li, Jun Zhu, and Bo Zhang. Learning to generate with memory. In International Conference on Machine Learning, pp. 1177–1186, 2016.
+
+David JC MacKay. Information theory, inference and learning algorithms. Cambridge university press, 2003.
+
+Alexander Pritzel, Benigno Uria, Sriram Srinivasan, Adrià Puigdomènech, Oriol Vinyals, Demis Hassabis, Daan Wierstra, and Charles Blundell. Neural episodic control. arXiv preprint arXiv:1703.01988, 2017.
+
+Danilo J. Rezende, Shakir Mohamed, Ivo Danihelka, Karol Gregor, and Daan Wierstra. One-shot generalization in deep generative models. In Proceedings of the 33rd International Conference on International Conference on Machine Learning - Volume 48, ICML’16, pp. 1521–1529. JMLR.org, 2016. URL http://dl.acm.org/citation.cfm?id=3045390.3045551.
+
+Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In The 31st International Conference on Machine Learning (ICML), 2014.
+
+Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy Lillicrap. Metalearning with memory-augmented neural networks. In Maria Florina Balcan and Kilian Q. Weinberger (eds.), Proceedings of The 33rd International Conference on Machine Learning, volume 48 of Proceedings of Machine Learning Research, pp. 1842–1850, New York, New York, USA, 20–22 Jun 2016. PMLR.
+
+Oriol Vinyals, Charles Blundell, Tim Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In Advances in Neural Information Processing Systems, pp. 3630–3638, 2016.
+
+# APPENDIX
+
+A EXTRA FIGURES
+
+![](images/22077009a79474ec7ca55bda0fd3419e40a3d6fd28e079323f3889937664496e.jpg)  
+Figure 7: Interpolation for Omniglot and CIFAR images. The first and last column show 2 random images from the data. Between them are linear interpolations in the space of memory accessing weights $w _ { t }$ .
+
+![](images/4486f345fd09442526e3b1f315a205da691f01b1850bb279b0e6e352ae43733a.jpg)  
+Figure 8: Iteratively sampled priors from VAE, for both Omniglot (left) and Cifar (right). In both panels, the columns show samples after 0, 2, 4, 6, 8 and 10 iterations, mirroring the procedure producing figure 4 and 5.
+
+# B SPARSE DISTRIBUTED MEMORY
+
+This section reviews Kanerva’s sparse distributed memory (Kanerva, 1988). For consistency with the rest of this paper, many of the notations are different from Kanerva’s description. In contrast to many recent models, Kanerva’s memory model is characterised by its distributed reading and writing operations. The model has two main components: a fixed table of addresses $A$ pointing to a modifiable memory $M$ . Both $A$ and $M$ have the same size of $K \times D$ , where $K$ is the number of addresses that and $D$ is the input dimensionality. Kanerva assumes all the inputs are uniform random vectors $\underline { { y } } \in \{ - 1 , 1 \} ^ { D }$ . Therefore, the fixed addresses $A _ { i }$ are uniformly randomly sampled from $\{ - 1 , 1 \} ^ { D }$ to reflect the input statistics.
+
+An input $y$ is compared with each address $A _ { k }$ in $A$ through the Hamming distance. For binary vectors $a , b \in \{ - 1 , 1 \} ^ { D }$ , the Hamming distance can be written as $\begin{array} { r } { h ( a , b ) = \frac { 1 } { 2 } ( \mathbf { \bar { \boldsymbol { D } } } - \boldsymbol { a } \cdot \boldsymbol { b } ) } \end{array}$ where $\cdot$ represents inner product between two vectors. An address $k$ is selected when the hamming distance between $x$ and $A _ { k }$ is smaller than a threshold $\tau$ , so the selection can be summarised by the binary weight vector:
+
+$$
+w _ { k } = \left\{ { \begin{array} { l l } { 1 , \quad } & { h ( x , A _ { k } ) \leqslant \tau } \\ { 0 , } & { \mathrm { o t h e r w i s e } } \end{array} } \right.
+$$
+
+During writing, a pattern $x$ is stored into $M$ by adding $M _ { k } \gets M _ { k } + w _ { k } x .$ . For reading, the memory contents pointed to by all the selected addresses are summed together to pass a threshold at 0 to produce a read out:
+
+$$
+\hat { x } = \left\{ \begin{array} { l l } { 1 , } & { ~ \sum _ { k = 1 } ^ { K } w _ { k } M _ { k } > 0 } \\ { - 1 , } & { ~ \mathrm { o t h e r w i s e } } \end{array} \right.
+$$
+
+This reading process can be iterated several times by repeatedly feeding-back the output $\hat { x }$ as input.
+
+It has been shown analytically by Kanerva that when both $K$ and $D$ are large enough, a small portion of the addresses will always be selected, thus the operations are sparse and distributed. Although an address’ content may be over-written many times, the stored vectors can be retrieved correctly. Moreover, Kanerva proved that even a significantly corrupted query can be discovered from the memory through iterative reading. However, the application of Kanerva’s model is restricted by the assumption of a uniform and binary data distribution, on which Kanerva’s analyses and bounds of performance rely (Kanerva, 1988). Unfortunately, this assumption is rarely true in practice, since real-world data typically lie on low-dimensional manifolds, and binary representation of data is less efficient in high-level neural network implementations that are heavily optimised for floating-point numbers.
+
+# C MODEL DETAILS
+
+Figure 9 shows the architecture of our model compared with a standard VAE. For all experiments, we use a convolutional encoder to convert input images into $2 C$ embedding vectors $e ( \bar { x } _ { t } )$ , where $C$ is the code size (dimension of $z _ { t }$ ). The convolutional encoder has 3 consecutive blocks, where each block is a convolutional layer with $4 \times 4$ filter with stride 2, which reduces the input dimension, followed by a basic ResNet block without bottleneck (He et al., 2016). All the convolutional layers have the same number of filters, which is either 16 or 32 depending on the dataset. The output from the blocks is flattened and linearly projected to a $2 C$ dimensional vector. The convolutional decoder mirrors this structure with transposed convolutional layers. All the “MLP” boxes in Fig. 9 are 2-layer multi-layer perceptron with ReLU non-linearity in between. We found that adding noise to the input into $q _ { \phi } \left( y _ { t } | x _ { t } \right)$ helped stabilise training, possibly by restricting the information in the addresses. The exact magnitude of the added noise matters little, and we use Gaussian noise with zero mean and standard deviation of 0.2 for all experiments. We use Bernoulli likelihood function for Omniglot dataset, and Gaussian likelihood function for CIFAR. To avoid Gaussian likelihood collapsing, we added uniform noise $\textstyle { \mathcal { U } } ( 0 , { \frac { 1 } { 2 5 6 } } )$ to CIFAR images during training.
+
+# D DNC DETAILS
+
+For a fair comparison, we wrap the differentiable neural computer (DNC) with the same interface as the Kanerva memory so that it can simply replace the memory $M$ in Fig. 9. More specifically, the DNC receives the addressing variable $y _ { t }$ with the same size and sampled the same ways as described in the main text in reading and writing stages. During writing it also receives $z _ { t }$ sampled from $q _ { \phi } \left( z _ { t } | x _ { t } \right)$ as input, by concatenating $y _ { t }$ and $z _ { t }$ together as input into the memory controller.
+
+Since DNCs do not have separated reading and writing stages, we separated this two process in our experiments: during writing, we discard the read-out from the DNC, and only keep its state as the memory; during reading, we discard the state at each step so it cannot be used for storing new information. In addition, we use a 2-layer MLP with 200 hidden neurons and ReLU nonlinearity as the controller instead of the commonly used LSTM to avoid the recurrent state being used as memory and interference with DNC’s external memory. Another issue with off-the-shelf DNC (Graves et al., 2016; Santoro et al., 2016) is that controllers may generate output bypassing the memory, which can be particularly confusing in our auto-encoding setting by simply ignoring the memory and functioning as a skip connection. We avoid this situation by removing this controller output and ensure that the DNC only reads-out from its memory. Further, to focus on the memory performance, we remove
+
+VAE
+
+![](images/81e4bc84470fadba151690e5e38dee018f2c8fb50bd2e946e92aea0a3920f6e9.jpg)
+
+generation reading writing
+
+![](images/a5597b89089504beb9260c48f0db06bf06ae4ff19c24f21ddf1c56e209ba9bd8.jpg)
+
+![](images/8834844721d58aadb5e2d46850182826b9ae5d6ca40719afe2fe02f28090d8ca.jpg)  
+Figure 9: The architecture of the VAE and the Kanerva Machine used in our experiments. conv/deconv: convolutional and transposed convolutions neural networks. MLP: multiplayer perceptron. concat: vector concatenation. The blue arrows show memory writing as exact inference.
+
+![](images/6202cd774c86d5dc91647350ecdfad782401061c6c0f80dad2b27e349754aa35.jpg)  
+Figure 10: Covariance between memory rows is important. The two curves shows the test loss (negative variational lower bound) as a function of iterations. Four models using full $K \times K$ covariance matrix $U$ are shown by red curves and four models using diagonal covariance matrix are shown in blue. All other settings for these 8 models are the same (as described in section 4). These 8 models are trained on machines with similar setup. The models using full covariance matrices were slightly slower per-iteration, but the test loss decreased far more quickly.
+
+the bottom-up stream in our model that compensates for the memory. This means directly sampling $z _ { t }$ from $p _ { \theta }$ $\upsilon _ { \theta } \left( z _ { t } | \boldsymbol { y } _ { t } , \boldsymbol { M } \right)$ , instead of $p _ { \theta } \left( z _ { t } | x _ { t } , y _ { t } , M \right)$ , for the decoder $\dot { p } _ { \theta } \left( x _ { t } | z _ { t } \right)$ , forcing the model to reconstruct solely using read-outs from the memory.
+
+![](images/ea5f146818917a868f439ba9fbe9f0825cae79e9b5737892c057571c838b6d62.jpg)  
+Figure 11: The KL-divergence between $y _ { t }$ (left) and $z _ { t }$ (right) during training.
+
+![](images/abd7e818d5da2bf5f791bb8b027e0a504827b16e2b020cc56c8034cae7bb3ea6.jpg)  
+Figure 12: The negative variational lower bound, reconstruction loss, and total KL-divergence during CIFAR training. Although the difference between the lower bound objective is smaller than that during Omniglot training, the general patterns of these curves are similar to those in Fig. 2. The relatively small difference in KL-divergence significantly influences sample quality. Notice at the time of our submission, the training is continuing and the advantage of the Kanerva Machine over the VAE is increasing.
+
+# E DERIVATION OF THE ONLINE UPDATE RULE
+
+Eq. 6 defines a linear Gaussian model. Using notations in the main paper, can write the joint distribution $p ( \operatorname { v e c } \left( Z \right) , \operatorname { v e c } ( M ) ) = { \mathcal { N } } \left( \operatorname { v e c } \left( Z \right) , \operatorname { v e c } ( M ) ; \mu _ { j } , \Sigma _ { j } \right)$ , where
+
+$$
+\begin{array} { r l } & { \mu _ { j } = \left[ \mathrm { v e c } \left( W R \right) \right] } \\ & { \Sigma _ { j } = \left[ \Sigma _ { z } \otimes I _ { C } \quad \Sigma _ { c } \otimes I _ { C } \right] } \\ & { \Sigma _ { j } = \left[ \Sigma _ { c } \mathbf { \bar { \Psi } } \otimes I _ { C } \quad U \otimes I _ { c } \right] } \end{array}
+$$
+
+We can then use the conditional formula for the Gaussian to derive the posterior distribution $p ( \operatorname { v e c } \left( M \right) | \operatorname { v e c } \left( Z \right) ) = \mathcal { N } \left( \operatorname { v e c } \left( M \right) ; \mu _ { p } , \Sigma _ { p } \right)$ , using the property Kronecker product:
+
+$$
+\begin{array} { r l } & { { \mu _ { p } } = \operatorname { v e c } \left( R \right) + { \Sigma _ { c } } ^ { \mathsf { T } } { \Sigma _ { z } } ^ { - 1 } \otimes I _ { C } ( \operatorname { v e c } \left( Z \right) - \operatorname { v e c } \left( W R \right) ) } \\ & { { \Sigma _ { p } } = U \otimes I _ { c } - { \Sigma _ { c } } ^ { \mathsf { T } } { \Sigma _ { z } } ^ { - 1 } { \Sigma _ { c } } \otimes I _ { C } } \end{array}
+$$
+
+From properties of matrix variate Gaussian distribution, the above two equations can be re-arranged to the update rule in eq. 9 to 11.
+
+# F DISTRIBUTION-BASED READING AND WRITING
+
+While the model we described in this paper works well using samples from $q _ { \phi } \left( z _ { t } | x _ { t } \right)$ for writing to the memory (section 3.3) and the mean-field approximation during reading (section 3.4), here we describe an alternative that fully exploits the analytic tractability of the Gaussian distribution. To simplify notation, we use $\psi = \{ R , U , V \}$ for all parameters of the memory.
+
+For reading, eq. 6 can be replaced with a distribution that directly depends on $\psi$ through the integral:
+
+$$
+\begin{array} { c } { { p _ { \theta } \left( z _ { t } | y _ { t } , \psi \right) = \displaystyle \int p _ { \theta } \left( z _ { t } | y _ { t } , M \right) p ( M ) \mathrm { d } M } } \\ { { = \mathcal { N } \left( z _ { t } | w _ { t } { } ^ { \mathsf { T } } R , w U w ^ { \mathsf { T } } + \sigma ^ { 2 } I _ { C } \right) } } \end{array}
+$$
+
+For writing, the distribution $\begin{array} { r } { q _ { \phi } \left( \boldsymbol { Z } \vert \boldsymbol { X } \right) = \prod _ { t = 1 } ^ { T } q _ { \phi } \left( z _ { t } \vert \boldsymbol { x } _ { t } \right) = \mathcal { N } \left( \mu _ { Q } , \boldsymbol { \Sigma } _ { Q } \right) } \end{array}$ ( $\mu _ { Q }$ and $\Sigma _ { Q }$ are functions of $X$ ) can be incorporated into the Bayes’ update rule by analytically marginalising-out $Z$ :
+
+$$
+\begin{array} { r l } & { p _ { \theta } \left( M | Y , X \right) = \displaystyle \int p _ { \theta } \left( M | Y , Z \right) q _ { \phi } \left( Z | X \right) \mathrm { d } Z } \\ & { \quad \quad \quad = \displaystyle \int \frac { p _ { \theta } \left( M \right) p _ { \theta } \left( Z | Y , M \right) } { p _ { \theta } \left( Z | Y \right) } q _ { \phi } \left( Z | X \right) \mathrm { d } Z } \\ & { \quad \quad \quad \propto p _ { \theta } \left( M \right) \displaystyle \int p _ { \theta } \left( Z | Y , M \right) q _ { \phi } \left( Z | X \right) \mathrm { d } Z } \end{array}
+$$
+
+where we used Bayes’ rule and dropped the normalising constant $p _ { \theta } \left( Z | Y \right)$ , and then replaced the equality with proportional-to accordingly. The last integral is:
+
+$$
+\begin{array} { r l } & { \displaystyle \int p _ { \theta } \left( Z \vert Y , M \right) q _ { \phi } \left( Z \vert X \right) \mathrm { d } Z = \frac { 1 } { \sqrt { \operatorname* { d e t } ( 2 \pi \Sigma _ { z ^ { \prime } } ) } } \exp \left[ - \frac { 1 } { 2 } ( \mu _ { Q } - W R ) ^ { \mathsf { T } } \Sigma _ { z ^ { \prime } } ^ { - 1 } ( \mu _ { Q } - W R ) \right] } \\ & { \quad \quad \quad \quad \cdot \displaystyle \int p ^ { \prime } ( Z ) \mathrm { d } Z } \\ & { \quad \quad \quad \quad = \mathcal { N } ( \mu _ { Q } \vert W R , \Sigma _ { z ^ { \prime } } ) } \end{array}
+$$
+
+where $\Sigma _ { z ^ { \prime } } = W U W ^ { \intercal } + \Sigma _ { \xi } + \Sigma _ { Q }$ and $p ^ { \prime } ( Z )$ is a distribution of $Z$ whose exact form is unimportant. Therefore, eq. 20 shows that the posterior distribution of $M$ is proportional to the product between the prior $p _ { \theta } \left( M \right)$ and the above likelihood term. From inspection, we can see the update rule (eq. 9 - 11) needs to be modified by replacing $\Sigma _ { z }$ with $\Sigma _ { z ^ { \prime } }$ by adding the bottom-up uncertainty $\Sigma _ { Q }$ .
+
+# G DESCRIPTION OF THE ALGORITHM
+
+# Algorithm 1 Iterative Reading
+
+<table><tr><td>Input: Memory M,a (potentially noisy) query xt, the number of iteration n Output: An estimate of the noiseless 𝑥t</td></tr><tr><td>initialisei=O</td></tr><tr><td>whilei&lt;ndo</td></tr><tr><td>sample yt ~ q(yt|xt) compute the key bt ← f(yt)</td></tr><tr><td>Compute the weights wt ←bt · A</td></tr><tr><td>read-out mean μz ← wtT · M</td></tr><tr><td>sample zt ~ q(zt|xt, Yt,M) which takes μz and xt as inputs</td></tr><tr><td>sample the new query xt ~ pe(xt|zt)</td></tr><tr><td>incrementi←i+1</td></tr><tr><td>end while</td></tr><tr><td>returnx←xt</td></tr></table>
+
+# Algorithm 2 Writing
+
+Input: Images $\{ x _ { t } \} _ { t = 1 } ^ { T }$ , Memory $M$ with parameters $R$ and $U$
+
+Output: Updated memory $M ^ { \prime }$ for each $y _ { t }$ do sample $y _ { t } \sim q _ { \phi } ( y _ { t } | x _ { t } )$ compute the key $b _ { t } \gets f ( y _ { t } )$ Compute the weights $w _ { t } \gets b _ { t } ^ { \intercal } \cdot A$ sample $z _ { t } \sim q _ { \phi } ( z _ { t } | x _ { t } )$ update parameters of $M$ $\begin{array} { r l } & { | \begin{array} { l } { \Delta \xleftarrow { } Z - W R } \end{array}  } \\ & {  \Sigma _ { c } \xleftarrow { } W U  } \\ & {  \Sigma _ { z } \xleftarrow { } W U W ^ { \intercal } + \Sigma _ { \xi }  } \\ & { R   R + \Sigma _ { c } \textbar { \Sigma } \Sigma _ { z } ^ { - 1 } \Delta  } \\ & { U   U - \Sigma _ { c } \textbar { \Sigma } \Sigma _ { z } ^ { - 1 } \Sigma _ { c }  } \end{array}$
+
+# end for
+
+return $M ^ { \prime }$ with the updated parameters $R$ and $U$

parse/train/S1HlA-ZAZ/S1HlA-ZAZ_content_list.json

@@ -0,0 +1,1868 @@
+[
+    {
+        "type": "text",
+        "text": "THE KANERVA MACHINE: A GENERATIVE DISTRIBUTED MEMORY ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            99,
+            655,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yan Wu, Greg Wayne, Alex Graves, Timothy Lillicrap DeepMind {yanwu,gregwayne,gravesa,countzero}@google.com ",
+        "bbox": [
+            184,
+            169,
+            633,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present an end-to-end trained memory system that quickly adapts to new data and generates samples like them. Inspired by Kanerva’s sparse distributed memory, it has a robust distributed reading and writing mechanism. The memory is analytically tractable, which enables optimal on-line compression via a Bayesian update-rule. We formulate it as a hierarchical conditional generative model, where memory provides a rich data-dependent prior distribution. Consequently, the top-down memory and bottom-up perception are combined to produce the code representing an observation. Empirically, we demonstrate that the adaptive memory significantly improves generative models trained on both the Omniglot and CIFAR datasets. Compared with the Differentiable Neural Computer (DNC) and its variants, our memory model has greater capacity and is significantly easier to train. ",
+        "bbox": [
+            233,
+            281,
+            764,
+            434
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            457,
+            336,
+            473
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent work in machine learning has examined a variety of novel ways to augment neural networks with fast memory stores. However, the basic problem of how to most efficiently use memory remains an open question. For instance, the slot-based external memory in models like Differentiable Neural Computers (DNCs Graves et al. (2016)) often collapses reading and writing into single slots, even though the neural network controller can in principle learn more distributed strategies. As as result, information is not shared across memory slots, and additional slots have to be recruited for new inputs, even if they are redundant with existing memories. Similarly, Matching Networks (Vinyals et al., 2016; Bartunov & Vetrov, 2016) and the Neural Episodic Controller (Pritzel et al., 2017) directly store embeddings of data. They therefore require the volume of memory to increase with the number of samples stored. In contrast, the Neural Statistician (Edwards & Storkey, 2016) summarises a dataset by averaging over their embeddings. The resulting “statistics” are conveniently small, but a large amount of information may be dropped by the averaging process, which is at odds with the desire to have large memories that can capture details of past experience. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            662
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Historically developed associative memory architectures provide insight into how to design efficient memory structures that store data in overlapping representations. For example, the Hopfield Net (Hopfield, 1982) pioneered the idea of storing patterns in low-energy states in a dynamic system. This type of model is robust, but its capacity is limited by the number of recurrent connections, which is in turn constrained by the dimensionality of the input patterns. The Boltzmann Machine (Ackley et al., 1985) lifts this constraint by introducing latent variables, but at the cost of requiring slow reading and writing mechanisms (i.e. via Gibbs sampling). This issue is resolved by Kanerva’s sparse distributed memory model (Kanerva, 1988), which affords fast reads and writes and dissociates capacity from the dimensionality of input by introducing addressing into a distributed memory store whose size is independent of the dimension of the data1. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            808
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present a conditional generative memory model inspired by Kanerva’s sparse distributed memory. We generalise Kanerva’s original model through learnable addresses and reparametrised latent variables (Rezende et al., 2014; Kingma & Welling, 2013; Bornschein et al., 2017). We solve the challenging problem of learning an effective memory writing operation by exploiting the analytic tractability of our memory model — we derive a Bayesian memory update rule that optimally trades-off preserving old content and storing new content. The resulting hierarchical generative model has a memory dependent prior that quickly adapts to new data, providing top-down knowledge in addition to bottom-up perception from the encoder to form the latent code representing data. As a generative model, our proposal provides a novel way of enriching the often over-simplified priors in VAE-like models (Rezende et al., 2016) through a adaptive memory. As a memory system, our proposal offers an effective way to learn online distributed writing which provides effective compression and storage of complex data. ",
+        "bbox": [
+            174,
+            815,
+            825,
+            886
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND: VARIATIONAL AUTOENCODERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            210,
+            599,
+            227
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our memory architecture can be viewed as an extension of the variational autoencoder (VAE) (Rezende et al., 2014; Kingma & Welling, 2013), where the prior is derived from an adaptive memory store. A VAE has an observable variable $x$ and a latent variable $z$ . Its generative model is specified by a prior distribution $p _ { \\theta } \\left( z \\right)$ and the conditional distribution $p _ { \\theta } \\left( x | z \\right)$ . The intractable posterior $p _ { \\theta }$ $( z | x )$ is approximated by a parameterised inference model $q _ { \\phi } \\left( z | x \\right)$ . Throughout this paper, we use $\\theta$ to represent the generative model’s parameters, and $\\phi$ to represent the inference model’s parameters. All parameterised distributions are implemented as multivariate Gaussian distributions with diagonal covariance matrices, whose means and variances are outputs from neural networks as in (Rezende et al., 2014; Kingma & Welling, 2013). ",
+        "bbox": [
+            173,
+            233,
+            825,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We assume a dataset with independently and identically distributed (iid) samples $\\begin{array} { r l } { \\mathcal { D } } & { { } = } \\end{array}$ $\\{ x _ { 1 } , \\ldots , x _ { n } , \\ldots , x _ { N } \\}$ . The objective of training a VAE is to maximise its log-likelihood $\\mathbb { E } _ { x \\sim \\mathcal { D } } \\left[ \\ln p _ { \\theta } \\left( x \\right) \\right]$ . This can be achieved by jointly optimising $\\theta$ and $\\phi$ for a variational lower-bound of the likelihood (omitting the expectation over all $x$ for simplicity): ",
+        "bbox": [
+            173,
+            366,
+            825,
+            422
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ff0c33b595a01418a7e68bb56506eb49c4dd3a488eff340edd4a9cc30636d575.jpg",
+        "text": "$$\n\\mathcal { L } = \\mathbb { E } _ { q _ { \\phi } ( z | x ) } \\left[ \\ln p _ { \\theta } \\left( x | z \\right) \\right] - \\operatorname { D } _ { \\mathrm { K L } } \\left( q _ { \\phi } \\left( z | x \\right) \\| p _ { \\theta } \\left( z \\right) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            426,
+            669,
+            445
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where the first term can be interpreted as the negative reconstruction loss for reconstructing $x$ using its approximated posterior sample from $q _ { \\phi } \\left( z | x \\right)$ , and the second term as a regulariser that encourages the approximated posterior to be near the prior of $z$ . ",
+        "bbox": [
+            173,
+            449,
+            826,
+            491
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 THE KANERVA MACHINE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            500,
+            416,
+            515
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To introduce our model, we use the concept of an exchangeable episode: $\\begin{array} { r l } { X } & { { } = } \\end{array}$ $\\{ x _ { 1 } , \\dotsc , x _ { t } , \\dotsc , x _ { T } \\} \\subset { \\mathcal { D } }$ is a subset of the entire dataset whose order does not matter. The objective of training is the expected conditional log-likelihood (Bornschein et al., 2017), ",
+        "bbox": [
+            174,
+            523,
+            825,
+            565
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fa9def01886b3007f0eca74aa5cb5da9b942e4367a6a07202dbc78fb18c22e7d.jpg",
+        "text": "$$\n\\mathcal { I } = \\int p ( X , M ) \\ln p _ { \\theta } \\left( X \\mid M \\right) \\mathrm { d } M \\mathrm { d } X = \\int p ( X ) p ( M \\mid X ) \\sum _ { t = 1 } ^ { T } \\ln p _ { \\theta } \\left( x _ { t } \\mid M \\right) \\mathrm { d } M \\mathrm { d } X\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            570,
+            784,
+            613
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The equality utilises the conditional independence of $x _ { t }$ given the memory $M$ , which is equivalent to the assumption of an exchangeable episode $X$ (Aldous, 1985). We factorise the joint distribution of $p ( X , M )$ into the marginal distribution $p ( X )$ and the posterior $p ( M | X )$ , so that computing $p ( M | X )$ can be naturally interpreted as writing $X$ into the memory. ",
+        "bbox": [
+            173,
+            616,
+            825,
+            674
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose this scenario as a general and principled way of formulating memory-based generative models, since $\\mathcal { I }$ is directly related to the mutual information $I ( X ; M )$ through $I ( { \\dot { X } } ; M ) { \\stackrel { \\textstyle = } { = } } H ( X ) -$ $\\begin{array} { r } { H ( X | M ) = H ( X ) + \\int p ( X , M ) \\ln p _ { \\theta } \\left( X | M \\right) \\mathrm { d } X \\mathrm { d } M = H ( X ) + \\mathcal { I } . } \\end{array}$ As the entropy of the data $H ( X )$ is a constant, maximising $\\mathcal { I }$ is equivalent to maximising $I ( X ; M )$ , the mutual information between the memory and the episode to store. ",
+        "bbox": [
+            173,
+            679,
+            825,
+            751
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 THE GENERATIVE MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            756,
+            392,
+            770
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We write the collection of latent variables corresponding to the observed episode $X$ as $Y =$ $\\{ y _ { 1 } , . . . , y _ { t } , . . . , y _ { T } \\}$ and $Z = \\{ z _ { 1 } , \\dots , z _ { t } , \\dots , z _ { T } \\}$ . As illustrated in Fig. 1 (left), the joint distribution of the generative model can be factorised as ",
+        "bbox": [
+            174,
+            775,
+            826,
+            816
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9713f0115043ec3746022eb0aa7b32f2388522c856d25b2a69b936f827fde75e.jpg",
+        "text": "$$\np _ { \\theta } \\left( X , Y , Z | M \\right) = \\prod _ { t = 1 } ^ { T } p _ { \\theta } \\left( x _ { t } , y _ { t } , z _ { t } | M \\right) = \\prod _ { t = 1 } ^ { T } p _ { \\theta } \\left( x _ { t } | z _ { t } \\right) p _ { \\theta } \\left( z _ { t } | y _ { t } , M \\right) p _ { \\theta } \\left( y _ { t } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            820,
+            754,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The first equality uses the conditional independence of $z _ { t } , y _ { t } , x _ { t }$ given $M$ , shown by the \"plates\" in Fig. 1 (left). The memory $M$ is a $K \\times C$ random matrix with the matrix variate Gaussian distribution (Gupta & Nagar, 1999): ",
+        "bbox": [
+            173,
+            867,
+            826,
+            909
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7e354b79067769f0e74d442ddc0c3016893aa432a206b29f2ce758bac383c0f0.jpg",
+        "text": "$$\np ( M ) = { \\mathcal { M N } } ( R , U , V )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            909,
+            581,
+            925
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/d4411ed2a4ad6cc73cbb39e9c325ac517355a41aa46592f038190c85b2228c65.jpg",
+        "image_caption": [
+            "Figure 1: The probabilistic graphical model for the Kanerva Machine. Left: the generative model; Central: reading inference model. Right: writing inference model; Dotted lines show approximate inference and dashed lines represent exact inference. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            362,
+            99,
+            635,
+            217
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $R$ is a $K \\times C$ matrix as the mean of $M , U$ is a $K \\times K$ matrix that provides the covariance between rows of $M$ , and $V$ is a $C \\times C$ matrix providing covariances between columns of $M$ . This distribution is equivalent to the multivariate Gaussian distribution of vectorised $M$ : $p ( \\operatorname { v e c } ( M ) ) = \\mathcal { N } ( \\operatorname { v e c } ( M ) | \\operatorname { \\bar { v e c } } ( R ) , V \\otimes U )$ , where vec $( \\cdot )$ is the vectorisation operator and $\\otimes$ denotes the Kronecker product. We assume independence between the columns but not the rows of $M$ , by fixing $V$ to be the identity matrix $I _ { C }$ and allow the full degree of freedom for $U$ . Since our experiments suggest the covariance between rows is useful for coordinating memory access, this setting balances simplicity and performance (Fig. 10). ",
+        "bbox": [
+            173,
+            303,
+            826,
+            416
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Accompanying $M$ are the addresses $A$ , a $K \\times S$ real-value matrix that is randomly initialised and is optimised through back-propagation. To avoid degeneracy, rows of $A$ are normalised to have L2-norms of 1. The addressing variable $y _ { t }$ is used to compute the weights controlling memory access. As in VAEs, the prior $p _ { \\theta } \\left( y _ { t } \\right)$ is an isotropic Gaussian distribution $\\bar { \\mathcal { N } } ( \\mathbf { 0 } , \\mathbf { 1 } )$ . A learned projection $b _ { t } = f ( y _ { t } )$ then transforms $y _ { t }$ into a $S \\times 1$ key vector. The $K \\times 1$ vector $w _ { t }$ , as weights across the rows of $M$ , is computed via the product: ",
+        "bbox": [
+            173,
+            421,
+            825,
+            506
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7e874f0d2fdaf1a0b6de38e6d17d805b5d21c782efd7bc46af4eb4ad87511de1.jpg",
+        "text": "$$\nw _ { t } = b _ { t } \\mathsf { \\bar { r } } \\cdot A = f ( y _ { t } ) \\mathsf { \\bar { r } } \\cdot A\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            511,
+            588,
+            527
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The projection $f$ is implemented as a multi-layer perception (MLP), which transforms the distribution of $y _ { t }$ , as well as $w _ { t }$ , to potentially non-Gaussian distributions that may better suit addressing. ",
+        "bbox": [
+            173,
+            532,
+            825,
+            561
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The code $z _ { t }$ is a learned representation that generates samples of $x _ { t }$ through the parametrised conditional distribution $p _ { \\theta } \\left( x _ { t } | z _ { t } \\right)$ . This distribution is tied for all $t \\in \\{ 1 \\ldots T \\}$ . Importantly, instead of the isotropic Gaussian prior, $z _ { t }$ has a memory dependent prior: ",
+        "bbox": [
+            173,
+            568,
+            823,
+            609
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/466a3367905bc867ab49b109650f77842e148963e179155e7a988a33893d78e9.jpg",
+        "text": "$$\np _ { \\theta } ( z _ { t } | y _ { t } , M ) = \\mathcal { N } \\left( z _ { t } \\middle | w _ { t } ^ { \\textsf { T } } \\cdot M , \\sigma ^ { 2 } I _ { C } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            613,
+            630,
+            633
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "whose mean is a linear combination of memory rows, with the noise covariance matrix fixed as an identity matrix by setting $\\sigma ^ { 2 } = 1$ . This prior results in a much richer marginal distribution, because of its dependence on memory and the addressing variable $y _ { t }$ through $p _ { \\theta } ( z _ { t } | M ) =$ $\\begin{array} { r } { \\int p _ { \\theta } ( z _ { t } | y _ { t } , M ) p _ { \\theta } ( y _ { t } ) \\bar { \\mathrm { d } } y _ { t } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            636,
+            825,
+            694
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In our hierarchical model, $M$ is a global latent variable for an episode that captures statistics of the entire episode (Bartunov & Vetrov, 2016; Edwards & Storkey, 2016), while the local latent variables $y _ { t }$ and $z _ { t }$ capture local statistics for data $x _ { t }$ within an episode. To generate an episode of length $T$ , we first sample $M$ once, then sample $y _ { t } , z _ { t }$ , and $x _ { t }$ sequentially for each of the $T$ samples. ",
+        "bbox": [
+            173,
+            699,
+            825,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 THE READING INFERENCE MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            761,
+            449,
+            775
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As illustrated in Fig. 1 (central), the approximated posterior distribution is factorised using the conditional independence: ",
+        "bbox": [
+            173,
+            780,
+            825,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0aaedb1ac88e357b1524ce85e963ffc58112e1b88a574bd6eb4a3a325cbb4aab.jpg",
+        "text": "$$\nq _ { \\phi } \\left( Y , Z | X , M \\right) = \\prod _ { t = 1 } ^ { T } q _ { \\phi } \\left( y _ { t } , z _ { t } | x _ { t } , M \\right) = \\prod _ { t = 1 } ^ { T } q _ { \\phi } \\left( z _ { t } | x _ { t } , y _ { t } , M \\right) q _ { \\phi } \\left( y _ { t } | x _ { t } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            813,
+            743,
+            856
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $q _ { \\phi } \\left( y _ { t } | x _ { t } \\right)$ is a parameterised approximate posterior distribution. The posterior distribution $q _ { \\phi } \\left( z _ { t } | x _ { t } , y _ { t } , M \\right)$ refines the (conditional) prior distribution $p _ { \\theta } ( z _ { t } | y _ { t } , M )$ with additional evidence from $x _ { t }$ . This parameterised posterior takes the concatenation of $x _ { t }$ and the mean of $p _ { \\theta } ( z _ { t } | y _ { t } , M )$ (eq. 6) as input. The constant variance of $p _ { \\theta } ( z _ { t } | y _ { t } , M )$ is omitted. Similar to the generative model, $q _ { \\phi } \\left( y _ { t } | x _ { t } \\right)$ is shared for all $t \\in \\{ 1 \\ldots T \\}$ . ",
+        "bbox": [
+            173,
+            859,
+            825,
+            933
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3 THE WRITING INFERENCE MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            449,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A central difficulty in updating memory is the trade-off between preserving old information and writing new information. It is well known that this trade-off can be balanced optimally through Bayes’ rule MacKay (2003). From the generative model perspective (eq. 2), it is natural to interpret memory writing as inference — computing the posterior distribution of memory $p ( M | X )$ . This section considers both batch inference — directly computing $p ( M | X )$ and on-line inference — sequentially accumulating evidence from $x _ { 1 } , \\ldots , x _ { T }$ . ",
+        "bbox": [
+            173,
+            122,
+            826,
+            207
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Following Fig. 1 (right), the approximated posterior distribution of memory can be written as ",
+        "bbox": [
+            168,
+            213,
+            782,
+            228
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cc53207f93335ebe9b75a1715b1ee507c54b5012ae32303a156157c4a1710305.jpg",
+        "text": "$$\n\\begin{array} { l } { q _ { \\phi } \\left( M | X \\right) = \\displaystyle \\int p _ { \\theta } \\left( M , Y , Z | X \\right) \\mathrm { d } Z \\mathrm { d } Y } \\\\ { \\displaystyle \\qquad = \\int p _ { \\theta } ( M | \\{ y _ { 1 } , \\dots , y _ { T } \\} , \\{ z _ { 1 } , \\dots , z _ { T } \\} ) \\prod _ { t = 1 } ^ { T } q _ { \\phi } ( z _ { t } | x _ { t } ) q _ { \\phi } ( y _ { t } | x _ { t } ) \\mathrm { d } z _ { t } \\mathrm { d } y _ { t } } \\\\ { \\displaystyle \\qquad \\approx p _ { \\theta } \\left( M | \\{ y _ { 1 } , \\dots , y _ { T } \\} , \\{ z _ { 1 } , \\dots , z _ { T } \\} \\right) \\Big | _ { y _ { t } \\sim q _ { \\phi } ( y _ { t } | x _ { t } ) , z _ { t } \\sim q _ { \\phi } ( z _ { t } | x _ { t } ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            227,
+            232,
+            769,
+            342
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The last line uses one sample of $y _ { t } , \\ x _ { t }$ to approximate the intractable integral. The posterior of the addressing variable $q _ { \\phi } \\left( y _ { t } | x _ { t } \\right)$ is the same as in section 3.2, and the posterior of code $q _ { \\phi } \\left( z _ { t } | x _ { t } \\right)$ is a parameterised distribution. We use the short-hand $p _ { \\theta }$ $_ { 9 } \\left( M | Y , Z \\right)$ for $p _ { \\theta } \\left( M | \\{ y _ { 1 } , \\dots , y _ { T } \\} , \\{ z _ { 1 } , \\dots , z _ { T } \\} \\right)$ when $Y , Z$ are sampled as described here. We abuse notation in this section and use $Z =$ $\\big ( z _ { 1 } { \\boldsymbol { \\mathsf { \\mathsf { \\mathsf { \\Pi } } } } } ; \\qquad \\ldots , ; z _ { T } { \\boldsymbol { \\mathsf { \\mathsf { \\mathsf { \\Pi } } } } } ^ { \\mathsf { \\mathsf { \\mathsf { \\mathsf { \\mathsf { \\mathsf { \\mathsf { \\Pi } } } } } } } } \\big )$ as a $T \\times C$ matrix with all the observations in an episode, and $W = ( w _ { 1 } \\mathsf { \\bar { r } } ; \\dots ; w _ { T } \\mathsf { \\bar { r } } )$ as a $T \\times K$ matrix with all corresponding weights for addressing. ",
+        "bbox": [
+            173,
+            344,
+            826,
+            429
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given the linear Gaussian model (eq. 6), the posterior of memory $p _ { \\theta } \\left( M | Y , Z \\right)$ is analytically tractable, and its parameters $R$ and $U$ can be updated as follows: ",
+        "bbox": [
+            174,
+            435,
+            823,
+            464
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5ef5fad91374e6f8c3f4207e21c4f0c91d639aa2d29bd5c9be10f36b5af1b695.jpg",
+        "text": "$$\n\\begin{array} { r l r l } & { \\Delta  Z - W R } \\\\ & { \\Sigma _ { c }  W U } \\\\ & { R  R + \\Sigma _ { c } \\mathbf { \\bar { T } } \\Sigma _ { z } ^ { - 1 } \\Delta } & & { U  U - \\Sigma _ { c } \\mathbf { \\bar { T } } \\Sigma _ { z } ^ { - 1 } \\Sigma _ { c } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            468,
+            746,
+            526
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\Delta$ is the prediction error before updating the memory, $\\Sigma _ { c }$ is a $T \\times K$ matrix providing the cross-covariance between $Z$ and $M$ , $\\Sigma _ { \\xi }$ is a $T \\times T$ diagonal matrix whose diagonal elements are the noise variance $\\sigma ^ { 2 }$ and $\\Sigma _ { z }$ is a $T \\times T$ matrix that encodes the covariance for $z _ { 1 } , \\dots , z _ { T }$ . This update rule is derived from applying Bayes’ rule to the linear Gaussian model (Appendix E). The prior parameters of $p ( M )$ , $R _ { 0 }$ and $U _ { 0 }$ are trained through back-propagation. Therefore, the prior of $M$ can learn the general structure of the entire dataset, while the posterior is left to adapt to features presented in a subset of data observed within a given episode. ",
+        "bbox": [
+            173,
+            530,
+            825,
+            628
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The main cost of the update rule comes from inverting $\\Sigma _ { z }$ , which has a complexity of $\\mathcal { O } ( T ^ { 3 } )$ . One may reduce the per-step cost via on-line updating, by performing the update rule using one sample at a time — when $X = x _ { t }$ , $\\Sigma _ { z }$ is a scalar which can be inverted trivially. According to Bayes’ rule, updating using the entire episode at once is equivalent to performing the one-sample/on-line update iteratively for all observations in the episode. Similarly, one can perform intermediate updates using mini-batch with size between 1 and $T$ . ",
+        "bbox": [
+            173,
+            635,
+            825,
+            719
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Another major cost in the update rule is the storage and multiplication of the memory’s row-covariance matrix $U$ , with the complexity of $\\mathcal { O } ( K ^ { 2 } )$ . Although restricting this covariance to diagonal can reduce this cost to $\\mathcal O ( K )$ , our experiments suggested this covariance is useful for coordinating memory accessing (Fig. 10). Moreover, the cost of $\\mathcal { O } ( K ^ { 2 } )$ is usually small, since parameters of the model are dominated by the encoder and decoder. Nevertheless, a future direction is to investigating low-rank approximation of $U$ that better balance cost and performance. ",
+        "bbox": [
+            173,
+            726,
+            825,
+            810
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            815,
+            287,
+            830
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To train this model, we optimise a variational lower-bound of the conditional likelihood $J$ (eq. 2), which can be derived in a fashion similar to standard VAEs: ",
+        "bbox": [
+            174,
+            834,
+            823,
+            863
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bb39ef57bb032c8e116360c926730df23429c0b3720a030ef78343d5a7619892.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\mathcal { L } = \\mathbb { E } _ { q _ { \\phi } ( M | X ) p ( X ) } \\sum _ { t = 1 } ^ { T } \\left\\{ \\mathbb { E } _ { q _ { \\phi } ( y _ { t } , z _ { t } | x _ { t } , M ) } \\left[ \\ln p _ { \\theta } \\left( x _ { t } | z _ { t } \\right) \\right] \\right. } \\\\ { \\displaystyle \\left. - \\mathrm { D } _ { \\mathrm { K L } } \\left( q _ { \\phi } \\left( y _ { t } | x _ { t } \\right) \\| p _ { \\theta } \\left( y _ { t } \\right) \\right) - \\mathrm { D } _ { \\mathrm { K L } } \\left( q _ { \\phi } \\left( z _ { t } | x _ { t } , y _ { t } , M \\right) \\| p _ { \\theta } \\left( z _ { t } | y _ { t } , M \\right) \\right) \\right\\} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            256,
+            866,
+            741,
+            931
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To maximise this lower bound, we sample $y _ { t } , z _ { t }$ from $q _ { \\phi } \\left( y _ { t } , z _ { t } | x _ { t } , M \\right)$ to approximate the inner expectation. For computational efficiency, we use a mean-field approximation for the memory — using the mean $R$ in the place of memory samples (since directly sampling $M$ requires expensive Cholesky decomposition of the non-diagonal matrix $U$ ). Alternatively, we can further exploit the analytical tractability of the Gaussian distribution to obtain distribution-based reading and writing operations (Appendix F). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Inside the bracket, the first term is the usual VAE reconstruction error. The first KL-divergence penalises complex addresses, and the second term penalises deviation of the code $z _ { t }$ from the memory-based prior. In this way, the memory learns useful representations that do not rely on complex addresses, and the bottom-up evidence only corrects top-down memory reading when necessary. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            263
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5 ITERATIVE SAMPLING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            270,
+            369,
+            284
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "An important feature of Kanerva’s sparse distributed memory is its iterative reading mechanism, by which output from the model is fed back as input for several iterations. Kanerva proved that the dynamics of iterative reading will decrease errors when the initial error is within a generous range, converging to a stored memory (Kanerva, 1988). A similar iterative process is also available in our model, by repeatedly feeding-back the reconstruction $\\hat { x } _ { t }$ . This Gibbs-like sampling follows the loop in Fig. 1 (central). While we cannot prove convergence, in our experiments iterative reading reliably improves denoising and sampling. ",
+        "bbox": [
+            174,
+            289,
+            825,
+            386
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To understand this process, notice that knowledge about memory is helpful in reading, which suggests using $q _ { \\phi } \\left( y _ { t } | x _ { t } , M \\right)$ instead of $q _ { \\phi } \\left( y _ { t } | x _ { t } \\right)$ for addressing (section 3.2). Unfortunately, training a parameterised model with the whole matrix $M$ as input can be prohibitively costly. Nevertheless, it is well-known in the coding literature that such intractable posteriors that usually arise in non-tree graphs (as in Fig. 1) can be approximated efficiently by loopy belief-propagation, as has been used in algorithms like Turbo coding (Frey & MacKay, 1998). Similarly, we believe iterative reading works in our model because $q _ { \\phi } \\left( y _ { t } | x _ { t } \\right)$ models the local coupling between $x _ { t }$ and $y _ { t }$ well enough, so iterative sampling with the rest of the model is likely to converge to the true posterior $q _ { \\phi } \\left( y _ { t } | x _ { t } , M \\right)$ Future research will seek to better understand this process. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            518
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            527,
+            326,
+            542
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Details of our model implementation are described in Appendix C. We use straightforward encoder and decoder models in order to focus on evaluating the improvements provided by an adaptive memory. In particular, we use the same model architecture for all experiments with both Omniglot and CIFAR dataset, changing only the the number of filters in the convolutional layers, memory size, and code size. We always use the on-line version of the update rule (section 3.3). The Adam optimiser was used for all training and required minimal tuning for our model (Kingma & Ba, 2014). In all experiments, we report the value of variational lower bound (eq. 12) $L$ divided by the length of episode $T$ , so the per-sample value can be compared with the likelihood from existing models. ",
+        "bbox": [
+            174,
+            550,
+            825,
+            662
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first used the Omniglot dataset to test our model. This dataset contains images of hand-written characters with 1623 different classes and 20 examples in each class (Lake et al., 2015). This large variation creates challenges for models trying to capture the entire complex distribution. We use a $6 4 \\times 1 0 0$ memory $M$ , and a smaller $6 4 \\times 5 0$ address matrix $A$ . For simplicity, we always randomly sample 32 images from the entire training set to form an “episode”, and ignore the class labels. This represents a worst case scenario since the images in an episode will tend to have relatively little redundant information for compression. We use a mini-batch size of 16, and optimise the variational lower-bound (eq. 12) using Adam with learning rate $1 \\times 1 0 ^ { - 4 }$ . ",
+        "bbox": [
+            174,
+            669,
+            825,
+            781
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We also tested our model with the CIFAR dataset, in which each $3 2 \\times 3 2 \\times 3$ real-valued colour image contains much more information than a binary omniglot pattern. Again, we discard all the label information and test our model in the unsupervised setting. To accommodate the increased complexity of CIFAR, we use convolutional coders with 32 features at each layer, use a code size of 200, and a $1 2 8 \\times 2 0 0$ memory with $1 2 8 \\times 5 0$ address matrix. All other settings are identical to experiments with Omniglot. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            871
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 COMPARISON WITH VAES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            877,
+            397,
+            891
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first use the $2 8 \\times 2 8$ binary Omniglot from Burda et al. (2015) and follow the same split of 24,345 training and 8,070 test examples. We first compare the training process of our model with a baseline ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "VAE model using the exact same encoder and decoder. Note that there is only a modest increase of parameters in the Kanerva Machine compared the VAE since the encoder and decoder dominates the model parameters. ",
+        "bbox": [
+            176,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/a7640fe61542670684263b9ea7459e9848a00156fc88073eea9cda8eaad6a189.jpg",
+        "image_caption": [
+            "Figure 2: The negative variational lower bound (left), reconstruction loss (central), and KL-Divergence (right) during learning. The dip in the KL-divergence suggests that our model has learned to use the memory. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            161,
+            810,
+            273
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Fig. 2 shows learning curves for our model along with those for the VAE trained on the Omniglot dataset. We plot 4 randomly initialised instances for each model. The training is stable and insensitive to initialisation. Fig. 2 (left) shows that our model reached a significantly lower negative variational lower-bound versus the VAE. Fig. 2 (central) and (right) further shows that the Kanerva Machine achieved better reconstruction and KL-divergence. In particular, the KL-divergence of our model “dips” sharply from about the 2000th step, implying our model learned to use the memory to induce a more informative prior. Fig. 11 confirms this: the KL-divergence for $z _ { t }$ has collapsed to near zero, showing that the top-down prior from memory $q _ { \\phi } \\left( z _ { t } | y _ { t } , M \\right)$ provides most of the information for the code. This rich prior is achieved at the cost of an additional KL-divergence for $y _ { t }$ (Fig. 11, right) which is still much lower than the KL-divergence for $z _ { t }$ in a VAE. Similar training curves are observed for CIFAR training (Fig. 12). Gemici et al. (2017) also observed such KL-divergence dips with a memory model. They report that the reduction in KL-divergence, rather than the reduction in reconstruction loss, was particularly important for improving sample quality, which we also observed in our experiments with Omniglot and CIFAR. ",
+        "bbox": [
+            173,
+            348,
+            825,
+            542
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "At the end of training, our VAE reached a negative log-likelihood (NLL) of $\\leq 1 1 2 . 7$ (the lower-bound of likelihood), which is worse than the state-of-the-art unconditioned generation that is achieved by rolling out 80 steps of a DRAW model (NLL of 95.5, Rezende et al., 2016), but comparable to results with IWAE training (NLL of 103.4, Burda et al., 2015). In contrast, with the same encoder and decoders, the Kanerva Machine achieve conditional NLL of 68.3. It is not fair to directly compare our results with unconditional generative models since our model has the advantage of its memory contents. Nevertheless, the dramatic improvement of NLL demonstrates the power of incorporating an adaptive memory into generative models. Fig. 3 (left) shows examples of reconstruction at the end of training; as a signature of our model, the weights were well distributed over the memory, illustrating that patterns written into the memory were superimposed on others. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            689
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/1ba4e39eebfe9297d7e79c43b7a5f9b9ac9a4508dfe5cb6a919bf8403823a287.jpg",
+        "image_caption": [
+            "Figure 3: Left: reconstruction of inputs and the weights used in reconstruction, where each bin represents the weight over one memory slot. Weights are widely distributed across memory slots. Right: denoising through iterative reading. In each panel: the first column shows the original pattern, the second column (in boxes) shows the corrupted pattern, and the following columns show the reconstruction after 1, 2 and 3 iterations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            699,
+            818,
+            779
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 ONE-SHOT GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            877,
+            385,
+            890
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We generalise “one-shot” generation from a single image (Rezende et al., 2016), or a few sample images from a limited set of classes (Edwards & Storkey, 2016; Bartunov & Vetrov, 2016), to a batch of images with many classes and samples. To better illustrate how samples are shaped by the conditioning data, in this section we use the same trained models, but test them using episodes with samples from only 2, 4 or 12 classes (omniglot characters)2. Fig. 4 compares samples from the VAE and the Kanerva Machine. While initial samples from our model (left most columns) are visually about as good as those from the VAE, the sample quality improved in consecutive iterations and the final samples clearly reflects the statistics of the conditioning patterns. Most samples did not change much after the 6th iteration, suggesting the iterative sampling had converged. Similar conditional samples from CIFAR are shown in Fig. 5. Notice that this approach, however, does not apply to VAEs, since VAEs do not have the structure we discussed in section 3.5. This is illustrated in Figure 8 by feeding back output from VAEs as input to the next iteration, which shows the sample quality did not improve after iterations. ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/e956a39900751590a52da07813b359778c839a9848a67753f95a0e3e838470d7.jpg",
+        "image_caption": [
+            "Figure 4: One-shot generation given a batch of examples. The first panel shows reference samples from the matched VAE. Samples from our model conditioned on 12 random examples from the specified number of classes. Conditioning examples are shown above the samples. The 5 columns show samples after 0, 2, 4, 6, and 8 iterations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            272,
+            267,
+            727,
+            469
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/65614c70c89ba0071ffe40253ff93802c1baafbec3ead3791d79d1fe42d14f93.jpg",
+        "image_caption": [
+            "Figure 5: Comparison of samples from CIFAR. The 24 conditioning images (top-right) are randomly sampled from the entire CIFAR dataset, so they contains a mix of many classes. Samples from the matched VAE are blurred and lack meaningful local structure. On the other hand, samples from the Kanerva Machine have clear local structures, despite using the same encoder and decoder as the VAE. The 5 columns show samples after 0, 2, 4, 6, and 8 iterations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            568,
+            808,
+            707
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 DENOISING AND INTERPOLATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            813,
+            444,
+            827
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To further examine generalisation, we input images corrupted by randomly positioned $1 2 \\times 1 2$ blocks, and tested whether our model can recover the original image through iterative reading. Our model was not trained on this task, but Fig. 3 (right) shows that, over several iterations, input images can be recovered. Due to high ambiguity, some cases (e.g., the second and last) ended up producing incorrect but still reasonable patterns. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            873
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The structure of our model affords interpretability of internal representations in memory. Since representations of data $x$ are obtained from a linear combination of memory slots (eq. 6), we expect linear interpolations between address weights to be meaningful. We examined interpolations by computing 2 weight vectors from two random input images, and then linearly interpolating between these two vectors. These vectors were then used to read $z _ { t }$ from memory (eq. 6), which is then decoded to produce the interpolated images. Fig. 7 in Appendix A shows that interpolating between these access weights indeed produces meaningful and smoothly changing images. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            236
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/d444b6eb0da9213ad80d81e1e5b94a53b4173d3cd1c3c084b68c6a1618ac343d.jpg",
+        "image_caption": [
+            "4.4 COMPARISON WITH DIFFERENTIABLE NEURAL COMPUTERS ",
+            "Figure 6: Left: the training curves of DNC and Kanerva machine both shows 6 instances with the best hyperparameter configuration for each model found via grid search. DNCs were more sensitive to random initilisation, slower, and plateaued with larger error. Right: the test variational lower-bounds of a DNC (dashed lines) and a Kanerva Machine as a function of different episode sizes and different sample classes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            268,
+            758,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This section compares our model with the Differentiable Neural Computer (DNC, Graves et al., 2016), and a variant of it, the Least Recently Used Architecture (LRUA, Santoro et al., 2016). We test these using the same episode storage and retrieval task as in previous experiments with Omniglot data. For a fair comparison, we fit the DNC models into the same framework, as detailed in Appendix D. Fig. 6 (left) illustrates the process of training the DNC and the Kanerva Machine. The LRUA did not passed the loss level of 150, so we did not include it in the figure. The DNC reached a test loss close to 100, but was very sensitive to hyper-parameters and random initialisation: only 2 out of 6 instances with the best hyper-parameter configuration (batch size $= 1 6$ , learning rate= ${ \\dot { 3 } } \\times 1 0 ^ { - 4 }$ ) found by grid search reached this level. On the other hand, the Kanerva Machine was robust to these hyper-parameters, and worked well with batch sizes between 8 and 64, and learning rates between $3 \\times 1 0 ^ { - 5 }$ and $3 \\times 1 0 ^ { - 4 }$ . The Kanerva Machine trained fastest with batch size 16 and learning rate $1 \\times 1 0 ^ { - 4 }$ and eventually converged below 70 test loss with all tested configurations. Therefore, the Kanerva Machine is significantly easier to train, thanks to principled reading and writing operations that do not depend on any model parameter. ",
+        "bbox": [
+            173,
+            534,
+            825,
+            728
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We next analysed the capacity of our model versus the DNC by examining the lower bound of then likelihood when storing and then retrieving patterns from increasingly large episodes. As above, these models are still trained with episodes containing 32 samples, but are tested on much larger episodes. We tested our model with episodes containing different numbers of classes and thus varying amounts of redundancy. Fig. 6 (right) shows both models are able to exploit this redundancy, since episodes with fewer classes (but the same number of images) have lower reconstruction losses. Overall, the Kanerva Machine generalises well to larger episodes, and maintained a clear advantage over the DNC (as measured by the variational lower-bound). ",
+        "bbox": [
+            174,
+            734,
+            825,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            857,
+            312,
+            873
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present the Kanerva Machine, a novel memory model that combines slow-learning neural networks and a fast-adapting linear Gaussian model as memory. While our architecture is inspired by Kanerva’s seminal model, we have removed the assumption of a uniform data distribution by training a generative model that flexibly learns the observed data distribution. By implementing memory as a generative model, we can retrieve unseen patterns from the memory through sampling. This phenomenon is consistent with the observation of constructive memory neuroscience experiments (Hassabis et al., 2007). ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Probabilistic interpretations of Kanerva’s model have been developed in previous works: Anderson (1989) explored a conditional probability interpretation of Kanerva’s sparse distributed memory, and generalised binary data to discrete data with more than two values. Abbott et al. (2013) provides an approximate Bayesian interpretation based on importance sampling. To our knowledge, our model is the first to generalise Kanerva’s memory model to continuous, non-uniform data while maintaining an analytic form of Bayesian inference. Moreover, we demonstrate its potential in modern machine learning through integration with deep neural networks. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            263
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Other models have combined memory mechanisms with neural networks in a generative setting. For example, Li et al. (2016) used attention to retrieve information from a set of trainable parameters in a memory matrix. Notably, the memory in this model is not updated following learning. As a result, the memory does not quickly adapt to new data as in our model, and so is not suited to the kind of episode-based learning explored here. Bornschein et al. (2017) used discrete (categorical) random variables to address an external memory, and train the addressing mechanism, together with the rest of the generative model, though a variational objective. However, the memory in their model is populated by storing images in the form of raw pixels. Although this provides a mechanism for fast adaptation, the cost of storing raw pixels may be overwhelming for large data sets. Our model learns to to store information in a compressed form by taking advantage of statistical regularity in the images via the encoder at the perceptual level, the learned addresses, and Bayes’ rule for memory updates. ",
+        "bbox": [
+            174,
+            271,
+            825,
+            438
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Central to an effective memory model is the efficient updating of memory. While various approaches to learning such updating mechanisms have been examined recently (Graves et al., 2016; Edwards & Storkey, 2016; Santoro et al., 2016), we designed our model to employ an exact Bayes’ update-rule without compromising the flexibility and expressive power of neural networks. The compelling performance of our model and its scalable architecture suggests combining classical statistical models and neural networks may be a promising direction for novel memory models in machine learning. ",
+        "bbox": [
+            174,
+            444,
+            825,
+            527
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            545,
+            326,
+            558
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Sergey Bartunov, Charles Blundell, Jörg Bornschein, Karol Gregor, Shakir Mohamed, and Benigno Uria for helpful discussions, and to thank Dillon Graham and Jascha Sohl-Dickstein for pointing out mistakes in earlier manuscripts. ",
+        "bbox": [
+            176,
+            568,
+            825,
+            609
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            631,
+            285,
+            646
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joshua T Abbott, Jessica B Hamrick, Thomas L Griffiths, et al. Approximating bayesian inference with a sparse distributed memory system. In Proceedings of the 35th annual conference of the cognitive science society, pp. 1686–1691, 2013.   \nDavid H Ackley, Geoffrey E Hinton, and Terrence J Sejnowski. A learning algorithm for boltzmann machines. Cognitive science, 9(1):147–169, 1985.   \nDavid J Aldous. Exchangeability and related topics. In École d’Été de Probabilités de Saint-Flour XIII—1983, pp. 1–198. Springer, 1985.   \nCharles H Anderson. A conditional probability interpretation of kanerva’s sparse distributed memory. Jet Propulsion, 1000:23–100, 1989.   \nSergey Bartunov and Dmitry P Vetrov. Fast adaptation in generative models with generative matching networks. arXiv preprint arXiv:1612.02192, 2016.   \nJörg Bornschein, Andriy Mnih, Daniel Zoran, and Danilo J Rezende. Variational memory addressing in generative models. arXiv preprint arXiv:1709.07116, 2017.   \nYuri Burda, Roger Grosse, and Ruslan Salakhutdinov. Importance weighted autoencoders. arXiv preprint arXiv:1509.00519, 2015. ",
+        "bbox": [
+            171,
+            654,
+            826,
+            925
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Harrison Edwards and Amos Storkey. Towards a neural statistician. arXiv preprint arXiv:1606.02185, 2016. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Brendan J Frey and David JC MacKay. A revolution: Belief propagation in graphs with cycles. In Advances in neural information processing systems, pp. 479–485, 1998. ",
+        "bbox": [
+            171,
+            140,
+            825,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mevlana Gemici, Chia-Chun Hung, Adam Santoro, Greg Wayne, Shakir Mohamed, Danilo J Rezende, David Amos, and Timothy Lillicrap. Generative temporal models with memory. arXiv preprint arXiv:1702.04649, 2017. ",
+        "bbox": [
+            173,
+            175,
+            823,
+            218
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka GrabskaBarwinska, Sergio Gómez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, et al. ´ Hybrid computing using a neural network with dynamic external memory. Nature, 538(7626): 471–476, 2016. ",
+        "bbox": [
+            173,
+            224,
+            826,
+            281
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arjun K Gupta and Daya K Nagar. Matrix variate distributions, volume 104. CRC Press, 1999. ",
+        "bbox": [
+            173,
+            289,
+            800,
+            305
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Demis Hassabis, Dharshan Kumaran, Seralynne D Vann, and Eleanor A Maguire. Patients with hippocampal amnesia cannot imagine new experiences. Proceedings of the National Academy of Sciences, 104(5):1726–1731, 2007. ",
+        "bbox": [
+            174,
+            311,
+            826,
+            354
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            174,
+            361,
+            826,
+            404
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John J Hopfield. Neural networks and physical systems with emergent collective computational abilities. Proceedings of the national academy of sciences, 79(8):2554–2558, 1982. ",
+        "bbox": [
+            173,
+            411,
+            825,
+            440
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pentti Kanerva. Sparse distributed memory. MIT press, 1988. ",
+        "bbox": [
+            173,
+            446,
+            581,
+            463
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            469,
+            825,
+            500
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational bayes. In Proceedings of the 2nd International Conference on Learning Representations (ICLR), 2013. ",
+        "bbox": [
+            173,
+            506,
+            823,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Brenden M Lake, Ruslan Salakhutdinov, and Joshua B Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015. ",
+        "bbox": [
+            173,
+            542,
+            823,
+            571
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chongxuan Li, Jun Zhu, and Bo Zhang. Learning to generate with memory. In International Conference on Machine Learning, pp. 1177–1186, 2016. ",
+        "bbox": [
+            173,
+            579,
+            823,
+            608
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David JC MacKay. Information theory, inference and learning algorithms. Cambridge university press, 2003. ",
+        "bbox": [
+            171,
+            614,
+            823,
+            643
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexander Pritzel, Benigno Uria, Sriram Srinivasan, Adrià Puigdomènech, Oriol Vinyals, Demis Hassabis, Daan Wierstra, and Charles Blundell. Neural episodic control. arXiv preprint arXiv:1703.01988, 2017. ",
+        "bbox": [
+            174,
+            651,
+            823,
+            694
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danilo J. Rezende, Shakir Mohamed, Ivo Danihelka, Karol Gregor, and Daan Wierstra. One-shot generalization in deep generative models. In Proceedings of the 33rd International Conference on International Conference on Machine Learning - Volume 48, ICML’16, pp. 1521–1529. JMLR.org, 2016. URL http://dl.acm.org/citation.cfm?id=3045390.3045551. ",
+        "bbox": [
+            173,
+            700,
+            825,
+            758
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In The 31st International Conference on Machine Learning (ICML), 2014. ",
+        "bbox": [
+            176,
+            765,
+            823,
+            808
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy Lillicrap. Metalearning with memory-augmented neural networks. In Maria Florina Balcan and Kilian Q. Weinberger (eds.), Proceedings of The 33rd International Conference on Machine Learning, volume 48 of Proceedings of Machine Learning Research, pp. 1842–1850, New York, New York, USA, 20–22 Jun 2016. PMLR. ",
+        "bbox": [
+            173,
+            814,
+            825,
+            885
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Charles Blundell, Tim Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In Advances in Neural Information Processing Systems, pp. 3630–3638, 2016. ",
+        "bbox": [
+            173,
+            892,
+            823,
+            921
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            290,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A EXTRA FIGURES ",
+        "bbox": [
+            176,
+            140,
+            346,
+            156
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/22077009a79474ec7ca55bda0fd3419e40a3d6fd28e079323f3889937664496e.jpg",
+        "image_caption": [
+            "Figure 7: Interpolation for Omniglot and CIFAR images. The first and last column show 2 random images from the data. Between them are linear interpolations in the space of memory accessing weights $w _ { t }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            305,
+            179,
+            692,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/4486f345fd09442526e3b1f315a205da691f01b1850bb279b0e6e352ae43733a.jpg",
+        "image_caption": [
+            "Figure 8: Iteratively sampled priors from VAE, for both Omniglot (left) and Cifar (right). In both panels, the columns show samples after 0, 2, 4, 6, 8 and 10 iterations, mirroring the procedure producing figure 4 and 5. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            302,
+            454,
+            691,
+            631
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B SPARSE DISTRIBUTED MEMORY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            729,
+            475,
+            746
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This section reviews Kanerva’s sparse distributed memory (Kanerva, 1988). For consistency with the rest of this paper, many of the notations are different from Kanerva’s description. In contrast to many recent models, Kanerva’s memory model is characterised by its distributed reading and writing operations. The model has two main components: a fixed table of addresses $A$ pointing to a modifiable memory $M$ . Both $A$ and $M$ have the same size of $K \\times D$ , where $K$ is the number of addresses that and $D$ is the input dimensionality. Kanerva assumes all the inputs are uniform random vectors $\\underline { { y } } \\in \\{ - 1 , 1 \\} ^ { D }$ . Therefore, the fixed addresses $A _ { i }$ are uniformly randomly sampled from $\\{ - 1 , 1 \\} ^ { D }$ to reflect the input statistics. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            875
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "An input $y$ is compared with each address $A _ { k }$ in $A$ through the Hamming distance. For binary vectors $a , b \\in \\{ - 1 , 1 \\} ^ { D }$ , the Hamming distance can be written as $\\begin{array} { r } { h ( a , b ) = \\frac { 1 } { 2 } ( \\mathbf { \\bar { \\boldsymbol { D } } } - \\boldsymbol { a } \\cdot \\boldsymbol { b } ) } \\end{array}$ where $\\cdot$ represents inner product between two vectors. An address $k$ is selected when the hamming distance between $x$ and $A _ { k }$ is smaller than a threshold $\\tau$ , so the selection can be summarised by the binary weight vector: ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            825,
+            119
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9ad1ee0766e244b75cab8041c6bc770cba9f7c9e55fbec5988f837f3ca4c9a41.jpg",
+        "text": "$$\nw _ { k } = \\left\\{ { \\begin{array} { l l } { 1 , \\quad } & { h ( x , A _ { k } ) \\leqslant \\tau } \\\\ { 0 , } & { \\mathrm { o t h e r w i s e } } \\end{array} } \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            128,
+            588,
+            164
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "During writing, a pattern $x$ is stored into $M$ by adding $M _ { k } \\gets M _ { k } + w _ { k } x .$ . For reading, the memory contents pointed to by all the selected addresses are summed together to pass a threshold at 0 to produce a read out: ",
+        "bbox": [
+            176,
+            166,
+            825,
+            207
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a40a0661b8b0ba140f5822022f867bfe1c3f24895db962c8dc6e645edd9fb93a.jpg",
+        "text": "$$\n\\hat { x } = \\left\\{ \\begin{array} { l l } { 1 , } & { ~ \\sum _ { k = 1 } ^ { K } w _ { k } M _ { k } > 0 } \\\\ { - 1 , } & { ~ \\mathrm { o t h e r w i s e } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            205,
+            598,
+            248
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "This reading process can be iterated several times by repeatedly feeding-back the output $\\hat { x }$ as input. ",
+        "bbox": [
+            174,
+            250,
+            821,
+            265
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "It has been shown analytically by Kanerva that when both $K$ and $D$ are large enough, a small portion of the addresses will always be selected, thus the operations are sparse and distributed. Although an address’ content may be over-written many times, the stored vectors can be retrieved correctly. Moreover, Kanerva proved that even a significantly corrupted query can be discovered from the memory through iterative reading. However, the application of Kanerva’s model is restricted by the assumption of a uniform and binary data distribution, on which Kanerva’s analyses and bounds of performance rely (Kanerva, 1988). Unfortunately, this assumption is rarely true in practice, since real-world data typically lie on low-dimensional manifolds, and binary representation of data is less efficient in high-level neural network implementations that are heavily optimised for floating-point numbers. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            410
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C MODEL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            430,
+            348,
+            446
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Figure 9 shows the architecture of our model compared with a standard VAE. For all experiments, we use a convolutional encoder to convert input images into $2 C$ embedding vectors $e ( \\bar { x } _ { t } )$ , where $C$ is the code size (dimension of $z _ { t }$ ). The convolutional encoder has 3 consecutive blocks, where each block is a convolutional layer with $4 \\times 4$ filter with stride 2, which reduces the input dimension, followed by a basic ResNet block without bottleneck (He et al., 2016). All the convolutional layers have the same number of filters, which is either 16 or 32 depending on the dataset. The output from the blocks is flattened and linearly projected to a $2 C$ dimensional vector. The convolutional decoder mirrors this structure with transposed convolutional layers. All the “MLP” boxes in Fig. 9 are 2-layer multi-layer perceptron with ReLU non-linearity in between. We found that adding noise to the input into $q _ { \\phi } \\left( y _ { t } | x _ { t } \\right)$ helped stabilise training, possibly by restricting the information in the addresses. The exact magnitude of the added noise matters little, and we use Gaussian noise with zero mean and standard deviation of 0.2 for all experiments. We use Bernoulli likelihood function for Omniglot dataset, and Gaussian likelihood function for CIFAR. To avoid Gaussian likelihood collapsing, we added uniform noise $\\textstyle { \\mathcal { U } } ( 0 , { \\frac { 1 } { 2 5 6 } } )$ to CIFAR images during training. ",
+        "bbox": [
+            173,
+            462,
+            825,
+            657
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D DNC DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            676,
+            330,
+            693
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For a fair comparison, we wrap the differentiable neural computer (DNC) with the same interface as the Kanerva memory so that it can simply replace the memory $M$ in Fig. 9. More specifically, the DNC receives the addressing variable $y _ { t }$ with the same size and sampled the same ways as described in the main text in reading and writing stages. During writing it also receives $z _ { t }$ sampled from $q _ { \\phi } \\left( z _ { t } | x _ { t } \\right)$ as input, by concatenating $y _ { t }$ and $z _ { t }$ together as input into the memory controller. ",
+        "bbox": [
+            174,
+            708,
+            823,
+            779
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Since DNCs do not have separated reading and writing stages, we separated this two process in our experiments: during writing, we discard the read-out from the DNC, and only keep its state as the memory; during reading, we discard the state at each step so it cannot be used for storing new information. In addition, we use a 2-layer MLP with 200 hidden neurons and ReLU nonlinearity as the controller instead of the commonly used LSTM to avoid the recurrent state being used as memory and interference with DNC’s external memory. Another issue with off-the-shelf DNC (Graves et al., 2016; Santoro et al., 2016) is that controllers may generate output bypassing the memory, which can be particularly confusing in our auto-encoding setting by simply ignoring the memory and functioning as a skip connection. We avoid this situation by removing this controller output and ensure that the DNC only reads-out from its memory. Further, to focus on the memory performance, we remove ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "VAE ",
+        "bbox": [
+            183,
+            104,
+            209,
+            116
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/81e4bc84470fadba151690e5e38dee018f2c8fb50bd2e946e92aea0a3920f6e9.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            121,
+            818,
+            141
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "generation reading writing ",
+        "bbox": [
+            183,
+            154,
+            246,
+            166
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            183,
+            199,
+            228,
+            210
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/a5597b89089504beb9260c48f0db06bf06ae4ff19c24f21ddf1c56e209ba9bd8.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            213,
+            820,
+            263
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            183,
+            267,
+            223,
+            280
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/8834844721d58aadb5e2d46850182826b9ae5d6ca40719afe2fe02f28090d8ca.jpg",
+        "image_caption": [
+            "Figure 9: The architecture of the VAE and the Kanerva Machine used in our experiments. conv/deconv: convolutional and transposed convolutions neural networks. MLP: multiplayer perceptron. concat: vector concatenation. The blue arrows show memory writing as exact inference. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            281,
+            583,
+            333
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/6202cd774c86d5dc91647350ecdfad782401061c6c0f80dad2b27e349754aa35.jpg",
+        "image_caption": [
+            "Figure 10: Covariance between memory rows is important. The two curves shows the test loss (negative variational lower bound) as a function of iterations. Four models using full $K \\times K$ covariance matrix $U$ are shown by red curves and four models using diagonal covariance matrix are shown in blue. All other settings for these 8 models are the same (as described in section 4). These 8 models are trained on machines with similar setup. The models using full covariance matrices were slightly slower per-iteration, but the test loss decreased far more quickly. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            338,
+            487,
+            658,
+            671
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "the bottom-up stream in our model that compensates for the memory. This means directly sampling $z _ { t }$ from $p _ { \\theta }$ $\\upsilon _ { \\theta } \\left( z _ { t } | \\boldsymbol { y } _ { t } , \\boldsymbol { M } \\right)$ , instead of $p _ { \\theta } \\left( z _ { t } | x _ { t } , y _ { t } , M \\right)$ , for the decoder $\\dot { p } _ { \\theta } \\left( x _ { t } | z _ { t } \\right)$ , forcing the model to reconstruct solely using read-outs from the memory. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/ea5f146818917a868f439ba9fbe9f0825cae79e9b5737892c057571c838b6d62.jpg",
+        "image_caption": [
+            "Figure 11: The KL-divergence between $y _ { t }$ (left) and $z _ { t }$ (right) during training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            102,
+            759,
+            247
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/abd7e818d5da2bf5f791bb8b027e0a504827b16e2b020cc56c8034cae7bb3ea6.jpg",
+        "image_caption": [
+            "Figure 12: The negative variational lower bound, reconstruction loss, and total KL-divergence during CIFAR training. Although the difference between the lower bound objective is smaller than that during Omniglot training, the general patterns of these curves are similar to those in Fig. 2. The relatively small difference in KL-divergence significantly influences sample quality. Notice at the time of our submission, the training is continuing and the advantage of the Kanerva Machine over the VAE is increasing. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            304,
+            794,
+            410
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E DERIVATION OF THE ONLINE UPDATE RULE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            544,
+            566,
+            559
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Eq. 6 defines a linear Gaussian model. Using notations in the main paper, can write the joint distribution $p ( \\operatorname { v e c } \\left( Z \\right) , \\operatorname { v e c } ( M ) ) = { \\mathcal { N } } \\left( \\operatorname { v e c } \\left( Z \\right) , \\operatorname { v e c } ( M ) ; \\mu _ { j } , \\Sigma _ { j } \\right)$ , where ",
+        "bbox": [
+            169,
+            577,
+            823,
+            607
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a017ebe807c58990d8cc3b6934b9c45848cd0106eff7c399354c6fcda9e584fc.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mu _ { j } = \\left[ \\mathrm { v e c } \\left( W R \\right) \\right] } \\\\ & { \\Sigma _ { j } = \\left[ \\Sigma _ { z } \\otimes I _ { C } \\quad \\Sigma _ { c } \\otimes I _ { C } \\right] } \\\\ & { \\Sigma _ { j } = \\left[ \\Sigma _ { c } \\mathbf { \\bar { \\Psi } } \\otimes I _ { C } \\quad U \\otimes I _ { c } \\right] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            614,
+            598,
+            688
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We can then use the conditional formula for the Gaussian to derive the posterior distribution $p ( \\operatorname { v e c } \\left( M \\right) | \\operatorname { v e c } \\left( Z \\right) ) = \\mathcal { N } \\left( \\operatorname { v e c } \\left( M \\right) ; \\mu _ { p } , \\Sigma _ { p } \\right)$ , using the property Kronecker product: ",
+        "bbox": [
+            173,
+            694,
+            823,
+            724
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b1c96ca379cd69dba488c70ba6e29c81fc9e75dde96193be101f4f81f1652d6b.jpg",
+        "text": "$$\n\\begin{array} { r l } & { { \\mu _ { p } } = \\operatorname { v e c } \\left( R \\right) + { \\Sigma _ { c } } ^ { \\mathsf { T } } { \\Sigma _ { z } } ^ { - 1 } \\otimes I _ { C } ( \\operatorname { v e c } \\left( Z \\right) - \\operatorname { v e c } \\left( W R \\right) ) } \\\\ & { { \\Sigma _ { p } } = U \\otimes I _ { c } - { \\Sigma _ { c } } ^ { \\mathsf { T } } { \\Sigma _ { z } } ^ { - 1 } { \\Sigma _ { c } } \\otimes I _ { C } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            732,
+            679,
+            775
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "From properties of matrix variate Gaussian distribution, the above two equations can be re-arranged to the update rule in eq. 9 to 11. ",
+        "bbox": [
+            174,
+            781,
+            823,
+            810
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "F DISTRIBUTION-BASED READING AND WRITING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            834,
+            604,
+            851
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "While the model we described in this paper works well using samples from $q _ { \\phi } \\left( z _ { t } | x _ { t } \\right)$ for writing to the memory (section 3.3) and the mean-field approximation during reading (section 3.4), here we describe an alternative that fully exploits the analytic tractability of the Gaussian distribution. To simplify notation, we use $\\psi = \\{ R , U , V \\}$ for all parameters of the memory. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For reading, eq. 6 can be replaced with a distribution that directly depends on $\\psi$ through the integral: ",
+        "bbox": [
+            169,
+            102,
+            820,
+            119
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4df8eb1af31a0c45e7df7090c3e1cd61f48c2d006603f9edd43b195962228706.jpg",
+        "text": "$$\n\\begin{array} { c } { { p _ { \\theta } \\left( z _ { t } | y _ { t } , \\psi \\right) = \\displaystyle \\int p _ { \\theta } \\left( z _ { t } | y _ { t } , M \\right) p ( M ) \\mathrm { d } M } } \\\\ { { = \\mathcal { N } \\left( z _ { t } | w _ { t } { } ^ { \\mathsf { T } } R , w U w ^ { \\mathsf { T } } + \\sigma ^ { 2 } I _ { C } \\right) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            140,
+            656,
+            194
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For writing, the distribution $\\begin{array} { r } { q _ { \\phi } \\left( \\boldsymbol { Z } \\vert \\boldsymbol { X } \\right) = \\prod _ { t = 1 } ^ { T } q _ { \\phi } \\left( z _ { t } \\vert \\boldsymbol { x } _ { t } \\right) = \\mathcal { N } \\left( \\mu _ { Q } , \\boldsymbol { \\Sigma } _ { Q } \\right) } \\end{array}$ ( $\\mu _ { Q }$ and $\\Sigma _ { Q }$ are functions of $X$ ) can be incorporated into the Bayes’ update rule by analytically marginalising-out $Z$ : ",
+        "bbox": [
+            173,
+            223,
+            823,
+            256
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d7120d3d09155125ce156f645014ed8378f50c0ff7f4a125ca0987413f3146bf.jpg",
+        "text": "$$\n\\begin{array} { r l } & { p _ { \\theta } \\left( M | Y , X \\right) = \\displaystyle \\int p _ { \\theta } \\left( M | Y , Z \\right) q _ { \\phi } \\left( Z | X \\right) \\mathrm { d } Z } \\\\ & { \\quad \\quad \\quad = \\displaystyle \\int \\frac { p _ { \\theta } \\left( M \\right) p _ { \\theta } \\left( Z | Y , M \\right) } { p _ { \\theta } \\left( Z | Y \\right) } q _ { \\phi } \\left( Z | X \\right) \\mathrm { d } Z } \\\\ & { \\quad \\quad \\quad \\propto p _ { \\theta } \\left( M \\right) \\displaystyle \\int p _ { \\theta } \\left( Z | Y , M \\right) q _ { \\phi } \\left( Z | X \\right) \\mathrm { d } Z } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            276,
+            679,
+            378
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where we used Bayes’ rule and dropped the normalising constant $p _ { \\theta } \\left( Z | Y \\right)$ , and then replaced the equality with proportional-to accordingly. The last integral is: ",
+        "bbox": [
+            173,
+            398,
+            825,
+            428
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/25f7efe24ef6292b157d86719b10cd0ad551136eb46b3b7e8863177d1ee2f8d7.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\displaystyle \\int p _ { \\theta } \\left( Z \\vert Y , M \\right) q _ { \\phi } \\left( Z \\vert X \\right) \\mathrm { d } Z = \\frac { 1 } { \\sqrt { \\operatorname* { d e t } ( 2 \\pi \\Sigma _ { z ^ { \\prime } } ) } } \\exp \\left[ - \\frac { 1 } { 2 } ( \\mu _ { Q } - W R ) ^ { \\mathsf { T } } \\Sigma _ { z ^ { \\prime } } ^ { - 1 } ( \\mu _ { Q } - W R ) \\right] } \\\\ & { \\quad \\quad \\quad \\quad \\cdot \\displaystyle \\int p ^ { \\prime } ( Z ) \\mathrm { d } Z } \\\\ & { \\quad \\quad \\quad \\quad = \\mathcal { N } ( \\mu _ { Q } \\vert W R , \\Sigma _ { z ^ { \\prime } } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            448,
+            781,
+            539
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where $\\Sigma _ { z ^ { \\prime } } = W U W ^ { \\intercal } + \\Sigma _ { \\xi } + \\Sigma _ { Q }$ and $p ^ { \\prime } ( Z )$ is a distribution of $Z$ whose exact form is unimportant. Therefore, eq. 20 shows that the posterior distribution of $M$ is proportional to the product between the prior $p _ { \\theta } \\left( M \\right)$ and the above likelihood term. From inspection, we can see the update rule (eq. 9 - 11) needs to be modified by replacing $\\Sigma _ { z }$ with $\\Sigma _ { z ^ { \\prime } }$ by adding the bottom-up uncertainty $\\Sigma _ { Q }$ . ",
+        "bbox": [
+            174,
+            559,
+            826,
+            617
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "G DESCRIPTION OF THE ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            654,
+            501,
+            670
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Iterative Reading ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            719,
+            377,
+            734
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/047731985fac6f8ed4fc625a4a6dc48696a6a849652e9960b2ce892eef71801f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Input: Memory M,a (potentially noisy) query xt, the number of iteration n Output: An estimate of the noiseless 𝑥t</td></tr><tr><td>initialisei=O</td></tr><tr><td>whilei&lt;ndo</td></tr><tr><td>sample yt ~ q(yt|xt) compute the key bt ← f(yt)</td></tr><tr><td>Compute the weights wt ←bt · A</td></tr><tr><td>read-out mean μz ← wtT · M</td></tr><tr><td>sample zt ~ q(zt|xt, Yt,M) which takes μz and xt as inputs</td></tr><tr><td>sample the new query xt ~ pe(xt|zt)</td></tr><tr><td>incrementi←i+1</td></tr><tr><td>end while</td></tr><tr><td>returnx←xt</td></tr></table>",
+        "bbox": [
+            173,
+            736,
+            758,
+            921
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Writing ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            315,
+            117
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Input: Images $\\{ x _ { t } \\} _ { t = 1 } ^ { T }$ , Memory $M$ with parameters $R$ and $U$ ",
+        "bbox": [
+            173,
+            122,
+            589,
+            137
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Output: Updated memory $M ^ { \\prime }$ for each $y _ { t }$ do sample $y _ { t } \\sim q _ { \\phi } ( y _ { t } | x _ { t } )$ compute the key $b _ { t } \\gets f ( y _ { t } )$ Compute the weights $w _ { t } \\gets b _ { t } ^ { \\intercal } \\cdot A$ sample $z _ { t } \\sim q _ { \\phi } ( z _ { t } | x _ { t } )$ update parameters of $M$ $\\begin{array} { r l } & { | \\begin{array} { l } { \\Delta \\xleftarrow { } Z - W R } \\end{array}  } \\\\ & {  \\Sigma _ { c } \\xleftarrow { } W U  } \\\\ & {  \\Sigma _ { z } \\xleftarrow { } W U W ^ { \\intercal } + \\Sigma _ { \\xi }  } \\\\ & { R   R + \\Sigma _ { c } \\textbar { \\Sigma } \\Sigma _ { z } ^ { - 1 } \\Delta  } \\\\ & { U   U - \\Sigma _ { c } \\textbar { \\Sigma } \\Sigma _ { z } ^ { - 1 } \\Sigma _ { c }  } \\end{array}$ ",
+        "bbox": [
+            174,
+            137,
+            431,
+            306
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "end for ",
+        "text_level": 1,
+        "bbox": [
+            191,
+            304,
+            243,
+            316
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "return $M ^ { \\prime }$ with the updated parameters $R$ and $U$ ",
+        "bbox": [
+            189,
+            318,
+            504,
+            332
+        ],
+        "page_idx": 15
+    }
+]

parse/train/SkNQeiRpb/SkNQeiRpb.md

@@ -0,0 +1,192 @@
+# TRAINING DEEP AUTOENCODERS FOR RECOM-MENDER SYSTEMS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+This paper proposes a new model for the rating prediction task in recommender systems which significantly outperforms previous state-of-the art models on a time-split Netflix data set. Our model is based on deep autoencoder with 6 layers and is trained end-to-end without any layer-wise pre-training. We empirically demonstrate that: a) deep autoencoder models generalize much better than the shallow ones, b) non-linear activation functions with negative parts are crucial for training deep models, and c) heavy use of regularization techniques such as dropout is necessary to prevent overfitting. We also propose a new training algorithm based on iterative output re-feeding to overcome natural sparseness of collaborate filtering. The new algorithm significantly speeds up training and improves model performance.
+
+# 1 INTRODUCTION
+
+Sites like Amazon, Netflix and Spotify use recommender systems to suggest items to users. Recommender systems can be divided into two categories: context-based and personalized recommendations.
+
+Context based recommendations take into account contextual factors such as location, date and time (Adomavicius & Tuzhilin, 2011). Personalized recommendations typically suggest items to users using the collaborative filtering (CF) approach. In this approach the user’s interests are predicted based on the analysis of tastes and preference of other users in the system and implicitly inferring “similarity” between them. The underlying assumption is that two people who have similar tastes, have a higher likelihood of having the same opinion on an item than two randomly chosen people.
+
+In designing recommender systems, the goal is to improve the accuracy of predictions. The Netflix Prize contest provides the most famous example of this problem (Bennett et al., 2007): Netflix held the Netflix Prize to substantially improve the accuracy of the algorithm to predict user ratings for films. This is a classic CF problem: Infer the missing entries in an mxn matrix, $R$ , whose $( i , j )$ entry describes the ratings given by the ith user to the $j$ th item. The performance is then measured using Root Mean Squared Error (RMSE).
+
+Training very deep autoencoders is non trivial both from optimization and regularization points of view. Early works on training auto-enocoders adapted layer-wise pre-training to solve optimization issues (Hinton & Salakhutdinov, 2006). In this work, we empirically show that optimization difficulties of training deep autoencoders can be solved by using scaled exponential linear units $( S E L U s ,$ )(Klambauer et al., 2017). This enables training without any layer-wise pre-training or residual connections. Since publicly available data sets for CF are relatively small, sufficiently large models can easily overfit. To prevent overfitting we employ heavy dropout with drop probability as high as 0.8. We also introduce a new output re-feeding training algorithm which helps to bypass the natural sparseness of updates in collaborative filtering and helps to further improve the model performance.
+
+# 1.1 RELATED WORK
+
+Deep learning (LeCun et al., 2015) has led to breakthroughs in image recognition, natural language understanding, and reinforcement learning. Naturally, these successes fuel an interest for using deep learning in recommender systems. First attempts at using deep learning for recommender systems involved restricted Boltzman machines (RBM) (Salakhutdinov et al., 2007). Several recent approaches use autoencoders (Sedhain et al., 2015; Strub & Mary, 2015), feed-forward neural networks (He et al., 2017), neural autoregressive architectures (Zheng et al., 2016) and recurrent recommender networks (Wu et al., 2017). Many popular matrix factorization techniques can be thought of as a form of dimensionality reduction. It is, therefore, natural to adapt deep autoencoders for this task as well. I-AutoRec (item-based autoencoder) and $U _ { ☉ }$ -AutoRec (user-based autoencoder) are first successful attempts to do so Sedhain et al. (2015). Stacked de-noising autoencoders has been sucesfully used on this task as well (Li et al., 2015; Wang et al., 2015).
+
+There are many non deep learning types of approaches to collaborative filtering (CF) (Breese et al., 1998; Ricci et al., 2011). Matrix factorization techniques, such as alternating least squares (ALS) (Kim & Park, 2008; Koren et al., 2009) and probabilistic matrix factorization (Mnih & Salakhutdinov, 2008) are particularly popular. The most robust systems may incorporate several ideas together such as the winning solution to the Netflix Prize competition (Koren, 2009). Note that Netflix Prize data also includes temporal signal - time when each rating has been made. Thus, several classic CF approaches has been extended to incorporate temporal information such as TimeSVD $^ { + + }$ Koren (2010), as well as more recent RNN-based techniques such as recurrent recommender networks Wu et al. (2017).
+
+# 2 MODEL
+
+Our model is inspired by $U$ -AutoRec approach with several important distinctions. We train much deeper models. To enable this without any pre-training, we: a) use “scaled exponential linear units” (SELUs) Klambauer et al. (2017), b) use high dropout rates, and d) use iterative output re-feeding during training.
+
+An autoencoder is a network which implements two transformations - encoder $e n c o d e ( x ) : R ^ { n } \to$ $R ^ { d }$ and $d e c o d e r ( z ) : R ^ { d } \to R ^ { n }$ . The “goal” of autoenoder is to obtain $d$ dimensional representation of data such that an error measure between $x$ and $f ( x ) = d e c o d e ( e n c o d e ( x ) )$ is minimized Hinton & Zemel (1994). Figure 1 depicts typical 4-layer autoencoder network. If noise is added to the data during encoding step, the autoencoder is called de-noising. Autoencoder is an excellent tool for dimensionality reduction and can be thought of as a strict generalization of principle component analysis (PCA) Hinton & Salakhutdinov (2006). An autoencoder without non-linear activations and only with “code” layer should be able to learn PCA transformation in the encoder if trained to optimize mean squared error (MSE) loss.
+
+In our model, both encoder and decoder parts of the autoencoder consist of feed-forward neural networks with classical fully connected layers computing $l = f ( W * x + b )$ , where $f$ is some nonlinear activation function. If range of the activation function is smaller than that of data, the last layer of the decoder should be kept linear. We found it to be very important for activation function $f$ in hidden layers to contain non-zero negative part, and we use SELU units in most of our experiments (see Section 3.2 for details).
+
+If decoder mirrors encoder architecture (as it does in our model), then one can constrain decoder’s weights $\boldsymbol { W } _ { d } ^ { l }$ to be equal to transposed encoder weights $W _ { e } ^ { l }$ from the corresponding layer $l$ . Such autoencoder is called constrained or tied and has almost two times less free parameters than unconstrained one.
+
+Forward pass and inference. During forward pass (and inference) the model takes user represented by his vector of ratings from the training set $x \in R ^ { n }$ , where $n$ is number of items. Note that $x$ is very sparse, while the output of the decoder, $f ( x ) \in R ^ { n }$ is dense and contains rating predictions for all items in the corpus.
+
+# 2.1 LOSS FUNCTION
+
+Since it doesn’t make sense to predict zeros in user’s representation vector $x$ , we follow the approach from Sedhain et al. (2015) and optimize Masked Mean Squared Error loss:
+
+$$
+M M S E = \frac { m _ { i } * ( r _ { i } - y _ { i } ) ^ { 2 } } { \sum _ { i = 0 } ^ { i = n } m _ { i } }
+$$
+
+where $r _ { i }$ is actual rating, $y _ { i }$ is reconstructed, or predicted rating, and $m _ { i }$ is a mask function such that $m _ { i } = 1$ if $r _ { i } \neq 0$ else $m _ { i } = 0$ . Note that there is a straightforward relation between RMSE score and MMSE score: $R M S E = \sqrt { M M S E }$ .
+
+# 2.2 DENSE RE-FEEDING
+
+During training and inference, an input $x \in R ^ { n }$ is very sparse because no user can realistically rate but a tiny fractions of all items. This poses problem for model training. Bayesian approches can be used to overcome this issue (Wang et al., 2015). On the other hand, autoencoder’s output $f ( x )$ is dense. Lets consider an idealized scenario with a perfect $f$ . Then $f ( x ) _ { i } = x _ { i } , \forall i : x _ { i } \neq 0$ and $f ( { \boldsymbol { x } } ) _ { i }$ accurately predicts all user’s future ratings for items $i : x _ { i } = 0$ . This means that if user rates new item $k$ (thereby creating a new vector $x ^ { \prime }$ ) then $f ( x ) _ { k } = x _ { k } ^ { \prime }$ and $f ( x ) = f ( x ^ { \prime } )$ . Hence, in this idealized scenario, $y = f ( x )$ should be a fixed point of a well trained autoencoder: $f ( y ) = y$ .
+
+To explicitly enforce fixed-point constraint and to be able to perform dense training updates, we augment every optimization iteration with an iterative dense re-feeding steps (3 and 4 below) as follows:
+
+1. Given sparse $x$ , compute dense $f ( x )$ and loss using equation 1 (forward pass)   
+2. Compute gradients and perform weight update (backward pass)   
+3. Treat $f ( x )$ as a new example and compute $f ( f ( x ) )$ . Now both $f ( x )$ and $f ( f ( x ) )$ are dense   
+and the loss from equation 1 has all $m$ as non-zeros. (second forward pass)   
+4. Compute gradients and perform weight update (second backward pass)
+
+Steps (3) and (4) can be also performed more than once for every iteration.
+
+# 3 EXPERIMENTS AND RESULTS
+
+# 3.1 EXPERIMENT SETUP
+
+For the rating prediction task, it is often most relevant to predict future ratings given the past ones instead of predicting ratings missing at random. For evaluation purposes we followed Wu et al. (2017) exactly by splitting the original Netflix Prize Bennett et al. (2007) training set into several training and testing intervals based on time. Training interval contains ratings which came in earlier than the ones from testing interval. Testing interval is then randomly split into Test and Validation subsets so that each rating from testing interval has a $50 \%$ chance of appearing in either subset. Users and items that do not appear in the training set are removed from both test and validation subsets. Table 1 provides details on the data sets.2
+
+For most of our experiments we uses a batch size of 128, trained using SGD with momentum of 0.9 and learning rate of 0.001. We used xavier initialization to initialize parameters. Note, that unlike Strub & Mary (2015) we did not use any layer-wise pre-training. We believe that we were able to do so successfully because of choosing the right activation function (see Section 3.2).
+
+# 3.2 EFFECTS OF THE ACTIVATION TYPES
+
+To explore the effects of using different activation functions, we tested some of the most popular choices in deep learning : sigmoid, “rectified linear units” (RELU), $m a x ( r e l u ( x ) , 6 )$ or RELU6, hyperbolic tangent (TANH), “exponential linear units” (ELU) (Clevert et al., 2015), leaky relu (LRELU) (Xu et al., 2015) , “self-gated activation function” (SWISH) (Ramachandran et al., 2017), and “scaled exponential linear units” (Klambauer et al., 2017) (SELU) on the 4 layer autoencoder with 128 units in each hidden layer. Because ratings are on the scale from 1 to 5, we keep last layer of the decoder linear for sigmoid and tanh-based models. In all other models activation function is applied in all layers.
+
+![](images/09a17f90285f07af06cb356344fc9c7e4c66332e57baa5666e3e4a13acf00cc6.jpg)  
+Figure 1: AutoEncoder consists of two neural networks, encoder and decoder, fused together on the “representation” layer $z$ . Encoder has 2 layers $e _ { 1 }$ and $e _ { 2 }$ and decoder has 2 layers $d _ { 1 }$ and $d _ { 2 }$ . Dropout may be applied to coding layer $z$ .
+
+Table 1: Subsets of Netflix Prize training set used in our experiments. We made sure that these splits match exactly the ones used in (Wu et al., 2017).   
+
+<table><tr><td></td><td>Full</td><td>3 months</td><td>6 months</td><td>1 year</td></tr><tr><td></td><td></td><td></td><td>06/05-11/05</td><td></td></tr><tr><td>Training Users</td><td>12/99-11/05 477,412</td><td>09/05-11/05 311,315</td><td>390,795</td><td>06/04-05/05 345,855</td></tr><tr><td>Ratings</td><td>98,074,901</td><td>13,675,402</td><td>29,179,009</td><td>41,451,832</td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Testing Users</td><td>12/05</td><td>12/05</td><td>12/05</td><td>06/05</td></tr></table>
+
+We found that on this task ELU, SELU and LRELU perform much better than SIGMOID, RELU, RELU6, TANH and SWISH. Figure 2 clearly demonstrates this. There are two properties which seems to separate activations which perform well from those which do not: a) non-zero negative part and b) unbounded positive part. Hence, we conclude, that in this setting these properties are important for successful training. Thus, we use SELU activation units and tune SELU-based networks for performance.
+
+![](images/aec9a2eced5f723ac04e892d3f29d7e2ede096781d457488e2eaddd2ec164ecb.jpg)  
+Figure 2: Training RMSE per mini-batch. All lines correspond to 4-layers autoencoder (2 layer encoder and 2 layer decoder) with hidden unit dimensions of 128. Different line colors correspond to different activation functions. TANH and SIGMOID lines are very similar as well as lines for ELU and SELU. The best performing activation functions are ELU and SELU.
+
+# 3.3 OVER-FITTING THE DATA
+
+The largest data set we use for training, “Netflix Full” from Table 1, contains 98M ratings given by 477K users. Number of movies (e.g. items) in this set is $n = 1 7$ , 768. Therefore, the first layer of encoder will have $d * n + d$ weights, where $d$ is number of units in the layer.
+
+For modern deep learning algorithms and hardware this is relatively small task. If we start with single layer encoders and decoders we can quickly overfit to the training data even for $d$ as small as 512. Figure 3 clearly demonstrates this. Switching from unconstrained autoencoder to constrained reduces over-fitting, but does not completely solve the problem.
+
+![](images/63b7bb1ea66cdf6bb9ca0bb346e6100321c6a5f1f9ea9693554e275cb0692ba0.jpg)  
+Figure 3: Single layer autoencoder with 128, 256, 512 and 1024 hidden units in the coding layer. A: training RMSE per epoch; B: evaluation RMSE per epoch.
+
+# 3.4 GOING DEEPER
+
+While making layers wider helps bring training loss down, adding more layers is often correlated with a network’s ability to generalize. In this set of experiments we show that this is indeed the case here. We choose small enough dimensionality $d = 1 2 8$ ) for all hidden layers to easily avoid over-fitting and start adding more layers. Table 2 shows that there is a positive correlation between the number of layers and the evaluation accuracy.
+
+Table 2: Depth helps generalization. Evaluation RMSE of the models with different number of layers. In all cases the hidden layer dimension is 128.   
+
+<table><tr><td>Number of layers</td><td>Evaluation RMSE</td><td>params</td></tr><tr><td></td><td></td><td></td></tr><tr><td>2</td><td>1.146</td><td>4,566,504</td></tr><tr><td>4</td><td>0.9615</td><td>4,599,528</td></tr><tr><td>6</td><td>0.9378</td><td>4,632,552</td></tr><tr><td>8 10</td><td>0.9364</td><td>4,665,576</td></tr><tr><td>12</td><td>0.9340 0.9328</td><td>4,698,600</td></tr><tr><td></td><td></td><td>4,731,624</td></tr></table>
+
+Going from one layer in encoder and decoder to three layers in both provides good improvement in evaluation RMSE (from 1.146 to 0.9378). After that, blindly adding more layers does help, however it provides diminishing returns. Note that the model with single $d \ : = \ : 2 5 6$ layer in encoder and decoder has 9,115,240 parameters which is almost two times more than any of these deep models while having much worse evauation RMSE (above 1.0).
+
+# 3.5 DROPOUT
+
+Section 3.4 shows us that adding too many small layers eventually hits diminishing returns. Thus, we start experimenting with model architecture and hyper-parameters more broadly. Our most promising model has the following architecture: $n , 5 1 2 , 5 1 2 , 1 0 2 4 , 5 1 2 , 5 1 2 , n .$ , which means 3 layers in encoder (512,512,1024), coding layer of 1024 and 3 layers in decoder of size 512,512,n. This model, however, quickly over-fits if trained with no regularization. To regularize it, we tried several dropout values and, interestingly, very high values of drop probability (e.g. 0.8) turned out to be the best. See Figure 4 for evaluation RMSE. We apply dropout on the encoder output only, e.g. $f ( x ) = d e c o d e ( d r o p o u t ( e n c o d e ( x ) ) )$ . We tried applying dropout after every layer of the model but that stifled training convergence and did not improve generalization.
+
+![](images/1d42da41c3ad8938ff124090a7abb4a7d64268bb5591f52f0509568c13480560.jpg)  
+Figure 4: Effects of dropout. Y-axis: evaluation RMSE, X-axis: epoch number. Model with no dropout (Drop Prob 0.0) clearly over-fits. Model with drop probability of 0.5 over-fits as well (but much slowly). Models with drop probabilities of 0.65 and 0.8 result in RMSEs of 0.9192 and 0.9183 correspondingly.
+
+# 3.6 DENSE RE-FEEDING
+
+Iterative dense re-feeding (see Section 2.2) provides us with additional improvement in evaluation accuracy for our 6-layer-model: $n$ , 512, 512, 1024, $d p ( 0 . 8 )$ , 512, 512, $n$ (referred to as Baseline below). Here each parameter denotes the number of inputs, hidden units, or outputs and $d p ( 0 . 8 )$ is a dropout layer with a drop probability of 0.8. Just applying output re-feeding did not have significant impact on the model performance. However, in conjunction with the higher learning rate, it did significantly increase the model performance. Note, that with this higher learning rate (0.005) but without dense re-feeding, the model started to diverge. See Figure 5 for details.
+
+Table 3: Test RMSE of different models. I-AR, U-AR and RRN numbers are taken from (Wu et al., 2017)   
+
+<table><tr><td>DataSet</td><td>I-AR</td><td>U-AR</td><td>RRN</td><td>DeepRec</td></tr><tr><td rowspan="3">Netflix 3 months Netfix Full</td><td></td><td></td><td></td><td></td></tr><tr><td>0.9778</td><td>0.9836</td><td>0.9427</td><td>0.9373</td></tr><tr><td>0.9364</td><td>0.9647</td><td>0.9224</td><td>0.9099</td></tr></table>
+
+![](images/b589cd81bc68f7c0374d34eb5d18286cf197a9628be19ee2e0751e9faaaf5554.jpg)  
+Figure 5: Effects of dense re-feeding. Y-axis: evaluation RMSE, $\mathbf { X }$ -axis: epoch number. Baseline model was trained with learning rate of 0.001. Applying re-feeding step with the same learning rate almost did not help (Baseline RF). Learning rate of 0.005 (Baseline LR 0.005) is too big for baseline model without re-feeding. However, increasing both learning rate and applying re-feeding step clearly helps (Baseline LR 0.005 RF).
+
+Applying dense re-feeding and increasing the learning rate, allowed us to further improve the evaluation RMSE from 0.9167 to 0.9100. Picking a checkpoint with best evaluation RMSE and computing test RMSE gives as 0.9099, which we believe is significantly better than other methods.
+
+# 3.7 COMPARISON WITH OTHER METHODS
+
+We compare our best model with Recurrent Recommender Network from Wu et al. (2017) which has been shown to outperform PMF (Mnih & Salakhutdinov, 2008), T-SVD (Koren, 2010) and I/UAR (Sedhain et al., 2015) on the data we use (see Table 1 for data description). Note, that unlike T-SVD and RRN, our method does not explicitly take into account temporal dynamics of ratings. Yet, Table 3 shows that it is still capable of outperforming these methods on future rating prediction task. We train each model using only the training set and compute evaluation RMSE for 100 epochs. Then the checkpoint with the highest evaluation RMSE is tested on the test set.
+
+“Netflix 3 months” has 7 times less training data compared to “Netflix full”, it is therefore, not surprising that the model’s performance is significantly worse if trained on this data alone (0.9373 vs 0.9099). In fact, the model that performs best on “Netflix full” over-fits on this set, and we had to reduce the model’s complexity accordingly (see Table 4 for details).
+
+Table 4: Test RMSE achieved by DeepRec on different Netflix subsets. All models are trained with one iterative output re-feeding step per each iteration.   
+
+<table><tr><td>DataSet</td><td>RMSE</td><td>Model Architecture</td></tr><tr><td></td><td></td><td></td></tr><tr><td>Netflix 3 months</td><td>0.9373</td><td>n,128,256,256,dp(0.65),256,128,n</td></tr><tr><td>Netflix 6 months</td><td>0.9207</td><td>n,256,256,512,dp(0.8),256,256,n</td></tr><tr><td>Netflix 1 year</td><td>0.9225</td><td>n,256,256,512,dp(0.8),256,256, n</td></tr><tr><td>Netfix Full</td><td>0.9099</td><td>n,512,512,1024,dp(0.8),512,512, n</td></tr></table>
+
+# 4 CONCLUSION
+
+Deep learning has revolutionized many areas of machine learning, and it is poised do so with recommender systems as well. In this paper we demonstrated how very deep autoencoders can be successfully trained even on relatively small amounts of data by using both well established (dropout) and relatively recent (“scaled exponential linear units”) deep learning techniques. Further, we introduced iterative output re-feeding - a technique which allowed us to perform dense updates in collaborative filtering, increase learning rate and further improve generalization performance of our model. On the task of future rating prediction, our model outperforms other approaches even without using additional temporal signals.
+
+While our code supports item-based model (such as I-AutoRec) we argue that this approach is less practical than user-based model (U-AutoRec). This is because in real-world recommender systems, there are usually much more users then items. Finally, when building personalized recommender system and faced with scaling problems, it can be acceptable to sample items but not users.
+
+# ACKNOWLEDGMENTS
+
+We thank the author of (Wu et al., 2017), Chao-Yuan Wu, for fruitfull discussion and help validating our data sets.
+
+# REFERENCES
+
+Gediminas Adomavicius and Alexander Tuzhilin. Context-aware recommender systems. In Recommender systems handbook, pp. 217–253. Springer, 2011.
+
+James Bennett, Stan Lanning, and Netflix Netflix. The netflix prize. In In KDD Cup and Workshop in conjunction with KDD, 2007.
+
+John S. Breese, David Heckerman, and Carl Kadie. Empirical analysis of predictive algorithms for collaborative filtering. In Proceedings of the Fourteenth Conference on Uncertainty in Artificial Intelligence, UAI’98, pp. 43–52, San Francisco, CA, USA, 1998. Morgan Kaufmann Publishers Inc. ISBN 1-55860-555-X. URL http://dl.acm.org/citation.cfm?id=2074094. 2074100.
+
+Djork-Arne Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network´ learning by exponential linear units (elus). arXiv preprint arXiv:1511.07289, 2015.
+
+Xiangnan He, Lizi Liao, Hanwang Zhang, Liqiang Nie, Xia Hu, and Tat-Seng Chua. Neural collaborative filtering. In Proceedings of the 26th International Conference on World Wide Web, pp. 173–182. International World Wide Web Conferences Steering Committee, 2017.
+
+Geoffrey E Hinton and Ruslan R Salakhutdinov. Reducing the dimensionality of data with neural networks. science, 313(5786):504–507, 2006.
+
+Geoffrey E Hinton and Richard S. Zemel. Autoencoders, minimum description length and helmholtz free energy. In J. D. Cowan, G. Tesauro, and J. Alspector (eds.), Advances in Neural Information Processing Systems 6, pp. 3– 10. Morgan-Kaufmann, 1994. URL http://papers.nips.cc/paper/ 798-autoencoders-minimum-description-length-and-helmholtz-free-energy. pdf.
+
+Hyunsoo Kim and Haesun Park. Nonnegative matrix factorization based on alternating nonnegativity constrained least squares and active set method. SIAM journal on matrix analysis and applications, 30(2):713–730, 2008.
+
+Gunter Klambauer, Thomas Unterthiner, Andreas Mayr, and Sepp Hochreiter. Self-normalizing ¨ neural networks. arXiv preprint arXiv:1706.02515, 2017.
+
+Yehuda Koren. The bellkor solution to the netflix grand prize. Netflix prize documentation, 81:1–10, 2009.
+
+Yehuda Koren. Collaborative filtering with temporal dynamics. Communications of the ACM, 53 (4):89–97, 2010.
+
+Yehuda Koren, Robert Bell, and Chris Volinsky. Matrix factorization techniques for recommender systems. Computer, 42(8), 2009.
+
+Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015.
+
+Sheng Li, Jaya Kawale, and Yun Fu. Deep collaborative filtering via marginalized denoising autoencoder. In Proceedings of the 24th ACM International on Conference on Information and Knowledge Management, pp. 811–820. ACM, 2015.
+
+Andriy Mnih and Ruslan R Salakhutdinov. Probabilistic matrix factorization. In Advances in neural information processing systems, pp. 1257–1264, 2008.
+
+Prajit Ramachandran, Barret Zoph, and Quoc V Le. Swish: a self-gated activation function. arXiv preprint arXiv:1710.05941, 2017.
+
+Francesco Ricci, Lior Rokach, and Bracha Shapira. Introduction to recommender systems handbook. In Recommender systems handbook, pp. 1–35. Springer, 2011.
+
+Ruslan Salakhutdinov, Andriy Mnih, and Geoffrey Hinton. Restricted boltzmann machines for collaborative filtering. In Proceedings of the 24th international conference on Machine learning, pp. 791–798. ACM, 2007.
+
+Suvash Sedhain, Aditya Krishna Menon, Scott Sanner, and Lexing Xie. Autorec: Autoencoders meet collaborative filtering. In Proceedings of the 24th International Conference on World Wide Web, pp. 111–112. ACM, 2015.
+
+Florian Strub and Jer´ emie Mary. Collaborative filtering with stacked denoising autoencoders and ´ sparse inputs. In NIPS workshop on machine learning for eCommerce, 2015.
+
+Hao Wang, Naiyan Wang, and Dit-Yan Yeung. Collaborative deep learning for recommender systems. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 1235–1244. ACM, 2015.
+
+Chao-Yuan Wu, Amr Ahmed, Alex Beutel, Alexander J. Smola, and How Jing. Recurrent recommender networks. In Proceedings of the Tenth ACM International Conference on Web Search and Data Mining, WSDM ’17, pp. 495–503, New York, NY, USA, 2017. ACM. ISBN 978- 1-4503-4675-7. doi: 10.1145/3018661.3018689. URL http://doi.acm.org/10.1145/ 3018661.3018689.
+
+Bing Xu, Naiyan Wang, Tianqi Chen, and Mu Li. Empirical evaluation of rectified activations in convolutional network. arXiv preprint arXiv:1505.00853, 2015.
+
+Yin Zheng, Bangsheng Tang, Wenkui Ding, and Hanning Zhou. A neural autoregressive approach to collaborative filtering. arXiv preprint arXiv:1605.09477, 2016.

parse/train/SkNQeiRpb/SkNQeiRpb_content_list.json

@@ -0,0 +1,1052 @@
+[
+    {
+        "type": "text",
+        "text": "TRAINING DEEP AUTOENCODERS FOR RECOM-MENDER SYSTEMS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper proposes a new model for the rating prediction task in recommender systems which significantly outperforms previous state-of-the art models on a time-split Netflix data set. Our model is based on deep autoencoder with 6 layers and is trained end-to-end without any layer-wise pre-training. We empirically demonstrate that: a) deep autoencoder models generalize much better than the shallow ones, b) non-linear activation functions with negative parts are crucial for training deep models, and c) heavy use of regularization techniques such as dropout is necessary to prevent overfitting. We also propose a new training algorithm based on iterative output re-feeding to overcome natural sparseness of collaborate filtering. The new algorithm significantly speeds up training and improves model performance. ",
+        "bbox": [
+            233,
+            273,
+            764,
+            426
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            472,
+            336,
+            488
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sites like Amazon, Netflix and Spotify use recommender systems to suggest items to users. Recommender systems can be divided into two categories: context-based and personalized recommendations. ",
+        "bbox": [
+            174,
+            511,
+            823,
+            551
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Context based recommendations take into account contextual factors such as location, date and time (Adomavicius & Tuzhilin, 2011). Personalized recommendations typically suggest items to users using the collaborative filtering (CF) approach. In this approach the user’s interests are predicted based on the analysis of tastes and preference of other users in the system and implicitly inferring “similarity” between them. The underlying assumption is that two people who have similar tastes, have a higher likelihood of having the same opinion on an item than two randomly chosen people. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            642
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In designing recommender systems, the goal is to improve the accuracy of predictions. The Netflix Prize contest provides the most famous example of this problem (Bennett et al., 2007): Netflix held the Netflix Prize to substantially improve the accuracy of the algorithm to predict user ratings for films. This is a classic CF problem: Infer the missing entries in an mxn matrix, $R$ , whose $( i , j )$ entry describes the ratings given by the ith user to the $j$ th item. The performance is then measured using Root Mean Squared Error (RMSE). ",
+        "bbox": [
+            174,
+            650,
+            823,
+            733
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Training very deep autoencoders is non trivial both from optimization and regularization points of view. Early works on training auto-enocoders adapted layer-wise pre-training to solve optimization issues (Hinton & Salakhutdinov, 2006). In this work, we empirically show that optimization difficulties of training deep autoencoders can be solved by using scaled exponential linear units $( S E L U s ,$ )(Klambauer et al., 2017). This enables training without any layer-wise pre-training or residual connections. Since publicly available data sets for CF are relatively small, sufficiently large models can easily overfit. To prevent overfitting we employ heavy dropout with drop probability as high as 0.8. We also introduce a new output re-feeding training algorithm which helps to bypass the natural sparseness of updates in collaborative filtering and helps to further improve the model performance. ",
+        "bbox": [
+            174,
+            741,
+            825,
+            880
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1.1 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            326,
+            117
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep learning (LeCun et al., 2015) has led to breakthroughs in image recognition, natural language understanding, and reinforcement learning. Naturally, these successes fuel an interest for using deep learning in recommender systems. First attempts at using deep learning for recommender systems involved restricted Boltzman machines (RBM) (Salakhutdinov et al., 2007). Several recent approaches use autoencoders (Sedhain et al., 2015; Strub & Mary, 2015), feed-forward neural networks (He et al., 2017), neural autoregressive architectures (Zheng et al., 2016) and recurrent recommender networks (Wu et al., 2017). Many popular matrix factorization techniques can be thought of as a form of dimensionality reduction. It is, therefore, natural to adapt deep autoencoders for this task as well. I-AutoRec (item-based autoencoder) and $U _ { ☉ }$ -AutoRec (user-based autoencoder) are first successful attempts to do so Sedhain et al. (2015). Stacked de-noising autoencoders has been sucesfully used on this task as well (Li et al., 2015; Wang et al., 2015). ",
+        "bbox": [
+            174,
+            140,
+            825,
+            292
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There are many non deep learning types of approaches to collaborative filtering (CF) (Breese et al., 1998; Ricci et al., 2011). Matrix factorization techniques, such as alternating least squares (ALS) (Kim & Park, 2008; Koren et al., 2009) and probabilistic matrix factorization (Mnih & Salakhutdinov, 2008) are particularly popular. The most robust systems may incorporate several ideas together such as the winning solution to the Netflix Prize competition (Koren, 2009). Note that Netflix Prize data also includes temporal signal - time when each rating has been made. Thus, several classic CF approaches has been extended to incorporate temporal information such as TimeSVD $^ { + + }$ Koren (2010), as well as more recent RNN-based techniques such as recurrent recommender networks Wu et al. (2017). ",
+        "bbox": [
+            174,
+            299,
+            825,
+            425
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            472,
+            267,
+            488
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our model is inspired by $U$ -AutoRec approach with several important distinctions. We train much deeper models. To enable this without any pre-training, we: a) use “scaled exponential linear units” (SELUs) Klambauer et al. (2017), b) use high dropout rates, and d) use iterative output re-feeding during training. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            575
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "An autoencoder is a network which implements two transformations - encoder $e n c o d e ( x ) : R ^ { n } \\to$ $R ^ { d }$ and $d e c o d e r ( z ) : R ^ { d } \\to R ^ { n }$ . The “goal” of autoenoder is to obtain $d$ dimensional representation of data such that an error measure between $x$ and $f ( x ) = d e c o d e ( e n c o d e ( x ) )$ is minimized Hinton & Zemel (1994). Figure 1 depicts typical 4-layer autoencoder network. If noise is added to the data during encoding step, the autoencoder is called de-noising. Autoencoder is an excellent tool for dimensionality reduction and can be thought of as a strict generalization of principle component analysis (PCA) Hinton & Salakhutdinov (2006). An autoencoder without non-linear activations and only with “code” layer should be able to learn PCA transformation in the encoder if trained to optimize mean squared error (MSE) loss. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            707
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In our model, both encoder and decoder parts of the autoencoder consist of feed-forward neural networks with classical fully connected layers computing $l = f ( W * x + b )$ , where $f$ is some nonlinear activation function. If range of the activation function is smaller than that of data, the last layer of the decoder should be kept linear. We found it to be very important for activation function $f$ in hidden layers to contain non-zero negative part, and we use SELU units in most of our experiments (see Section 3.2 for details). ",
+        "bbox": [
+            174,
+            714,
+            825,
+            797
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "If decoder mirrors encoder architecture (as it does in our model), then one can constrain decoder’s weights $\\boldsymbol { W } _ { d } ^ { l }$ to be equal to transposed encoder weights $W _ { e } ^ { l }$ from the corresponding layer $l$ . Such autoencoder is called constrained or tied and has almost two times less free parameters than unconstrained one. ",
+        "bbox": [
+            174,
+            805,
+            823,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Forward pass and inference. During forward pass (and inference) the model takes user represented by his vector of ratings from the training set $x \\in R ^ { n }$ , where $n$ is number of items. Note that $x$ is very sparse, while the output of the decoder, $f ( x ) \\in R ^ { n }$ is dense and contains rating predictions for all items in the corpus. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 LOSS FUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            328,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Since it doesn’t make sense to predict zeros in user’s representation vector $x$ , we follow the approach from Sedhain et al. (2015) and optimize Masked Mean Squared Error loss: ",
+        "bbox": [
+            171,
+            130,
+            823,
+            159
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1897d4b1db1749e191b172c3dd7d98ae749d38dd07fd68a752082ec3404f525a.jpg",
+        "text": "$$\nM M S E = \\frac { m _ { i } * ( r _ { i } - y _ { i } ) ^ { 2 } } { \\sum _ { i = 0 } ^ { i = n } m _ { i } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            164,
+            594,
+            203
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $r _ { i }$ is actual rating, $y _ { i }$ is reconstructed, or predicted rating, and $m _ { i }$ is a mask function such that $m _ { i } = 1$ if $r _ { i } \\neq 0$ else $m _ { i } = 0$ . Note that there is a straightforward relation between RMSE score and MMSE score: $R M S E = \\sqrt { M M S E }$ . ",
+        "bbox": [
+            174,
+            207,
+            823,
+            251
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 DENSE RE-FEEDING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            268,
+            354,
+            282
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "During training and inference, an input $x \\in R ^ { n }$ is very sparse because no user can realistically rate but a tiny fractions of all items. This poses problem for model training. Bayesian approches can be used to overcome this issue (Wang et al., 2015). On the other hand, autoencoder’s output $f ( x )$ is dense. Lets consider an idealized scenario with a perfect $f$ . Then $f ( x ) _ { i } = x _ { i } , \\forall i : x _ { i } \\neq 0$ and $f ( { \\boldsymbol { x } } ) _ { i }$ accurately predicts all user’s future ratings for items $i : x _ { i } = 0$ . This means that if user rates new item $k$ (thereby creating a new vector $x ^ { \\prime }$ ) then $f ( x ) _ { k } = x _ { k } ^ { \\prime }$ and $f ( x ) = f ( x ^ { \\prime } )$ . Hence, in this idealized scenario, $y = f ( x )$ should be a fixed point of a well trained autoencoder: $f ( y ) = y$ . ",
+        "bbox": [
+            174,
+            294,
+            825,
+            392
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To explicitly enforce fixed-point constraint and to be able to perform dense training updates, we augment every optimization iteration with an iterative dense re-feeding steps (3 and 4 below) as follows: ",
+        "bbox": [
+            176,
+            398,
+            825,
+            440
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. Given sparse $x$ , compute dense $f ( x )$ and loss using equation 1 (forward pass)   \n2. Compute gradients and perform weight update (backward pass)   \n3. Treat $f ( x )$ as a new example and compute $f ( f ( x ) )$ . Now both $f ( x )$ and $f ( f ( x ) )$ are dense   \nand the loss from equation 1 has all $m$ as non-zeros. (second forward pass)   \n4. Compute gradients and perform weight update (second backward pass) ",
+        "bbox": [
+            210,
+            452,
+            825,
+            539
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Steps (3) and (4) can be also performed more than once for every iteration. ",
+        "bbox": [
+            176,
+            549,
+            663,
+            564
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS AND RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            583,
+            449,
+            599
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 EXPERIMENT SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            614,
+            356,
+            630
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For the rating prediction task, it is often most relevant to predict future ratings given the past ones instead of predicting ratings missing at random. For evaluation purposes we followed Wu et al. (2017) exactly by splitting the original Netflix Prize Bennett et al. (2007) training set into several training and testing intervals based on time. Training interval contains ratings which came in earlier than the ones from testing interval. Testing interval is then randomly split into Test and Validation subsets so that each rating from testing interval has a $50 \\%$ chance of appearing in either subset. Users and items that do not appear in the training set are removed from both test and validation subsets. Table 1 provides details on the data sets.2 ",
+        "bbox": [
+            173,
+            641,
+            825,
+            752
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For most of our experiments we uses a batch size of 128, trained using SGD with momentum of 0.9 and learning rate of 0.001. We used xavier initialization to initialize parameters. Note, that unlike Strub & Mary (2015) we did not use any layer-wise pre-training. We believe that we were able to do so successfully because of choosing the right activation function (see Section 3.2). ",
+        "bbox": [
+            174,
+            760,
+            825,
+            815
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 EFFECTS OF THE ACTIVATION TYPES ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            833,
+            467,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To explore the effects of using different activation functions, we tested some of the most popular choices in deep learning : sigmoid, “rectified linear units” (RELU), $m a x ( r e l u ( x ) , 6 )$ or RELU6, hyperbolic tangent (TANH), “exponential linear units” (ELU) (Clevert et al., 2015), leaky relu (LRELU) (Xu et al., 2015) , “self-gated activation function” (SWISH) (Ramachandran et al., 2017), and “scaled exponential linear units” (Klambauer et al., 2017) (SELU) on the 4 layer autoencoder with 128 units in each hidden layer. Because ratings are on the scale from 1 to 5, we keep last layer of the decoder linear for sigmoid and tanh-based models. In all other models activation function is applied in all layers. ",
+        "bbox": [
+            176,
+            858,
+            823,
+            887
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/09a17f90285f07af06cb356344fc9c7e4c66332e57baa5666e3e4a13acf00cc6.jpg",
+        "image_caption": [
+            "Figure 1: AutoEncoder consists of two neural networks, encoder and decoder, fused together on the “representation” layer $z$ . Encoder has 2 layers $e _ { 1 }$ and $e _ { 2 }$ and decoder has 2 layers $d _ { 1 }$ and $d _ { 2 }$ . Dropout may be applied to coding layer $z$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            212,
+            103,
+            787,
+            388
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/98febd8b2de97993caeb17fa47cd2eb95b84983871e8e9652b9662c8b7406a28.jpg",
+        "table_caption": [
+            "Table 1: Subsets of Netflix Prize training set used in our experiments. We made sure that these splits match exactly the ones used in (Wu et al., 2017). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Full</td><td>3 months</td><td>6 months</td><td>1 year</td></tr><tr><td></td><td></td><td></td><td>06/05-11/05</td><td></td></tr><tr><td>Training Users</td><td>12/99-11/05 477,412</td><td>09/05-11/05 311,315</td><td>390,795</td><td>06/04-05/05 345,855</td></tr><tr><td>Ratings</td><td>98,074,901</td><td>13,675,402</td><td>29,179,009</td><td>41,451,832</td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Testing Users</td><td>12/05</td><td>12/05</td><td>12/05</td><td>06/05</td></tr></table>",
+        "bbox": [
+            259,
+            535,
+            738,
+            679
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            748,
+            825,
+            833
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We found that on this task ELU, SELU and LRELU perform much better than SIGMOID, RELU, RELU6, TANH and SWISH. Figure 2 clearly demonstrates this. There are two properties which seems to separate activations which perform well from those which do not: a) non-zero negative part and b) unbounded positive part. Hence, we conclude, that in this setting these properties are important for successful training. Thus, we use SELU activation units and tune SELU-based networks for performance. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/aec9a2eced5f723ac04e892d3f29d7e2ede096781d457488e2eaddd2ec164ecb.jpg",
+        "image_caption": [
+            "Figure 2: Training RMSE per mini-batch. All lines correspond to 4-layers autoencoder (2 layer encoder and 2 layer decoder) with hidden unit dimensions of 128. Different line colors correspond to different activation functions. TANH and SIGMOID lines are very similar as well as lines for ELU and SELU. The best performing activation functions are ELU and SELU. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            106,
+            816,
+            348
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 OVER-FITTING THE DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            452,
+            388,
+            467
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The largest data set we use for training, “Netflix Full” from Table 1, contains 98M ratings given by 477K users. Number of movies (e.g. items) in this set is $n = 1 7$ , 768. Therefore, the first layer of encoder will have $d * n + d$ weights, where $d$ is number of units in the layer. ",
+        "bbox": [
+            174,
+            478,
+            823,
+            521
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For modern deep learning algorithms and hardware this is relatively small task. If we start with single layer encoders and decoders we can quickly overfit to the training data even for $d$ as small as 512. Figure 3 clearly demonstrates this. Switching from unconstrained autoencoder to constrained reduces over-fitting, but does not completely solve the problem. ",
+        "bbox": [
+            174,
+            527,
+            825,
+            583
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/63b7bb1ea66cdf6bb9ca0bb346e6100321c6a5f1f9ea9693554e275cb0692ba0.jpg",
+        "image_caption": [
+            "Figure 3: Single layer autoencoder with 128, 256, 512 and 1024 hidden units in the coding layer. A: training RMSE per epoch; B: evaluation RMSE per epoch. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            599,
+            825,
+            756
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 GOING DEEPER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            828,
+            320,
+            842
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While making layers wider helps bring training loss down, adding more layers is often correlated with a network’s ability to generalize. In this set of experiments we show that this is indeed the case here. We choose small enough dimensionality $d = 1 2 8$ ) for all hidden layers to easily avoid over-fitting and start adding more layers. Table 2 shows that there is a positive correlation between the number of layers and the evaluation accuracy. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/88fcfcca1263e20a032f9acfaef74ea8491daebbea86756b7bd10814e85b9e95.jpg",
+        "table_caption": [
+            "Table 2: Depth helps generalization. Evaluation RMSE of the models with different number of layers. In all cases the hidden layer dimension is 128. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Number of layers</td><td>Evaluation RMSE</td><td>params</td></tr><tr><td></td><td></td><td></td></tr><tr><td>2</td><td>1.146</td><td>4,566,504</td></tr><tr><td>4</td><td>0.9615</td><td>4,599,528</td></tr><tr><td>6</td><td>0.9378</td><td>4,632,552</td></tr><tr><td>8 10</td><td>0.9364</td><td>4,665,576</td></tr><tr><td>12</td><td>0.9340 0.9328</td><td>4,698,600</td></tr><tr><td></td><td></td><td>4,731,624</td></tr></table>",
+        "bbox": [
+            310,
+            145,
+            687,
+            273
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Going from one layer in encoder and decoder to three layers in both provides good improvement in evaluation RMSE (from 1.146 to 0.9378). After that, blindly adding more layers does help, however it provides diminishing returns. Note that the model with single $d \\ : = \\ : 2 5 6$ layer in encoder and decoder has 9,115,240 parameters which is almost two times more than any of these deep models while having much worse evauation RMSE (above 1.0). ",
+        "bbox": [
+            174,
+            320,
+            825,
+            390
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.5 DROPOUT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            407,
+            284,
+            422
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Section 3.4 shows us that adding too many small layers eventually hits diminishing returns. Thus, we start experimenting with model architecture and hyper-parameters more broadly. Our most promising model has the following architecture: $n , 5 1 2 , 5 1 2 , 1 0 2 4 , 5 1 2 , 5 1 2 , n .$ , which means 3 layers in encoder (512,512,1024), coding layer of 1024 and 3 layers in decoder of size 512,512,n. This model, however, quickly over-fits if trained with no regularization. To regularize it, we tried several dropout values and, interestingly, very high values of drop probability (e.g. 0.8) turned out to be the best. See Figure 4 for evaluation RMSE. We apply dropout on the encoder output only, e.g. $f ( x ) = d e c o d e ( d r o p o u t ( e n c o d e ( x ) ) )$ . We tried applying dropout after every layer of the model but that stifled training convergence and did not improve generalization. ",
+        "bbox": [
+            173,
+            434,
+            825,
+            560
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/1d42da41c3ad8938ff124090a7abb4a7d64268bb5591f52f0509568c13480560.jpg",
+        "image_caption": [
+            "Figure 4: Effects of dropout. Y-axis: evaluation RMSE, X-axis: epoch number. Model with no dropout (Drop Prob 0.0) clearly over-fits. Model with drop probability of 0.5 over-fits as well (but much slowly). Models with drop probabilities of 0.65 and 0.8 result in RMSEs of 0.9192 and 0.9183 correspondingly. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            297,
+            573,
+            699,
+            732
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.6 DENSE RE-FEEDING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            352,
+            856
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Iterative dense re-feeding (see Section 2.2) provides us with additional improvement in evaluation accuracy for our 6-layer-model: $n$ , 512, 512, 1024, $d p ( 0 . 8 )$ , 512, 512, $n$ (referred to as Baseline below). Here each parameter denotes the number of inputs, hidden units, or outputs and $d p ( 0 . 8 )$ is a dropout layer with a drop probability of 0.8. Just applying output re-feeding did not have significant impact on the model performance. However, in conjunction with the higher learning rate, it did significantly increase the model performance. Note, that with this higher learning rate (0.005) but without dense re-feeding, the model started to diverge. See Figure 5 for details. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/89ef14c3de00dd1d762baf07ab626bac7c2f3f10836603e833ad767ad6532fab.jpg",
+        "table_caption": [
+            "Table 3: Test RMSE of different models. I-AR, U-AR and RRN numbers are taken from (Wu et al., 2017) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>DataSet</td><td>I-AR</td><td>U-AR</td><td>RRN</td><td>DeepRec</td></tr><tr><td rowspan=\"3\">Netflix 3 months Netfix Full</td><td></td><td></td><td></td><td></td></tr><tr><td>0.9778</td><td>0.9836</td><td>0.9427</td><td>0.9373</td></tr><tr><td>0.9364</td><td>0.9647</td><td>0.9224</td><td>0.9099</td></tr></table>",
+        "bbox": [
+            294,
+            143,
+            702,
+            218
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            275,
+            825,
+            318
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b589cd81bc68f7c0374d34eb5d18286cf197a9628be19ee2e0751e9faaaf5554.jpg",
+        "image_caption": [
+            "Figure 5: Effects of dense re-feeding. Y-axis: evaluation RMSE, $\\mathbf { X }$ -axis: epoch number. Baseline model was trained with learning rate of 0.001. Applying re-feeding step with the same learning rate almost did not help (Baseline RF). Learning rate of 0.005 (Baseline LR 0.005) is too big for baseline model without re-feeding. However, increasing both learning rate and applying re-feeding step clearly helps (Baseline LR 0.005 RF). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            299,
+            344,
+            694,
+            535
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Applying dense re-feeding and increasing the learning rate, allowed us to further improve the evaluation RMSE from 0.9167 to 0.9100. Picking a checkpoint with best evaluation RMSE and computing test RMSE gives as 0.9099, which we believe is significantly better than other methods. ",
+        "bbox": [
+            176,
+            660,
+            825,
+            702
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.7 COMPARISON WITH OTHER METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            732,
+            473,
+            746
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare our best model with Recurrent Recommender Network from Wu et al. (2017) which has been shown to outperform PMF (Mnih & Salakhutdinov, 2008), T-SVD (Koren, 2010) and I/UAR (Sedhain et al., 2015) on the data we use (see Table 1 for data description). Note, that unlike T-SVD and RRN, our method does not explicitly take into account temporal dynamics of ratings. Yet, Table 3 shows that it is still capable of outperforming these methods on future rating prediction task. We train each model using only the training set and compute evaluation RMSE for 100 epochs. Then the checkpoint with the highest evaluation RMSE is tested on the test set. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "“Netflix 3 months” has 7 times less training data compared to “Netflix full”, it is therefore, not surprising that the model’s performance is significantly worse if trained on this data alone (0.9373 vs 0.9099). In fact, the model that performs best on “Netflix full” over-fits on this set, and we had to reduce the model’s complexity accordingly (see Table 4 for details). ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/89907b1ebad481827acd0332cbbaef5f201eabc2a54538f92e01b86f1cd34677.jpg",
+        "table_caption": [
+            "Table 4: Test RMSE achieved by DeepRec on different Netflix subsets. All models are trained with one iterative output re-feeding step per each iteration. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>DataSet</td><td>RMSE</td><td>Model Architecture</td></tr><tr><td></td><td></td><td></td></tr><tr><td>Netflix 3 months</td><td>0.9373</td><td>n,128,256,256,dp(0.65),256,128,n</td></tr><tr><td>Netflix 6 months</td><td>0.9207</td><td>n,256,256,512,dp(0.8),256,256,n</td></tr><tr><td>Netflix 1 year</td><td>0.9225</td><td>n,256,256,512,dp(0.8),256,256, n</td></tr><tr><td>Netfix Full</td><td>0.9099</td><td>n,512,512,1024,dp(0.8),512,512, n</td></tr></table>",
+        "bbox": [
+            263,
+            145,
+            733,
+            247
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            290,
+            320,
+            306
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Deep learning has revolutionized many areas of machine learning, and it is poised do so with recommender systems as well. In this paper we demonstrated how very deep autoencoders can be successfully trained even on relatively small amounts of data by using both well established (dropout) and relatively recent (“scaled exponential linear units”) deep learning techniques. Further, we introduced iterative output re-feeding - a technique which allowed us to perform dense updates in collaborative filtering, increase learning rate and further improve generalization performance of our model. On the task of future rating prediction, our model outperforms other approaches even without using additional temporal signals. ",
+        "bbox": [
+            174,
+            321,
+            825,
+            434
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While our code supports item-based model (such as I-AutoRec) we argue that this approach is less practical than user-based model (U-AutoRec). This is because in real-world recommender systems, there are usually much more users then items. Finally, when building personalized recommender system and faced with scaling problems, it can be acceptable to sample items but not users. ",
+        "bbox": [
+            174,
+            440,
+            825,
+            497
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            513,
+            326,
+            526
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We thank the author of (Wu et al., 2017), Chao-Yuan Wu, for fruitfull discussion and help validating our data sets. ",
+        "bbox": [
+            176,
+            536,
+            823,
+            564
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            585,
+            285,
+            602
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Gediminas Adomavicius and Alexander Tuzhilin. Context-aware recommender systems. In Recommender systems handbook, pp. 217–253. Springer, 2011. ",
+        "bbox": [
+            174,
+            609,
+            821,
+            638
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "James Bennett, Stan Lanning, and Netflix Netflix. The netflix prize. In In KDD Cup and Workshop in conjunction with KDD, 2007. ",
+        "bbox": [
+            173,
+            647,
+            823,
+            676
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "John S. Breese, David Heckerman, and Carl Kadie. Empirical analysis of predictive algorithms for collaborative filtering. In Proceedings of the Fourteenth Conference on Uncertainty in Artificial Intelligence, UAI’98, pp. 43–52, San Francisco, CA, USA, 1998. Morgan Kaufmann Publishers Inc. ISBN 1-55860-555-X. URL http://dl.acm.org/citation.cfm?id=2074094. 2074100. ",
+        "bbox": [
+            173,
+            685,
+            825,
+            756
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Djork-Arne Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network´ learning by exponential linear units (elus). arXiv preprint arXiv:1511.07289, 2015. ",
+        "bbox": [
+            171,
+            765,
+            823,
+            795
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Xiangnan He, Lizi Liao, Hanwang Zhang, Liqiang Nie, Xia Hu, and Tat-Seng Chua. Neural collaborative filtering. In Proceedings of the 26th International Conference on World Wide Web, pp. 173–182. International World Wide Web Conferences Steering Committee, 2017. ",
+        "bbox": [
+            176,
+            804,
+            821,
+            848
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton and Ruslan R Salakhutdinov. Reducing the dimensionality of data with neural networks. science, 313(5786):504–507, 2006. ",
+        "bbox": [
+            174,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton and Richard S. Zemel. Autoencoders, minimum description length and helmholtz free energy. In J. D. Cowan, G. Tesauro, and J. Alspector (eds.), Advances in Neural Information Processing Systems 6, pp. 3– 10. Morgan-Kaufmann, 1994. URL http://papers.nips.cc/paper/ 798-autoencoders-minimum-description-length-and-helmholtz-free-energy. pdf. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            187,
+            103,
+            879,
+            160
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hyunsoo Kim and Haesun Park. Nonnegative matrix factorization based on alternating nonnegativity constrained least squares and active set method. SIAM journal on matrix analysis and applications, 30(2):713–730, 2008. ",
+        "bbox": [
+            176,
+            169,
+            825,
+            212
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gunter Klambauer, Thomas Unterthiner, Andreas Mayr, and Sepp Hochreiter. Self-normalizing ¨ neural networks. arXiv preprint arXiv:1706.02515, 2017. ",
+        "bbox": [
+            174,
+            219,
+            823,
+            250
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yehuda Koren. The bellkor solution to the netflix grand prize. Netflix prize documentation, 81:1–10, 2009. ",
+        "bbox": [
+            174,
+            257,
+            823,
+            287
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yehuda Koren. Collaborative filtering with temporal dynamics. Communications of the ACM, 53 (4):89–97, 2010. ",
+        "bbox": [
+            174,
+            295,
+            823,
+            325
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yehuda Koren, Robert Bell, and Chris Volinsky. Matrix factorization techniques for recommender systems. Computer, 42(8), 2009. ",
+        "bbox": [
+            174,
+            333,
+            823,
+            363
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015. ",
+        "bbox": [
+            173,
+            371,
+            823,
+            401
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sheng Li, Jaya Kawale, and Yun Fu. Deep collaborative filtering via marginalized denoising autoencoder. In Proceedings of the 24th ACM International on Conference on Information and Knowledge Management, pp. 811–820. ACM, 2015. ",
+        "bbox": [
+            174,
+            409,
+            823,
+            452
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andriy Mnih and Ruslan R Salakhutdinov. Probabilistic matrix factorization. In Advances in neural information processing systems, pp. 1257–1264, 2008. ",
+        "bbox": [
+            173,
+            460,
+            823,
+            489
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Prajit Ramachandran, Barret Zoph, and Quoc V Le. Swish: a self-gated activation function. arXiv preprint arXiv:1710.05941, 2017. ",
+        "bbox": [
+            174,
+            497,
+            821,
+            527
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Francesco Ricci, Lior Rokach, and Bracha Shapira. Introduction to recommender systems handbook. In Recommender systems handbook, pp. 1–35. Springer, 2011. ",
+        "bbox": [
+            173,
+            535,
+            823,
+            565
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ruslan Salakhutdinov, Andriy Mnih, and Geoffrey Hinton. Restricted boltzmann machines for collaborative filtering. In Proceedings of the 24th international conference on Machine learning, pp. 791–798. ACM, 2007. ",
+        "bbox": [
+            173,
+            573,
+            823,
+            617
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Suvash Sedhain, Aditya Krishna Menon, Scott Sanner, and Lexing Xie. Autorec: Autoencoders meet collaborative filtering. In Proceedings of the 24th International Conference on World Wide Web, pp. 111–112. ACM, 2015. ",
+        "bbox": [
+            173,
+            625,
+            823,
+            667
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Florian Strub and Jer´ emie Mary. Collaborative filtering with stacked denoising autoencoders and ´ sparse inputs. In NIPS workshop on machine learning for eCommerce, 2015. ",
+        "bbox": [
+            169,
+            676,
+            823,
+            707
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hao Wang, Naiyan Wang, and Dit-Yan Yeung. Collaborative deep learning for recommender systems. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 1235–1244. ACM, 2015. ",
+        "bbox": [
+            174,
+            714,
+            823,
+            758
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chao-Yuan Wu, Amr Ahmed, Alex Beutel, Alexander J. Smola, and How Jing. Recurrent recommender networks. In Proceedings of the Tenth ACM International Conference on Web Search and Data Mining, WSDM ’17, pp. 495–503, New York, NY, USA, 2017. ACM. ISBN 978- 1-4503-4675-7. doi: 10.1145/3018661.3018689. URL http://doi.acm.org/10.1145/ 3018661.3018689. ",
+        "bbox": [
+            174,
+            766,
+            825,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bing Xu, Naiyan Wang, Tianqi Chen, and Mu Li. Empirical evaluation of rectified activations in convolutional network. arXiv preprint arXiv:1505.00853, 2015. ",
+        "bbox": [
+            173,
+            844,
+            821,
+            875
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yin Zheng, Bangsheng Tang, Wenkui Ding, and Hanning Zhou. A neural autoregressive approach to collaborative filtering. arXiv preprint arXiv:1605.09477, 2016. ",
+        "bbox": [
+            174,
+            883,
+            823,
+            912
+        ],
+        "page_idx": 8
+    }
+]

parse/train/SyzVb3CcFX/SyzVb3CcFX.md

@@ -0,0 +1,390 @@
+# TIME-AGNOSTIC PREDICTION: PREDICTING PREDICTABLE VIDEO FRAMES
+
+Dinesh Jayaraman UC Berkeley
+
+Frederik Ebert UC Berkeley
+
+Alyosha Efros UC Berkeley
+
+Sergey Levine UC Berkeley
+
+# ABSTRACT
+
+Prediction is arguably one of the most basic functions of an intelligent system. In general, the problem of predicting events in the future or between two waypoints is exceedingly difficult. However, most phenomena naturally pass through relatively predictable bottlenecks—while we cannot predict the precise trajectory of a robot arm between being at rest and holding an object up, we can be certain that it must have picked the object up. To exploit this, we decouple visual prediction from a rigid notion of time. While conventional approaches predict frames at regularly spaced temporal intervals, our time-agnostic predictors (TAP) are not tied to specific times so that they may instead discover predictable “bottleneck” frames no matter when they occur. We evaluate our approach for future and intermediate frame prediction across three robotic manipulation tasks. Our predictions are not only of higher visual quality, but also correspond to coherent semantic subgoals in temporally extended tasks.
+
+# 1 INTRODUCTION
+
+Imagine taking a bottle of water and laying it on its side. Consider what happens to the surface of the water as you do this: which times can you confidently make predictions about? The surface is initially flat, then becomes turbulent, until it is flat again, as shown in Fig 1. Predicting the exact shape of the turbulent liquid is extremely hard, but its easy to say that it will eventually settle down.
+
+Prediction is thought to be fundamental to intelligence (Bar, 2009; Clark, 2013; Hohwy, 2013). If an agent can learn to predict the future, it can take anticipatory actions, plan through its predictions, and use prediction as a proxy for representation learning. The key difficulty in prediction is uncertainty. Visual prediction approaches attempt to mitigate uncertainty by predicting iteratively in heuristically chosen small timesteps, such as, say, $0 . 1 s$ . In the bottle-tilting case, such approaches generate blurry images of the chaotic states at $t = 0 . 1 s , 0 . 2 s , . . . ,$ , and this blurriness compounds to make predictions unusable within a few steps. Sophisticated probabilistic approaches have been proposed to better handle this uncertainty (Babaeizadeh et al., 2018; Lee et al., 2018; Denton & Fergus, 2018; Xue et al., 2016).
+
+What if we instead change the goal of our prediction models? Fixed time intervals in prediction are in many ways an artifact of the fact that cameras and monitors record and display video at fixed frequencies. Rather than requiring predictions at regularly spaced future frames, we ask: if a frame prediction is treated as a bet on that frame occurring at some future point, what should we predict? Such time-agnostic prediction (TAP) has two immediate effects: (i) the predictor may skip more uncertain states in favor of less uncertain ones, and (ii) while in the standard approach, a prediction is wrong if it occurs at $t \pm \epsilon$ rather than at $t$ , our formulation considers such predictions equally correct.
+
+Recall the bottle-tilting uncertainty profile. Fig 1 depicts uncertainty profiles for several other prediction settings, including both forward/future prediction (given a start frame) and intermediate prediction (given start and end frames). Our time-agnostic reframing of the prediction problem targets the minima of these profiles, where prediction is intuitively easiest. We refer to these minima states as “bottlenecks.”
+
+At this point, one might ask: are these “easy” bottlenecks actually useful to predict? Intuitively, bottlenecks naturally correspond to reliable subgoals—an agent hoping to solve the maze in Fig 1 (e) would do well to target its bottlenecks as subgoals. In our experiments, we evaluate the usefulness of our predictions as subgoals in simulated robotic manipulation tasks.
+
+![](images/92f28243dd5787bef0b1258b64d2a01ce30a0854c5c61a880096ebae7320225f.jpg)  
+Figure 1: (a) Over time as the bottle is tilted, the uncertainty first rises and then falls as the bottle is held steady after tilting. (b)-(e) Similar uncertainty profiles corresponding to various scenarios—a ball rolling down the side of a bowl, a car driving on a highway with an exit $1 0 0 \mathrm { m }$ away, an iron pellet tossed in the direction of a magnet, and intermediate frame prediction in a maze traversal given start and end states. The red asterisks along the $\mathbf { X } ^ { } -$ -axis correspond to the asterisks in the maze—these “bottleneck” states must occur in any successful traversal.
+
+Our main contributions are: (i) we reframe the video prediction problem to be time-agnostic, (ii) we propose a novel technical approach to solve this problem, (iii) we show that our approach effectively identifies “bottleneck states” across several tasks, and (iv) we show that these bottlenecks correspond to subgoals that aid in planning towards complex end goals.
+
+# 2 RELATED WORK
+
+Visual prediction approaches. Prior visual prediction approaches regress directly to future video frames in the pixel space (Ranzato et al., 2014; Oh et al., 2015) or in a learned feature space (Hadsell et al., 2006; Mobahi et al., 2009; Jayaraman & Grauman, 2015; Wang et al., 2016; Vondrick et al., 2016b; Kitani et al., 2012). The success of generative adversarial networks (GANs) (Goodfellow et al., 2014; Mirza & Osindero, 2014; Radford et al., 2015; Isola et al., 2017) has inspired many video prediction approaches (Mathieu et al., 2015; Vondrick et al., 2016a; Finn & Levine, 2017; Xue et al., 2016; Oh et al., 2015; Ebert et al., 2017; Finn et al., 2016; Larsen et al., 2016; Lee et al., 2018). While adversarial losses aid in producing photorealistic image patches, prediction has to contend with a more fundamental problem: uncertainty. Several approaches (Walker et al., 2016; Xue et al., 2016; Denton & Fergus, 2018; Lee et al., 2018; Larsen et al., 2016; Babaeizadeh et al., 2018) exploit conditional variational autoencoders (VAE) (Kingma & Welling, 2013) to train latent variable models for video prediction. Pixel-autoregression (Oord et al., 2016; van den Oord et al., 2016; Kalchbrenner et al., 2016) explicitly factorizes the joint distribution over all pixels to model uncertainty, at a high computational cost.
+
+Like these prior approaches, we too address the uncertainty problem in video prediction. We propose a general time-agnostic prediction (TAP) framework for prediction tasks. While all prior work predicts at fixed time intervals, we aim to identify inherently low-uncertainty bottleneck frames with no associated timestamp. We show how TAP may be combined with conditional GANs as well as VAEs, to handle the residual uncertainty in its predictions.
+
+Bottlenecks. In hierarchical reinforcement learning, bottlenecks are proposed for discovery of options (Sutton et al., 1999) in low-dimensional state spaces in (McGovern & Barto, 2001; S¸ ims¸ek & Barto, 2009; Bacon, 2013; Metzen, 2013). Most approaches (S¸ims¸ek & Barto, 2009; Bacon, 2013; Metzen, 2013) construct full transition graphs and apply notions of graph centrality to locate bottlenecks. A multi-instance learning approach is applied in (McGovern & Barto, 2001) to mine states that occur in successful trajectories but not in others. We consider the use of our bottleneck predictions as subgoals for a hierarchical planner, which is loosely related to options in that both aim to break down temporally extended trajectories into more manageable chunks. Unlike these prior works, we use predictability to identify bottlenecks, and apply this to unlabeled high-dimensional visual state trajectories.
+
+Concurrently with us, Neitz et al. (2018) also propose a similar idea that allows a predictor to select when to predict, and their experiments demonstrate its advantages in specially constructed tasks with clear bottlenecks. In comparison, we propose not just the basic time-agnostic loss (Sec 3.1), but also improvements in Sec 3.2 through 3.5 that allow time-agnostic prediction to work in more general tasks such as synthetic and real videos of robotic object manipulation. Our experiments also test the quality of discovered bottlenecks in these scenarios and their usefulness as subgoals for hierarchical planning.
+
+# 3 TIME-AGNOSTIC PREDICTION OF BOTTLENECK FRAMES
+
+In visual prediction, the goal is to predict a set of unobserved target video frames given some observed context frames. In forward prediction, the context is the first frame, and the target is all future frames. In the bidirectionally conditioned prediction case, the context is the first and the last frame, and the frames in between are the target. In Fig 1, we may wish to predict future images of the tilting bottle, or intermediate images of an agent who traverses the maze successfully.
+
+# 3.1 MINIMUM-OVER-TIME LOSS
+
+In standard fixed-time video prediction models (Ranzato et al., 2014; Oh et al., 2015; Mathieu et al., 2015; Vondrick et al., 2016a; Walker et al., 2016; Finn & Levine, 2017; Xue et al., 2016; Oh et al., 2015; Ebert et al., 2017; Finn et al., 2016; Lee et al., 2018; Denton & Fergus, 2018), a frame $x _ { \tau }$ (video frame at time $\tau$ ) is selected in advance to be the training target for some given input frames $c$ . For instance, in a
+
+![](images/553b16ffacea6fe1931de7a05f2cd5a1dc88cc89a9ebb774a469ea6e63d25d18.jpg)  
+Figure 2: The TAP minimum-over time loss.
+
+typical forward prediction setup, the input may be $c = x _ { 0 }$ , and the target frame may be set to $x _ { \tau } = x _ { 1 }$ A predictor $G$ takes context frames $c$ as input and produces a single frame $G ( c )$ . $G$ is trained as:
+
+$$
+G ^ { * } = \underset { G } { \arg \operatorname* { m i n } } \mathcal { L } _ { 0 } ( G ) = \underset { G } { \arg \operatorname* { m i n } } \mathcal { E } ( G ( c ) , x _ { \tau } ) ,
+$$
+
+where $\mathcal { E }$ is a measure of prediction error, such as $\| G ( c ) - x _ { \tau } \| _ { 1 }$ .1 This predictor may be applied recursively at test time to generate more predictions as ${ \dot { G } } ( G ( c ) ) , G ( G ( G ( c ) ) )$ , and so on.
+
+We propose to depart from this fixed-time paradigm by decoupling prediction from a rigid notion of time. Instead of predicting the video frame at a specified time $\tau$ , we propose to predict predictable bottleneck video frames through a time-agnostic predictor (TAP), as motivated in Sec 1. To train this predictor, we minimize the following “minimum-over-time” loss:
+
+$$
+G ^ { * } = \underset { G } { \arg \operatorname* { m i n } } \ : \mathcal { L } ( G ) = \underset { G } { \arg \operatorname* { m i n } } \ : \underset { t \in \mathrm { T } } { \operatorname* { m i n } } \ : \mathcal { E } ( G ( c ) , x _ { t } ) ,
+$$
+
+where the key difference from $\mathrm { E q ~ } 1$ is that the loss is now a minimum over target times of a timeindexed error $\mathcal { E } _ { t } = \mathcal { E } ( \cdot , x _ { t } )$ . The target times are defined by a set of time indices T. For forward prediction starting from input $c = x _ { 0 }$ , we may set targets to $\mathrm { T } = \{ 1 , 2 , \ldots \}$ . Fig 2 depicts this idea schematically. Intuitively, the penalty for a prediction is determined based on the closest matching ground truth target frame. This loss incentivizes the model to latch on to “bottleneck” states in the video, i.e., those with low uncertainty. In the bottle-tilting example, this would mean producing an image of the bottle after the water has come to rest.
+
+One immediate concern with this minimum-over-time TAP loss might be that it could produce degenerate predictions very close to the input conditioning frames $c$ . However, as in the tilting bottle and other cases in Fig 1, uncertainty is not always lowest closest to the observed frames. Moreover, target frame indices $\mathrm { T }$ are always disjoint from the input context frames, so the model’s prediction must be different from input frames by at least one step, which is no worse than the one-step-forward prediction of Eq 1. In our experiments, we show cases where the minimum-over-time loss above captures natural bottlenecks successfully. Further, Sec 3.2 shows how it is also possible to explicitly penalize predictions near input frames $c$ .
+
+This minimum loss may be viewed as adaptively learning the time offset $\tau$ , but in fact, the predictor’s task is even simpler since it is not required to provide a timestamp accompanying its prediction. For example, in Fig 1(e), it need only specify which points in the maze the agent will go through; it need not specify when. Lifting the requirement of a timestamped prediction relieves TAP approaches of a significant implicit burden.
+
+Recursive TAP. TAP models may also be trained for recursive prediction, by minimizing the following loss:
+
+$$
+G ^ { * } = \underset { G } { \arg \operatorname* { m i n } } \mathcal L _ { \mathrm { r e c } } ( G ) = \underset { G } { \arg \operatorname* { m i n } } \sum _ { r } \underset { t \in \mathrm { T } ( r ) } { \min } \mathcal { E } ( G ( c ( r ) ) , x _ { t } ) ,
+$$
+
+where $c ( r )$ and $\mathrm { T } ( r )$ are the input and target set at recursion level $r$ , both dynamically adapted based on the previous prediction. The input $c ( r )$ may be set to the previous prediction $G ( c ( r - 1 ) )$ , so that the sequence of predictions is $( G ( c ( 0 ) ) , G ( G ( c ( 0 ) ) ) , \dots )$ . $\mathrm { T } ( r )$ is set to target all times after the last prediction. In other words, if the prediction at $r = 0$ was closest to frame $x _ { 5 }$ , the targets for $r = 1$ are set to $\mathrm { T } ( 1 ) = \{ 6 , 7 , \ldots \}$ . While we also test recursive TAP in Sec 4, in the rest of this section, we discuss the non-recursive formulation, building on $\operatorname { E q } 2$ , for simplicity.
+
+Bidirectional TAP. Finally, while the above description of TAP has focused on forward prediction, the TAP loss of Eq 2 easily generalizes to bidirectional prediction. Given input frames $c = ( x _ { 0 } , x _ { \mathrm { l a s t } } )$ , fixed-time bidirectional predictors might target, say, the middle frame $x _ { \tau } = x _ { \mathrm { l a s t / 2 } }$ . Instead, bidirectional TAP models target all intermediate frames, i.e., $\mathrm { T } = \{ 1 , 2 , . . . , \mathrm { l a s t } - 1 \}$ in Eq 2. As in forward prediction, the model has incentive to predict predictable frames. In the maze example from Fig 1, this would mean producing an image of the agent at one of the asterisks.
+
+# 3.2 FROM MINIMUM TO GENERALIZED MINIMUM TAP LOSS
+
+Within the time-agnostic prediction paradigm, we may still want to specify preferences for some times over others, or for some visual properties of the predictions. Consider the minimum-over-time loss $\mathcal { L }$ in Eq 2. Taking the minimum inside, this may be rewritten as:
+
+$$
+{ \mathcal { L } } ( G ) = \operatorname* { m i n } _ { t \in T } { \mathcal { E } } _ { t } = { \mathcal { E } } _ { \arg \operatorname* { m i n } _ { t \in T } { \mathcal { E } } _ { t } } ,
+$$
+
+where we use the time-indexed error $\mathcal { E } _ { t }$ as shorthand for $\mathcal { E } ( . , x _ { t } )$ . We may now extend this to the following “generalized minimum” loss, where the outer and inner errors are decoupled:
+
+$$
+\begin{array} { r } { \mathcal { L } ^ { \prime } ( G ) = \mathcal { E } _ { \mathrm { a r g m i n } _ { t \in T } } \mathcal { E } _ { t } ^ { \prime } . } \end{array}
+$$
+
+Now, $\mathcal { E } _ { t } ^ { \prime }$ , over which the minimum is computed, could be designed to express preferences about which frames to predict. In the simplest case, $\mathcal { E } _ { t } ^ { \prime } = \mathcal { E } _ { t }$ , and the loss reduces to $\operatorname { E q } 2$ . Instead, suppose that predictions at some times are preferred over others. Let $w ( t )$ express the preference value for all target times $t \in T$ , so that higher $w ( t )$ indicates higher preference. Then we may set $\mathcal { E } _ { t } ^ { \prime } = \mathcal { E } _ { t } / w ( t )$ so that times $t$ with higher $w ( t )$ are preferred in the arg min. In our experiments, we set $w ( t )$ to linearly increase with time during forward prediction and to a truncated discrete Gaussian centered at the midpoint in bidirectional prediction.
+
+At this point, one might ask: could we not directly incorporate preferences into the outer error? For instance, why not simply optimize $\mathrm { m i n } _ { t } \mathcal { E } _ { t } / w ( t ) ^ { \star }$ ? Unfortunately, that would have the sideeffect of downweighting the errors computed against frames with higher preferences $w ( t )$ , which is counterproductive. Decoupling the outer and inner errors instead, as in $\operatorname { E q } 5$ , allows applying preferences $w ( t )$ only to select the target frame to compute the outer loss against; the outer loss itself penalizes prediction errors equally regardless of which frame was selected.
+
+The generalized minimum formulation may be used to express other kinds of preferences too. For instance, when using predictions as subgoals in a planner, perhaps some states are more expensive to reach than others. We also use the generalized minimum to select frames using different criteria than the prediction penalty itself, as we will discuss in Sec 3.5.
+
+# 3.3 TIME-AGNOSTIC CONDITIONAL GANS
+
+TAP is not limited to simple losses such as $\ell _ { 1 }$ or $\ell _ { 2 }$ errors; it can be extended to handle expressive GAN losses to improve perceptual quality. A standard conditional GAN (CGAN) in fixed-time video prediction targeting time $\tau$ works as follows: given a “discriminator” $D$ that outputs 0 for input-prediction tuples and 1 for input-ground truth tuples, the generator $G$ is trained to fool the discriminator. The discriminator in turn is trained adversarially using a binary cross-entropy loss. The CGAN objective is written as:
+
+$$
+\begin{array} { r l } & { G ^ { * } = \underset { G } { \arg \operatorname* { m i n } } \ \underset { D } { \operatorname* { m a x } } \mathcal { L } _ { \mathrm { c g a n } } ( G , D ) , } \\ & { } \\ & { \mathcal { L } _ { \mathrm { c g a n } } ( G , D ) = \log ( D ( c , x _ { \tau } ) ) + \log ( 1 - D ( c , G ( c ) ) } \end{array}
+$$
+
+To make this compatible with TAP, we train $| \mathrm { T } |$ discriminators $\{ D _ { t } \}$ , one per timestep. Then, analogous to $\operatorname { E q } 2$ , we may define a time-agnostic CGAN loss:
+
+$$
+\begin{array} { r l } & { G ^ { * } = \underset { G } { \arg \operatorname* { m i n } } \underset { t \in T } { \operatorname* { m i n } } \underset { D _ { t } } { \operatorname* { m a x } } \mathcal { L } _ { \mathrm { c g a n } } ^ { t } ( G , D _ { t } ) , } \\ & { \mathcal { L } _ { \mathrm { c g a n } } ^ { t } ( G , D _ { t } ) = \log D _ { t } ( c , x _ { t } ) + \log ( 1 - D _ { t } ( c , G ( c ) ) ) + \underset { t ^ { \prime } \neq t } { \sum } \log ( 1 - D _ { t } ( c , x _ { t ^ { \prime } } ) ) , } \end{array}
+$$
+
+Like $\mathrm { E q } 6 , \mathrm { E q } 7$ defines a cross-entropy loss. The first two terms are analogous to $\operatorname { E q } 6$ — for the $t$ -th discriminator, the $t$ -th frame provides a positive, and the generated frame provides a negative instance. The third term treats ground truth video frames occurring at other times $x _ { t ^ { \prime } \neq t }$ as negatives. In practice, we train a single discriminator network with $| T |$ outputs that serve as $\{ D _ { t } \}$ . Further, for computational efficiency, we approximate the summation over $t ^ { \prime } \neq t$ by sampling a single frame at random for each training video at each iteration. Appendix A provides additional details.
+
+# 3.4 TIME-AGNOSTIC CONDITIONAL VAES
+
+While TAP targets low-uncertainty bottleneck states, it may be integrated with a conditional variational autoencoder (CVAE) to handle residual uncertainty at these bottlenecks. In typical fixed-time CVAE predictors targeting time $\tau$ , variations in a latent code $z$ input to a generator $G ( c , z )$ must capture stochasticity in $x _ { \tau }$ . At training time, $z$ is sampled from a posterior distribution $q _ { \phi } ( z | x _ { \tau } )$ with parameters $\phi$ , represented by a neural network. At test time, $z$ is sampled from a prior $p ( z )$ . The training loss combines a log-likelihood term with a KL-divergence from the prior:
+
+$$
+\begin{array} { r } { \mathcal { L } _ { \mathrm { c v a e } } ( G , \phi ) = D _ { K L } ( q _ { \phi } ( z | x _ { \tau } ) , p ( z ) ) - \mathbb { E } _ { z \sim q _ { \phi } ( z | x _ { \tau } ) } \ln p _ { G } ( x _ { \tau } | c , z ) , } \end{array}
+$$
+
+where we might set $p _ { G }$ to a Laplacian distribution such that the second term reduces to a $l 1$ - reconstruction loss $- \ln p _ { G } ( x _ { \tau } | \bar { c , { z } } ) = \| \boldsymbol { G } ( c , { z } ) - \boldsymbol { x } _ { \tau } \| _ { 1 }$ . In a time-agnostic CVAE, rather than capturing stochasticity at a fixed time $\tau$ , $z$ must now capture stochasticity at bottlenecks: e.g., when the agent crosses one of the asterisks in the maze of $\mathrm { F i g ~ 1 }$ , which pose is it in? The bottleneck’s time index varies and is not known in advance. For computational reasons (see Appendix B), we pass the entire video $X$ into the inference network $q _ { \phi }$ , similar to Babaeizadeh et al. (2018). The negative log-likelihood term is adapted to be a minimum-over-time:
+
+$$
+\mathcal { L } _ { \mathrm { c v a e } } ( G , \phi ) = D _ { K L } ( q _ { \phi } ( z | X ) , p ( z ) ) + \operatorname* { m i n } _ { t \in \mathbb { T } } \mathbb { E } _ { z \sim q _ { \phi } ( z | X ) } \left[ - \ln p _ { G } ( x _ { t } | c , z ) \right] .
+$$
+
+# 3.5 COMBINED LOSS, NETWORK ARCHITECTURE, AND TRAINING
+
+We train time-agnostic CVAE-GANs with the following combination of a generalized minimum loss (Sec 3.2) and the CVAE KL divergence loss (Sec 3.4):
+
+$$
+\begin{array} { r l } & { G ^ { * } = \underset { G } { \arg \operatorname* { m i n } } \underset { \phi } { \operatorname* { m i n } } \left[ D _ { K L } ( q _ { \phi } ( \boldsymbol { z } | \boldsymbol { X } ) , p ( \boldsymbol { z } ) ) + \mathcal { E } _ { \mathrm { a r g } \operatorname* { m i n } _ { t \in \mathbb { T } } } \varepsilon _ { t } ^ { \prime } \right] , } \\ & { \mathcal { E } _ { t } = \underset { D , D ^ { \prime } } { \operatorname* { m a x } } \mathcal { L } _ { \mathrm { c g a n } } ^ { t } ( G , D _ { t } ) + \mathcal { L } _ { \mathrm { c v a e - g a n } } ^ { t } ( G , D _ { t } ^ { \prime } ) + \| G ( \boldsymbol { c } , \boldsymbol { z } ) - x _ { t } \| _ { 1 } , } \\ & { \mathcal { E } _ { t } ^ { \prime } = \| G ( \boldsymbol { c } , \boldsymbol { z } ) - x _ { t } \| _ { 1 } / w ( t ) . } \end{array}
+$$
+
+The outer error $\mathcal { E } _ { t }$ absorbs the CGAN discriminator errors (Sec 3.3), while the inner error $\mathcal { E } _ { t } ^ { \prime }$ is a simple $\ell _ { 1 }$ error, weighted by user-specified time preferences $w ( t )$ (Sec 3.2). Omitting GAN error terms in $\mathcal { E } _ { t } ^ { \prime }$ helps stabilize training, since learned errors may not always be meaningful especially includesthe prior early on in training. As in VAE-GANs (Larsen et al., 2016; Lee et al., 2018), the training objective w term , while $\mathcal { L } _ { \mathrm { c v a e - g a n } } ^ { t }$ , analogous to instead sample $\mathcal { L } _ { \mathrm { c g a n } } ^ { t }$ (Eq 7). We set om the posterior $\mathcal { L } _ { \mathrm { c g a n } } ^ { t }$ to use samples , and employs s $z$ fromarate $p ( z )$ $\mathcal { L } _ { \mathrm { c v a e - g a n } } ^ { t }$ $z$ $q _ { \phi } ( z | X )$ discriminators $\{ D _ { t } ^ { \prime } \}$ . The $\ell _ { 1 }$ loss also samples $z$ from the posterior. We omit expectations over the VAE latent $z$ to keep notation simple.
+
+Frame generation in the predictor involves first generating appearance flow-transformed input frames (Zhou et al., 2016) and a frame with new uncopied pixels. These frames are masked and averaged to produce the output. Full architecture and training details are in Appendix C.
+
+![](images/5770695687526489da2068203ed0e833315b117d7b1003431ea451379f1cd9f3.jpg)  
+Figure 3: (Best seen in pdf) One sample episode each for grasping, pick-andplace, and pushing. Time overlaid on each frame.
+
+![](images/c276a2df0e0bfd87996b9ced2d4c7e08dda70fc8eb2ef52b070ed396f8e3d0f5.jpg)  
+Figure 4: Forward prediction $\ell _ { 1 }$ error for grasping. TAP methods (red) perform better than fixedtime predictors over all time steps.
+
+# 4 EXPERIMENTS
+
+We have proposed a time-agnostic prediction (TAP) paradigm that is different from the fixed-time paradigm followed in prior prediction work. In our experiments, we focus on comparing TAP against a representative fixed-time prediction model, keeping network architectures fixed. We use three simulated robot manipulation settings: object grasping ( $5 0 \mathrm { k }$ episodes), pick-and-place $7 5 \mathrm { k }$ episodes), and multi-object pushing (55k episodes). Example episodes from each task are shown in Fig 3 (videos in Supp). $5 \%$ of the data is set aside for testing. We use $6 4 \times 6 4$ images.
+
+For grasping (15 frames per episode), the arm moves to a single object on a table, selects a grasp, and lifts it vertically. For pick-and-place (20 frames), the arm additionally places the lifted object at a new position before performing a random walk. For pushing (40 frames), two objects are initialized at random locations and pushed to random final positions. Object shapes and colors in all three settings are randomly generated. Fig 3 shows example episodes.
+
+Forward prediction. First, we evaluate our approach for forward prediction on grasping. The first frame (“start”) is provided as input. We train fixed-time baselines (architecture same as ours, using $\ell _ { 1 }$ and GAN losses same as MIN and GENMIN) that target predictions at exactly 0.25, 0.50, 0.75, 1.0 fraction of the episode length (FIX0.25,. . . , FIX1.00). MIN and GENMIN are TAP with/without the generalized minimum of ${ \tt S e c 3 . 2 }$ . For GENMIN, we evaluate different choices of the time preference vector $w ( t )$ (Sec 3.2). We set $w ( t ) = \beta + t / 1 5$ , so that our preference increases linearly from $\beta$ to $\beta + 1$ . Since $w ( t )$ applies multiplicatively, low $\beta$ corresponds to high disparity in preferences $\beta = \infty$ reduces to MIN, i.e., no time preference). GENMIN2 is our approach with $\beta = 2$ and so on.
+
+Fig 5 shows example predictions from all methods for the grasping task. In terms of visual quality of predictions and finding a semantically coherent bottleneck, GENMIN2, GENMIN4, and GENMIN7 perform best—they reliably produce a grasp on the object while it is still on the table. With little or no time preferences, MIN and GENMIN10 produce images very close to the start, while GENMIN0.5 places too high a value on predictions farther away, and produces blurry images of the object after lifting.
+
+Quantitatively, for each method, we report the min and arg min index of the $\ell _ { 1 }$ distance to all frames in the video, as “min $\ell _ { 1 }$ err” and “match-step” (“which future ground truth frame is the prediction closest to?”). Fig 4 shows a scatter plot, where each dot or square is one model. TAP (various models with varying $\beta$ ) produces an even larger variation in stepsizes than fixed-time methods explicitly targeting the entire video $\mathrm { ' } _ { \mathrm { F I X 0 . 7 5 } }$ and $\mathrm { F I X } 1 . 0$ fall short of producing predictions at 0.75 and 1.0 fraction of the episode length). TAP also produces higher quality predictions (lower error) over that entire range. From these quantitative and qualitative results, we see that TAP not only successfully encourages semantically coherent bottleneck predictions, it also produces higher quality predictions than fixed-time prediction over a range of time offsets.
+
+Intermediate frame prediction. Next, we evaluate our approaches for bidirectionally conditioned prediction in all three settings. Initial and final frames are provided as input, and the method is trained to generate an intermediate frame. The FIX baseline now targets the middle frame. As before, MIN and GENMIN are our TAP models. The GENMIN time preference $w ( t )$ is bell-shaped and varies from 2/3 at the ends to 1 at the middle frame (see Appendix E).
+
+Figs 6 and 9 show examples from the three settings. TAP approaches successfully discover interesting bottlenecks in each setting. For grasping (Fig 6 (left)), both MIN and GENMIN consistently produce clear images of the arm at the point at which it picks up the object. Pick-and-place (Fig 6, right) is harder because it is more temporally extended, and the goal image does not specify how to grasp the object. FIX struggles to produce any coherent predictions, but GENMIN once again identifies bottlenecks reliably—in examples #3 and #1, it predicts the “pick” and the “place” respectively. For the pushing setting (Fig 9 (left)), GENMIN frequently produces images with one object moved and the other object fixed in place, which again is a semantically coherent bottleneck for this task. In row #1, it moves the correct object first to generate the subgoal, so that objects do not collide.
+
+![](images/f86ef90a00ab7b85808ffe17668e41b8c711bf42aeb798ea3b554ada01459605.jpg)
+
+![](images/e5accb667c317aea1ebb4ab176afeda30572430c2be8e635f7851878016d9e41.jpg)  
+Figure 5: (Best seen in pdf) Forward prediction results on grasping comparing fixed-time predictors and our approach. Each row is a separate example. First column is the input. Thereafter, each column corresponds to the output of a different model per the column title. More in Appendix Fig 17.   
+Figure 6: (Best seen in pdf) Bidirectional prediction results comparing fixed-time prediction and our approach. (Left) Grasping results. First two columns are inputs (start and goal). Thereafter, each column corresponds to the output of a different model per the column title. “match” is the ground truth image closest to the GENMIN prediction. More in Appendix Fig 13. (Right) Similar results for pick-and-place. More in Appendix Fig 14.
+
+Table 1 shows quantitative results over the full test set. As in forward prediction, we report min $\ell _ { 1 }$ error and the best-matching frame index (“match-step”) for all methods. MIN and GENMIN consistently yield higher quality predictions (lower error) than FIX at similar times on average. As an example, GENMIN reduces FIX errors by $21 \%$ , $2 6 . 5 \%$ , and $5 3 . 2 \%$ on the three tasks—these are consistent and large gains that increase with increasing task complexity/duration. Additionally, while all foregoing results were reported without the CVAE approach of Sec 3.4, Table 1 shows results for GENMIN+VAE, and Fig 9 shows example predictions for pick-and-place. In our models, individual stochastic predictions from GENMIN $^ +$ VAE produce higher $\ell _ { 1 }$ errors than GENMIN. However, the CVAE helps capture meaningful sources of stochasticity at the bottlenecks—in Fig 9 (right), it produces different grasp configurations to pick up the object in each case. To measure this, we evaluate the best of 100 stochastic predictions from GENMIN $^ +$ VAE in Table 1 (GENMIN $^ +$ VAE BEST-OF-100). On pick-and-place and pushing, the best VAE results are significantly better than any of the deterministic methods. Table 1 also shows results for our method without the GAN (GENMIN W/O GAN)—while its $\ell _ { 1 }$ errors are comparable, we observed a drop in visual quality.
+
+Table 1: Bidirectional frame prediction performance on: grasping, pick-and-place, and two-object pushing. Lower min $\ell _ { 1 }$ err is better. match-step denotes which times are being predicted, out of $T$ steps. It is clear that TAP methods make better predictions than fixed-time prediction at the same time offsets.   
+
+<table><tr><td>Setting→ Method↓</td><td>Grasping (T=15 steps) min lierr</td><td>match-step/T</td><td>Pick-and-place (T=20 steps) min l1 err</td><td>match-step/T</td><td>Pushing (T=30 steps) min l1 err</td><td>match-step/T</td></tr><tr><td>fix</td><td>0.0153</td><td>0.51±0.17</td><td>0.0366</td><td>0.53±0.24</td><td>0.0722</td><td>0.36±0.19</td></tr><tr><td>MIN (ours)</td><td>0.0104</td><td>0.49±0.18</td><td>0.0256</td><td>0.41±0.30</td><td>0.0365</td><td>0.35±0.22</td></tr><tr><td>GENMIN (ours)</td><td>0.0121</td><td>0.45±0.16</td><td>0.0269</td><td>0.42±0.23</td><td>0.0338</td><td>0.36±0.19</td></tr><tr><td>GENMIN W/O GAN (Ours)</td><td>0.0117</td><td>0.45±0.16</td><td>0.0235</td><td>0.46±0.25</td><td>0.0411</td><td>0.37±0.19</td></tr><tr><td>GENMIN + VAE (Ours)</td><td>0.0156</td><td>0.47±0.18</td><td>0.0432</td><td>0.31±0.24</td><td>0.0447</td><td>0.37±0.21</td></tr><tr><td>GENMIN + VAE BEST-OF-10O (Ours)</td><td>0.0121</td><td>-</td><td>0.0196</td><td>-</td><td>0.0236</td><td>-</td></tr></table>
+
+![](images/08ead4e71ea153e3db3ca86982af8338fef990eac09998525a0fdc8907203658.jpg)  
+Figure 9: (Best seen in pdf) (Left) Bidirectional prediction results on two-object pushing. More in Appendix Fig 15. (Right) When used with a VAE (Sec 3.4), our approach captures residual stochasticity at the bottleneck. In these results from the pick-and-place task, GENMIN $^ +$ VAE produces images that are all of the arm in contact with the object on the table, but at different points on the object, and with different arm/gripper poses.
+
+As indicated in ${ \mathrm { S e c } } 3 . 1$ and Eq 3, TAP may also be applied recursively. Fig 7 compares consecutive subgoals for the pick-and-place task produced by recursive TAP versus a recursive fixed-time model. Recursion level $r = 1$ refers to the first subgoal, and $r = 2$ refers to the subgoal generated when the first subgoal is provided as the goal input (start input is unchanged). In example #1, FIX struggles while “ours” identifies the “place” bottleneck at $r = 1$ , and subsequently the “pick” botleneck at $r = 2$ .
+
+![](images/fe2aa8133a51dbd41e95dc77f0fc36f12af4aaa53458e7768be0fa33c485273a.jpg)  
+Figure 7: Recursive bidirectional prediction on pickand-place. $r = 2$ is earlier in time than $r = 2$ .
+
+Finally, we test on “BAIR pushing” (Ebert et al., 2017), a real-world dataset that is commonly used in visual prediction tasks. The data consists of 30-frame clips of random motions of a Sawyer arm tabletop. While this dataset does not have natural bottlenecks like in grasping, TAP (min $\ell _ { 1 }$ error 0.046 at match-step 15.42) still performs better than FIX (0.059 at 15.29). Qualitatively, as Fig 8 shows, even though BAIR pushing contains incoherent random arm motions, TAP consistently produces predictions that plausibly lie on the path from start to goal image. In example #1, given a start and goal image with one object displaced, “ours” correctly moves the arm to the object before displacement, whereas FIX struggles.
+
+![](images/9385c328efd3ef9d40d2aebb6da428efee79f90d0d1504ea5d2217964752ce67.jpg)  
+Figure 8: Bidirectional prediction results on BAIR pushing data. The first two columns are the inputs, and the next two correspond to FIX and GENMIN.
+
+Bottleneck discovery frequency. We have thus far relied on qualitative results to assess how often our approach finds coherent bottlenecks. For pushing, we test bottleneck discovery frequency more quantitatively. We make the reasonable assumption that bottlenecks in 2-object pushing correspond to states where one object is pushed and the other is in place. Our metric exploits knowledge of true object positions at start and goal states. First, for this evaluation, we restrict both GENMIN and FIX to synthesize predictions purely by warping and masking inputs. Thus, we can track where the pixels at ground truth object locations in start and goal images end up in the prediction, i.e., where did each object move? We then compute a score that may be thresholded to detect when only one object moves (details in Appendix F). As an intuitive example, suppose that the two objects are displaced by $1 0 \mathrm { c m }$ and $1 5 \mathrm { { c m } }$ respectively between start and goal frames. Suppose further that our predictor predicts the start frame as its output. Then its distance score would be computed to be 10 cm. For all values of threshold below $1 0 \mathrm { c m }$ , this would be counted as a bottleneck discovery failure.
+
+![](images/c98be0a524e6a6ba7b94ce1b7a36d75a2305e1440f91fbf772d0f3efa5ba64f2.jpg)  
+Figure 10: Bottleneck frequency vs. score threshold
+
+As Fig 10 shows, GENMIN predicts bottlenecks much more frequently $\sim 6 0 \%$ of the time) than FIX. As hypothesized, our time-agnostic approach does indeed identify and latch on to low-uncertainty states to improve its predictions.
+
+Hierarchical planning evaluation. Finally, we discuss experiments directly evaluating our intermediate predictions as visual subgoals for hierarchical planning for pushing tasks. A forward Visual MPC planner (Ebert et al., 2017) accepts the subgoal object positions (computed as above for evaluating bottlenecks). Start and goal object positions are also known. Internally, Visual MPC makes action-conditioned fixed-time forward predictions of future object positions to find an action sequence that reaches the subgoal object
+
+<table><tr><td></td><td>2-object</td><td>3-object</td></tr><tr><td>direct</td><td>12.9±0.6</td><td>15.8±0.6</td></tr><tr><td>FIX</td><td>12.5±0.5</td><td>17.6±0.6</td></tr><tr><td>GENMIN</td><td>11.9±0.6</td><td>12.9±0.7</td></tr></table>
+
+Table 2: Multi-object pushing errors (in cm).
+
+positions, with a planning horizon of 15. Additional implementation details are in Appendix G.
+
+Given start and goal images, our model produces a subgoal. Visual MPC plans towards this subgoal for half the episode length, then switches to the final goal. We compare this scheme against (i) “direct”: planning directly towards the final goal for the entire episode length, and (ii) FIX: subgoals from a center-frame predictor. The error measure is the mean of object distances to goal states (lower is better). As an upper bound, single-object pushing with the planner yields ${ \sim } 5 \mathrm { c m }$ error. Results for two-object and three-object pushing are shown in Table 2. GENMIN does best on both, but especially on the more complex three-object task. Since Visual MPC has thus far been demonstrated to work only on pushing tasks, our hierarchical planning evaluation is also limited to this task. Going forward, we plan to adapt Visual MPC to allow testing TAP on more complex temporally extended tasks like block-stacking, where direct planning breaks down and subgoals offer greater value.
+
+# 5 CONCLUSIONS
+
+The standard paradigm for prediction tasks demands that a predictor not only make good predictions, but that it make them on a set schedule. We have argued for redefining the prediction task so that the predictor need only care that its prediction occur at some time, rather than that it occur at a specific scheduled time. We define this time-agnostic prediction task and propose novel technical approaches to solve it, that require relatively small changes to standard prediction methods. Our results show that reframing prediction objectives in this way yields higher quality predictions that are also semantically coherent—unattached to a rigid schedule of regularly specified timestamps, model predictions instead naturally attach to specific semantic “bottleneck” events, like a grasp. In our preliminary experiments with a hierarchical visual planner, our results suggest that such predictions could serve as useful subgoals for complex tasks.
+
+In future work, we would like to address some limitations of our TAP formulation, of which we will mention two here. First, TAP currently benefits not only from selecting which times to predict, but also from not having to provide timestamps attached to its predictions. We would like to study: could we retain the benefits of time-agnostic prediction while also providing timestamps for when each predicted state will occur? Second, our current TAP formulation may not generalize to prediction problems in all settings of interest. As an example, for videos of juggling or waving, which involve repeated frames, TAP might collapse to predicting the input state repeatedly. We would like to investigate more general TAP formulations: for example, rather than choosing $\mathcal { E } _ { t } ^ { \prime }$ in Eq 5 to encourage predicting farther away times, we could conceivably penalize predictions that look too similar to the input context frames. More broadly, we believe that our results thus far hold great promise for many applications of prediction including hierarchical planning and model-based reinforcement learning, and we hope to build further on these results.
+
+Acknowledgements. We thank Alex Lee and Chelsea Finn for helpful discussions and Sudeep Dasari for help with the simulation framework and for generating the simulated data used in this work. We thank Kate Rakelly, Kyle Hsu, and Allan Jabri for feedback on early drafts. This work was supported by Berkeley DeepDrive, NSF IIS-1614653, NSF IIS-1633310, and an Office of Naval Research Young Investigator Program award. The NVIDIA DGX-1 used for this research was donated by the NVIDIA Corporation.
+
+# REFERENCES
+
+Mohammad Babaeizadeh, Chelsea Finn, Dumitru Erhan, Roy H Campbell, and Sergey Levine. Stochastic variational video prediction. ICLR, 2018.
+
+Pierre-Luc Bacon. On the bottleneck concept for options discovery. M.S. Thesis, McGill University, 2013.
+
+Moshe Bar. The proactive brain: memory for predictions. Philosophical Transactions of the Royal Society B: Biological Sciences, 364(1521):1235–1243, 2009.
+
+Andy Clark. Whatever next? predictive brains, situated agents, and the future of cognitive science. Behavioral and brain sciences, 36(3):181–204, 2013.
+
+Emily Denton and Rob Fergus. Stochastic video generation with a learned prior. arXiv preprint arXiv:1802.07687, 2018.
+
+Frederik Ebert, Chelsea Finn, Alex X. Lee, and Sergey Levine. Self-supervised visual planning with temporal skip connections. CORL, 2017.
+
+Chelsea Finn and Sergey Levine. Deep visual foresight for planning robot motion. In International Conference on Robotics and Automation (ICRA), 2017.
+
+Chelsea Finn, Ian Goodfellow, and Sergey Levine. Unsupervised learning for physical interaction through video prediction. In Neural Information Processing Systems (NIPS), 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.
+
+Raia Hadsell, Sumit Chopra, and Yann LeCun. Dimensionality reduction by learning an invariant mapping. In Computer vision and pattern recognition, 2006 IEEE computer society conference on, volume 2, pp. 1735–1742. IEEE, 2006.
+
+Jakob Hohwy. The predictive mind. Oxford University Press, 2013.
+
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. CVPR, 2017.
+
+Dinesh Jayaraman and Kristen Grauman. Learning image representations tied to ego-motion. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1413–1421, 2015.
+
+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.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Kris M Kitani, Brian D Ziebart, James Andrew Bagnell, and Martial Hebert. Activity forecasting. In European Conference on Computer Vision, pp. 201–214. Springer, 2012.
+
+Dirk P Kroese, Reuven Y Rubinstein, Izack Cohen, Sergey Porotsky, and Thomas Taimre. Crossentropy method. In Encyclopedia of Operations Research and Management Science, pp. 326–333. Springer, 2013.
+
+Anders Boesen Lindbo Larsen, Søren Kaae Sønderby, Hugo Larochelle, and Ole Winther. Autoencoding beyond pixels using a learned similarity metric. ICML, 2016.
+
+Alex X Lee, Richard Zhang, Frederik Ebert, Pieter Abbeel, Chelsea Finn, and Sergey Levine. Stochastic adversarial video prediction. arXiv preprint arXiv:1804.01523, 2018.
+
+Michael Mathieu, Camille Couprie, and Yann LeCun. Deep multi-scale video prediction beyond mean square error. arXiv preprint arXiv:1511.05440, 2015.
+
+Amy McGovern and Andrew G Barto. Automatic discovery of subgoals in reinforcement learning using diverse density. In ICML, 2001.
+
+Jan Hendrik Metzen. Online skill discovery using graph-based clustering. In European Workshop on Reinforcement Learning, pp. 77–88, 2013.
+
+Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint arXiv:1411.1784, 2014.
+
+Hossein Mobahi, Ronan Collobert, and Jason Weston. Deep learning from temporal coherence in video. In Proceedings of the 26th Annual International Conference on Machine Learning, pp. 737–744. ACM, 2009.
+
+Alexander Neitz, Giambattista Parascandolo, Stefan Bauer, and Bernhard Schlkopf. Adaptive skip intervals: Temporal abstraction for recurrent dynamical models. NIPS, 2018.
+
+Augustus Odena, Vincent Dumoulin, and Chris Olah. Deconvolution and checkerboard artifacts. Distill, 2016. doi: 10.23915/distill.00003. URL http://distill.pub/2016/ deconv-checkerboard.
+
+Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-conditional video prediction using deep networks in atari games. In Advances in Neural Information Processing Systems, 2015.
+
+Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. arXiv preprint arXiv:1601.06759, 2016.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.
+
+MarcAurelio Ranzato, Arthur Szlam, Joan Bruna, Michael Mathieu, Ronan Collobert, and Sumit Chopra. Video (language) modeling: a baseline for generative models of natural videos. arXiv preprint arXiv:1412.6604, 2014.
+
+Ozg ¨ ur¨ S¸ims¸ek and Andrew G Barto. Skill characterization based on betweenness. In Advances in neural information processing systems, pp. 1497–1504, 2009.
+
+Richard S Sutton, Doina Precup, and Satinder Singh. Between mdps and semi-mdps: A framework for temporal abstraction in reinforcement learning. Artificial intelligence, 112(1-2):181–211, 1999.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026–5033. IEEE, 2012.
+
+Aaron van den Oord, Nal Kalchbrenner, Lasse Espeholt, Oriol Vinyals, Alex Graves, et al. Conditional image generation with pixelcnn decoders. In Advances in Neural Information Processing Systems, pp. 4790–4798, 2016.
+
+Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. In Advances In Neural Information Processing Systems, pp. 613–621, 2016a.
+
+Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Anticipating visual representations from unlabeled video. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 98–106, 2016b.
+
+Jacob Walker, Carl Doersch, Abhinav Gupta, and Martial Hebert. An uncertain future: Forecasting from static images using variational autoencoders. In European Conference on Computer Vision, pp. 835–851. Springer, 2016.
+
+Xiaolong Wang, Ali Farhadi, and Abhinav Gupta. Actions˜ transformations. In Proceedings of the IEEE conference on Computer Vision and Pattern Recognition, pp. 2658–2667, 2016.
+
+Tianfan Xue, Jiajun Wu, Katherine Bouman, and Bill Freeman. Visual dynamics: Probabilistic future frame synthesis via cross convolutional networks. In Advances in Neural Information Processing Systems, pp. 91–99, 2016.
+
+Tinghui Zhou, Shubham Tulsiani, Weilun Sun, Jitendra Malik, and Alexei A Efros. View synthesis by appearance flow. In European conference on computer vision, pp. 286–301. Springer, 2016.
+
+![](images/77d54b0e7d23e2a5f211a986f42660665ad7067860e4a9d856ffea03a249a4ba.jpg)  
+Figure 11: Training time network schematic. At test time, only the predictor $G$ is used, and $z \sim \mathcal { N } ( 0 , \mathcal { Z } )$ . Loss terms (as used in Eq 10) are in red.
+
+In these appendices, we provide details omitted in the main text for space. Note that more supplementary material, such as video examples, is hosted at: https://sites.google.com/view/ ta-pred
+
+# A LABEL SMOOTHING FOR TIME-AGNOSTIC CONDITIONAL GANS
+
+In $\operatorname { E q } 7$ , we defined a time-agnostic CGAN loss that trained $\mathrm { T }$ discriminators, one corresponding to each target time $t \in \mathrm { T }$ . In Eq 7, the only positives for the $t$ -th discriminator $D _ { t }$ were ground truth frames that occured precisely at time $t$ relative to the input $c$ , i.e., discriminators are trained so that $D _ { t } ( c , x _ { t } )$ would be 1, and $D _ { t } ( c , x _ { t ^ { \prime } \neq t } )$ and $D _ { t } ( c , G ( c ) )$ would both be 0. However, in practice, we use the following slightly different loss:
+
+$$
+\begin{array} { r l } & { G ^ { * } = \underset { G } { \arg \operatorname* { m i n } } \underset { t \in \mathcal { T } } { \min } \underset { D _ { t } } { \operatorname* { m a x } } \mathcal { L } _ { \mathrm { c g a n } } ^ { t } ( G , D _ { t } ) , } \\ & { \mathcal { L } _ { \mathrm { c g a n } } ^ { t } ( G , D _ { t } ) = \log D _ { t } ( c , x _ { t } ) + \log ( 1 - D _ { t } ( c , G ( c ) ) ) + } \\ & { \qquad \quad \sum _ { t ^ { \prime } \not = t } [ l _ { t , t ^ { \prime } } \log D _ { t } ( c , x _ { t ^ { \prime } } ) + ( 1 - l _ { t , t ^ { \prime } } ) \log ( 1 - D _ { t } ( c , x _ { t ^ { \prime } } ) ) ] , } \end{array}
+$$
+
+where we set $l _ { t , t ^ { \prime } } = \operatorname* { m a x } ( 0 , 1 - \alpha | t - t ^ { \prime } | )$ with $\alpha = 0 . 2 5$ . The first two terms are the same as $\mathrm { E q } ~ 7$ — for the $t$ -th discriminator, the $t$ -th frame provides a positive, and the generated frame provides a negative instance. The third term defines the loss for frames $x _ { t ^ { \prime } \neq t }$ : frames close to time $t$ are partial positives $( 0 < l _ { t , t ^ { \prime } } < 1 )$ , and others are negatives $( l _ { t , t ^ { \prime } } = 0 )$ . This label smoothing stabilizes training and ensures enough positives for each discriminator $D _ { t }$ .
+
+# B TIME-AGNOSTIC CONDITIONAL VAES
+
+Here, we discuss one alternative to the TAP CVAE formulation of $\operatorname { E q } 9$ in Sec 3.4. Rather than restricting the minimum-over-time to be over the log-likelihood term alone, why not take the minimumover-time over the whole loss? In other words, the inference network would still have to only see one frame as input, and this version of the TAP CVAE loss would be:
+
+$$
+\mathcal { L } _ { \mathrm { c v a e } } ( G , \phi ) = \operatorname* { m i n } _ { t \in \mathbb { T } } \left[ D _ { K L } ( q _ { \phi } ( z | x _ { t } ) , p ( z ) ) - \mathbb { E } _ { z \sim q _ { \phi } ( z | x _ { t } ) } \ln p _ { G } ( x _ { t } | c , z ) \right] .
+$$
+
+Unfortunately, this would be computationally very expensive to train. Both the inference network $q _ { \phi }$ and the generator $G$ would have to process $| \mathrm { T } |$ frames. In comparison, the formulation of $\operatorname { E q } 9$ allows $q _ { \phi }$ and $G$ to process just one frame, and only error computation must be done $\mathrm { T }$ times, once with each target frame $x _ { t }$ for $t \in \mathrm { T }$ .
+
+# C ARCHITECTURE AND TRAINING DETAILS
+
+Predictor architecture. As indicated in Fig 11, the predictor $G$ has an encoder-decoder architecture. When our approach is used together with the conditional VAE (Sec 3.4), the conditional latent $z$ is appended at the bottleneck between the encoder and the decoder. The encoder produces a 128- dimensional code, and the VAE latent code $z$ is 32-dimensional, so the overall size of the input to the decoder is 160 when the VAE is used.
+
+![](images/f8856cd9f2f3798eee429753195214b113ada59861c91af370862789af7f7cd3.jpg)  
+Figure 12: The predictor produces an appearance flowfield which is used to produce flow-warped input frames, which together with a frame of new pixels are masked and averaged to produce the output frame.
+
+The encoder inside the predictor uses a series of 4x4convolution-batchnorm-LeakyReLU(0.2) blocks to reduce the 64x64 input image as $3 \mathrm { x 6 4 \mathrm { x 6 4 } } {  } 3 2 \mathrm { x } 3 2 \mathrm { x } 3 2 {  } 6 4 \mathrm { x } 1 6 \mathrm { x } 1 6 {  } 1 2 8 \mathrm { x } 8 \mathrm { x } 8 {  } 2 5 6 \mathrm { x } 4 \mathrm { x } 4$ . For bidirectional prediction, this is repeated for both images and concatenated to produce a $5 1 2 \mathrm { x } 4 \mathrm { x } 4$ feature map. Finally, a small convolution-ReLU-convolution head reduces this to a 128-dimensional vector. Except for this last head subnetwork, this architecture is identical to the DCGAN discriminator (Radford et al., 2015).
+
+The decoder inside the predictor uses a DCGAN-based architecture (Radford et al., 2015). The input vector is reshaped by a transposed convolution into 256 $4 \times 4$ maps. This is subsequently processed a series of bilinear upsampling-5x5convolution-batchnorm-ReLU blocks as $2 5 6 \times 4 \times 4 - 1 2 8 \times 8 \times 8  6 4 \mathrm { x } 3 2 \mathrm { x } 3 2  3 \mathrm { x } 6 4 \mathrm { x } \bar { 6 } 4$ . For the last block, a Tanh activation is used in place of ReLU to keep outputs in [-1,1]. Compared to (Radford et al., 2015), the main difference is that transposed convolutions are replaced by upsampling-5x5 convolution blocks, which aids in faster learning with fewer image artifacts (Odena et al., 2016).
+
+As shown in $\mathrm { F i g } 1 2$ , our predictor produces three sets of outputs: (a) one frame of new pixels, (b) “appearance flow” (Zhou et al., 2016) maps that warp the $| C |$ input image(s), and (c) $| C | + 1$ masks (summing to 1 at each pixel) that combine the warped input images and the new pixels frame to produce the final output. To produce these three outputs, we use three decoders that all have the same architecture as above, except that the final output is shaped appropriately—the appearance flow decoder produces $\vert C \vert \mathrm { x 6 4 x 6 4 }$ flowfields, and the masks decoder produces $( | C | + 1 ) \mathrm { x } 6 4 \mathrm { x } 6 4$ masks.
+
+Discriminator and Recognition Network The VAE recognition network and the discriminator both use similar architectures to the predictor encoder above. Only the input layer and the output layer are changed as follows: (a) The discriminator accepts $| C | + 1$ images as input and the recognition network accepts $| C | + | T |$ images (the full video) as input. (b) The discriminator head produces $| T |$ logits (one corresponding to each target time), and the recognition network produces a 32-dimensional conditional latent.
+
+Training. We found it beneficial to initialize the decoder by training it first as an unconditional frame generator on frames from the training videos. For this pretraining, we use learning rate 0.0001 for 10 epochs with batch size 64 and Adam optimizer. Thereafter, for training, we use learning rate 0.0001 for 200 epochs with batch size 64 and Adam optimizer.
+
+# D DATA GENERATION
+
+To generate the data, we use a cross-entropy method (CEM)-based planner (Kroese et al., 2013; Ebert et al., 2017) in the MuJoCo (Todorov et al., 2012) environment with access to the physics engine, which produces non-deterministic trajectories. The planner plans towards randomly provided goals, but we use both successful and failed trajectories. Sample videos of episodes are shown at: https://sites.google.com/view/ta-pred
+
+# E GENERALIZED MINIMUM WEIGHTS FOR INTERMEDIATE PREDICTION
+
+In Sec 4, we briefly mentioned that the time preference $w ( t )$ for the generalized minimum loss during intermediate frame prediction was set to 2/3 at the ends to 1 at the middle frame. In our experiments, we set these weights heuristically as follows: $w ( t )$ rises linearly from $\kappa = 0 . 6 6$ at $t = 1$ to 1.0 at the $t = 5$ , then stay at 1.0 for $T - 1 0$ frames. Then, starting from the $( T - 5 )$ -th frame, it would drop linearly to $\kappa$ once more at $t = T$ . The only hyperparameter we tuned was $\kappa$ (search over $2 / 3$ and $1 / 3$ ).
+
+# F BOTTLENECK DISCOVERY FREQUENCY SCORE
+
+In Sec 4, we mentioned a bottleneck discovery frequency measure in the paragraph titled “Bottleneck discovery frequency metric.” We now provide further details.
+
+Our proposed metric for two-object pushing quantifies how reliably the network is able to generate a bottleneck state with one object being moved and the other being at its original position. The reason that this state is of interest is that in two-object pushing, this may be reasonably assumed to be the natural bottleneck, so we call this metric the bottleneck frequency. Even without this assumption though, the metric quantifies the ability of our approach to generate predictions attached to this consistent semantically coherent bidirectional state.
+
+To measure bottleneck frequency, we use a technique similar to the approach proposed in (Ebert et al., 2017) for planning with a visual predictor. First, we train versions of “genmin” and “fix” that synthesize predictions purely by appearance-flow-warping and masking inputs (as shown in the scheme of Fig 12, but without pixel generation). Next, recall that we have access to the starting and goal positions of objects since our dataset is synthetically generated. Thus, we can exploit this and track where the pixels at ground truth object locations in start and goal images end up in the prediction, i.e., where did each object move? This works as follows: we take the appearance flow transformations and masks generated by the model internally (for application to input images to generate prediction) and apply them instead to one-hot object location maps—these maps have value one at the ground truth origin of the the objects and zero elsewhere. The output of this operation is a probability map for each object indicating where it is located in the predictor’s bidirectional prediction output.
+
+To compute the score, we then calculate the expected distance in pixels between the predicted positions of each object and the bottleneck state. There are actually two possible candidates for this bottleneck state: object 1 is moved first, or object 2 is moved first. We compute the expected distances to both these bottleneck candidates and take the lower distance to be the score. This score does not evaluate whether the semantically correct bottleneck was predicted (in cases where one object must always be moved first to avoid collision, such as Fig 9 (left) example #1).
+
+The lower this distance score, the higher the likelihood that the predicted output is actually a bottleneck (“bottleneck frequency”). Fig 10 shows what happens when the threshold over the score is varied, for our approach and the fixed-time baseline. Higher bottleneck frequency at lower threshold is desirable. As the figure shows, at a low threshold distance score $\approx 2$ pixels), our approach gets to about $58 \%$ bottleneck frequency while the fixed-time predictor gets about $0 \%$ frequency at this threshold. This verifies that our approach produces predictions attached to semantically coherent low-uncertainty bottleneck events.
+
+# G HIERARCHICAL PLANNING EVALUTION METHOD
+
+In Sec 4, we described a hierarchical planning approach using our predictions in the paragraph titled “Hierarchical planning evaluation.” We describe this method in more detail here.
+
+We test the usefulness of the generated predictions as subgoals for planning multi-object pushing. Given a start and goal image, we produce an bidirectional prediction using our time-agnostic predictor and feed it to a low-level planner that plans towards this prediction as its subgoal. For the low-level planner we use the visual model-predictive control algorithm (“Visual MPC”) (Ebert et al., 2017) which internally uses a fixed-time forward prediction model and sampling-based planning to solve short-term and medium duration tasks. A more detailed description of this process follows.
+
+Visual MPC requires start and goal locations of objects to plan. When used in conjunction with our method, we first compute the locations of objects at the bidirectional predictions and feed this in place of the final goal object locations, so that Visual MPC may plan to first reach the bidirectional prediction as a subgoal/stepping stone towards the final goal. Once the subgoal is reached, Visual MPC is fed the final goal. To compute subgoal object locations, we use the same technique as in Appendix F above—one-hot maps of object locations are transformed by the appearance flow maps and masks computed internally by our predictor. This produces a probability map $p _ { g }$ over object locations at the prediction, which is passed to Visual MPC.
+
+Internally, the Visual MPC planner makes fixed-time forward predictions for the object locations starting from the initial distribution $p _ { s }$ given a randomly sampled action sequence of length $h = 1 5$ (the “planning horizon”). Out of all the action sequences, it selects the sequence that brings the distribution closest to $p _ { g }$ within $h = 1 5$ steps $h$ is the “planning horizon”). In practice, we use 200 random action sequences and perform three iterations of CEM search (Kroese et al., 2013) to find the the best sequence. Once an action sequence is selected, the first action in the sequence is executed, and the initial object distribution is updated. New candidate action sequences are now generated starting from this updated object distribution and the process repeats.
+
+In our experiments, we use a time budget $B$ of 40 steps for 2-object pushing, and 75 steps for 3-object pushing. In both cases, we feed Visual MPC the subgoal (bidirectional prediction object locations) for the first $B / 2$ timesteps, and then feed the final goal location for the last $B / 2$ steps. The “direct” planning baseline instead receives the final goal location for all $B$ steps. As shown by the results in the paper, our subgoal predictions aid in performing these multi-stage pushing tasks better than with the direct planning baseline.
+
+# H SUPPLEMENTARY PREDICTION EXAMPLES
+
+We now show more prediction results from various settings in Figs 13, 14, 15, 16, and 17, to supplement those in Sec 4.
+
+![](images/331e0f729cf40eff5b382bbf06438a664d492baeae26a68992e41a0ef5ac3d03.jpg)  
+Figure 13: (Same format as Fig 6). Supplementary bidirectional prediction results comparing fixed-time prediction and our approach on grasping. First two columns are inputs (start and goal). Thereafter, each column corresponds to the output of a different model per the column title. “match” is the ground truth image closest to the GENMIN prediction.
+
+![](images/4c02c50243df3f49393e35f68fcbe9a306dde711b7ab7db4fa781dd6ed57197c.jpg)  
+Figure 14: (Same format as Fig 6). Supplementary bidirectional prediction results comparing fixed-time prediction and our approach on pick-and-place. First two columns are inputs (start and goal). Thereafter, each column corresponds to the output of a different model per the column title. “match” is the ground truth image closest to the GENMIN prediction.
+
+![](images/7608e21d6351de86eb9561103060c7e34e988b183e26ac97471c7f928e861972.jpg)  
+Figure 15: Supplementary bidirectional prediction results on pushing. Four columns for each method correspond to masked warped start frame, masked warped goal frame, masked new pixels, and final output respectively. See Appendix C and Fig 12 for the synthesis scheme with masks and warps.
+
+![](images/ef3dab5ffbd647668dd9b6a11921ad8c76166914d6c8c768742020a369945769.jpg)  
+Figure 16: Supplementary bidirectional prediction examples for pick-and-place with GENMIN $^ +$ VAE. Same format as Fig 9. Each row is a separate example. First column is the input. GENMIN $^ +$ VAE captures residual stochasticity at the bottleneck. GENMIN $^ +$ VAE produces images that are most all of the arm in contact with the object on the table, but at different points on the object, and with different arm/gripper poses.
+
+![](images/935acf73750df876dda1f586688730675d4fa8665ac4a901053f00f014cd5c71.jpg)  
+Figure 17: Supplementary forward prediction examples for grasping, comparing fixed-time predictors and our approach. Same format as Fig 5. Each row is a separate example. First column is the input. Thereafter, each column corresponds to the output of a different model per the column title.

parse/train/Uj7pF-D-YvT/Uj7pF-D-YvT.md

@@ -0,0 +1,244 @@
+# Deep Learning on a Data Diet: Finding Important Examples Early in Training
+
+Mansheej Paul Stanford University mansheej@stanford.edu
+
+Surya Ganguli Stanford University; Facebook AI Research sganguli@stanford.edu
+
+Gintare Karolina Dziugaite Mila ⇤ gkdz@google.com
+
+# Abstract
+
+Recent success in deep learning has partially been driven by training increasingly overparametrized networks on ever larger datasets. It is therefore natural to ask: how much of the data is superfluous, which examples are important for generalization, and how do we find them? In this work, we make the striking observation that, in standard vision datasets, simple scores averaged over several weight initializations can be used to identify important examples very early in training. We propose two such scores—the Gradient Normed (GraNd) and the Error L2-Norm (EL2N) scores—and demonstrate their efficacy on a range of architectures and datasets by pruning significant fractions of training data without sacrificing test accuracy. In fact, using EL2N scores calculated a few epochs into training, we can prune half of the CIFAR10 training set while slightly improving test accuracy. Furthermore, for a given dataset, EL2N scores from one architecture or hyperparameter configuration generalize to other configurations. Compared to recent work that prunes data by discarding examples that are rarely forgotten over the course of training, our scores use only local information early in training. We also use our scores to detect noisy examples and study training dynamics through the lens of important examples—we investigate how the data distribution shapes the loss surface and identify subspaces of the model’s data representation that are relatively stable over training.
+
+# 1 Introduction
+
+Recently, deep learning has made remarkable progress driven, in part, by training overparameterized models on ever larger datasets. This trend creates new challenges: the large computational resources required pose a roadblock to the democratization of AI. Memory and resource constrained settings, such as on-device computing, require smaller models and datasets. Identifying important training data plays a role in online and active learning. Finally, it is of theoretical interest to understand how individual examples and sub-populations of training examples influence learning.
+
+To address these challenges, we propose a scoring method that can be used to identify important and difficult examples early in training, and prune the training dataset without large sacrifices in test accuracy. We also investigate how different sub-populations of the training data identified by our score affect the loss surface and training dynamics of the model.
+
+Recent work on pruning data [1, 2], can be placed in the broader context of identifying coresets— examples that provably guarantee a small gap in training error on the full dataset [3–7]. However, due to the nonconvex nature of deep learning, coreset techniques make conservative estimates that lead to weak theoretical guarantees and are less effective in practice.
+
+A different approach recently proposed by Toneva et al. [8] tracks the number of times through training an example transitions from being correctly classified to misclassified, called a "forgetting event", and find that some examples are rarely forgotten, while others are forgotten repeatedly. Empirically, they observed that training accuracy is not affected by the rarely forgotten training examples and a large fraction of the training data can be removed without any impact on test accuracy. However, since this method relies on collecting forgetting statistics throughout training, the forgetting score is typically calculated in the middle of or at the end of training. Toneva et al. [8] find that, in their example of a ResNet18 trained on CIFAR-10 for 200 epochs, the Spearman rank correlation between early and late scores is good after about 25 epochs and stabilizes after 75 epochs.
+
+Broadly speaking, the ability to prune datasets raises a number of questions: What is the nature of examples that can be removed from the training data without hurting accuracy? How early in training can we recognize such examples? How many examples do we need and how does this depend on the data distribution? These questions may have no generic answers and so, in this work, we begin to pursue them empirically in the context of several standard vision benchmarks and standard network architectures. Answers to these questions may both (1) lead to new methodologies that could dramatically reduce training times and memory requirements, and (2) offer important insights into the training dynamics of deep neural networks, and the role of data.
+
+Our first finding is that very early in training (just a few epochs), partial forgetting scores identify large fractions of data that can be pruned. Analyzing this puzzling result with a one gradient step analysis of training suggests a very simple heuristic: use the loss gradient norm of individual examples to identify important examples. While this approach does not work when the loss gradient norms are computed at the weights early in training of a single trajectory, we find that, surprisingly, averaging these norms over multiple weight initializations does produce a ranking that correlates strongly with forgetting scores and allows us to prune a significant fraction of examples early in training. Indeed, we can prune $50 \%$ of examples from CIFAR-10 without affecting accuracy, while on the more challenging CIFAR-100 dataset, we can prune $2 5 \%$ of examples with only a $1 \%$ drop in accuracy.
+
+Through a series of empirical studies, we have begun to tease apart the properties of important examples and how they can depend on the data distribution. In particular, we find that the examples with the very highest norms become superfluous as the amount of label noise increases. Indeed, even on clean data, we find that in the high pruning regime, the best population excludes the very highest-scoring examples.
+
+# 1.1 Contributions
+
+• We propose to score the importance of each training example $( x _ { i } , y _ { i } )$ by its expected loss gradient norm (GraNd score), which, up to a constant, bounds the expected change in loss for an arbitrary example $( x , y )$ caused by removing $( x _ { i } , y _ { i } )$ .
+
+• We show that pruning training samples with small GraNd scores at initialization allows one to train on much smaller subset of the training data without significant loss in accuracy. While the pruning levels are comparable to those provided by other methods [1, 8], our score is the only one that is well-defined at initialization and early in training.
+
+• Our experimental findings suggest that, within the first few epochs of training, the GraNd score is well-approximated by the norm of the error vector (EL2N score), where the error vector is the predicted class probabilities minus one-hot label encoding. In fact, we find that the EL2N score provides an even stronger signal for data-pruning—for CIFAR10 we can prune $50 \%$ of the data, and for the harder CIFAR100, we can prune as much as $2 5 \%$ of the data without any loss in test accuracy.
+
+• We study the role of examples with the highest EL2N scores, and find that excluding a small subset of the very highest scoring examples produces a boost in performance. This boost in performance is enhanced in a corrupted label regime.
+
+• We introduce a method, based on linearly connected modes, for studying the empirical risk surface in terms of the modes of subsets of data, allowing us to identify when, in training, the final performance on subpopulations is determined. We demonstrate that the linearly connected mode at-convergence of empirical risk surface computed on low EL2N score examples is determined much earlier in training compared to high score examples.
+
+• Finally, we study how an example’s EL2N score connects to the network’s training dynamics. We do so by tracking the data-dependent NTK submatrices corresponding to the low or high score examples, and measuring the rate at which it evolves in a scale-invariant way. We find that the NTK submatrix for the high score examples evolves faster throughout training, supporting our hypothesis that high-scoring examples are the ones driving the learning and the changes in the NTK feature space [9].
+
+# 2 Which samples are important for learning?
+
+# 2.1 Preliminaries
+
+We consider supervised classification, where ${ \cal { S } } = \{ ( x _ { i } , y _ { i } ) \} _ { i = 1 } ^ { N }$ denotes the training set, drawn i.i.d. from an unknown data distribution $\mathcal { D }$ , with input vectors $x \in \mathbb { R } ^ { d }$ and one-hot vectors $y \in \{ 0 , 1 \} ^ { K }$ encoding labels. For a fixed neural network architecture, let $f _ { \mathbf { w } } ( x ) \in \mathbb { R } ^ { K }$ be the logit outputs of the neural network with weights w $\in \mathcal { W } \subseteq \mathbb { R } ^ { D }$ on input $\boldsymbol { x } ~ \in ~ \mathbb { R } ^ { d }$ . Let $\sigma$ be the softmax function given by $\begin{array} { r } { \sigma ( z _ { 1 } , . . . , z _ { K } ) _ { k } = \exp \{ z _ { k } \} / \sum _ { k ^ { \prime } = 1 } ^ { K } \exp \{ z _ { k ^ { \prime } } \} } \end{array}$ . Let $p ( \mathbf { w } , x ) = \sigma ( f ( \mathbf { w } , x ) )$ denote the neural network output in the form of a probability vector. For any probability vector $\begin{array} { r } { \ell ( \hat { p } , y ) = \sum _ { k = 1 } ^ { K } y ^ { ( k ) } \log \hat { p } ^ { ( k ) } } \end{array}$ denote cross-entropy loss. $\hat { p }$ , let
+
+Let $\mathbf { w } _ { 0 } , \mathbf { w } _ { 1 } , \mathbf { w } _ { 2 } , \ldots , \mathbf { w } _ { T }$ be the iterates of stochastic gradient descent (SGD), where, for some sequence of minibatches $S _ { 0 } , S _ { 1 } , \ldots , S _ { T - 1 } \subseteq S$ of size $M$ , we have
+
+$$
+\begin{array} { r } { \mathbf { w } _ { t } = \mathbf { w } _ { t - 1 } - \eta \sum _ { ( x , y ) \in S _ { t - 1 } } g _ { t - 1 } ( x , y ) , } \end{array}
+$$
+
+for $g _ { t - 1 } ( x , y ) = \nabla _ { \mathbf { w } _ { t - 1 } } \ell ( p ( \mathbf { w } _ { t - 1 } , x ) , y )$ , and $t = 1 , \dots , T$ .
+
+# 2.2 Gradient Norm Score and an infinitesimal analysis
+
+Fix a training set $S$ . Due to training with SGD from a random initialization, the weight vector at time $t > 0$ , $\mathbf { w } _ { t }$ , is a random variable. The expected magnitude of the loss vector is our primary focus:
+
+Definition 2.1. The GraNd score of a training example $( x , y )$ at time $t$ is $\chi _ { t } ( x , y ) = \mathbb { E } _ { \mathbf { w } _ { t } } \left\| g _ { t } ( x , y ) \right\| _ { 2 }$
+
+Here we describe conditions under which the GraNd score controls the contribution of a training example to the change in the training loss. In order to simplify our analysis, we approximate the training dynamics as if they were in continuous time.
+
+A key quantity in our analysis is the time derivative of the loss for a generic labeled example $( x , y )$ : $\begin{array} { r } { \Delta _ { t } ( ( x , y ) , S _ { t } ) = - \frac { \mathrm { d } \ell ( f _ { t } ( x ) , y ) } { \mathrm { d } t } } \end{array}$ (where $f _ { t } ( \cdot ) = f _ { \mathbf { w } _ { t } } ( \cdot ) )$ , i.e., the instantaneous rate of change in the loss on $( x , y )$ at time $t$ , where the gradient is computed on the minibatch $S _ { t }$ . By the chain rule,
+
+$$
+\begin{array} { r } { \Delta _ { t } ( ( x , y ) , S _ { t } ) = g _ { t } ( x , y ) \frac { \mathrm { d } { \mathbf w } _ { t } } { \mathrm { d } t } . } \end{array}
+$$
+
+This relates to our discrete time dynamics via $\begin{array} { r } { \frac { \mathrm { d } \mathbf { w } _ { t } } { \mathrm { d } t } \approx \mathbf { w } _ { t + 1 } - \mathbf { w } _ { t } = - \eta \sum _ { ( x ^ { \prime } , y ^ { \prime } ) \in S _ { t } } g _ { t } ( x ^ { \prime } , y ^ { \prime } ) } \end{array}$
+
+Our goal is to understand how removing a training point from minibatch $S _ { t }$ affects $\Delta _ { t } ( ( x ^ { * } , y ^ { * } ) , S _ { t } )$ for any $( x ^ { * } , y ^ { * } )$ . If a training point $( x , y )$ is not in the minibatch $S _ { t }$ , then the effect is trivial. We thus study $\Delta _ { t } ( ( x ^ { * } , y ^ { * } ) , S )$ in order to be able to rank all the training examples.
+
+Lemma 2.2. Let $S _ { \neg j } = S \setminus ( x _ { j } , y _ { j } )$ . Then for all $( x ^ { * } , y ^ { * } )$ , there exists c such that
+
+$$
+\begin{array} { r } { \| \Delta _ { t } ( ( x ^ { * } , y ^ { * } ) , S ) - \Delta _ { t } ( ( x ^ { * } , y ^ { * } ) , S _ { - j } ) \| \leq c \| g _ { t } ( x _ { j } , y _ { j } ) \| . } \end{array}
+$$
+
+Proof. For a given example $( x ^ { * } , y ^ { * } )$ , the chain rule yields $\begin{array} { r l } { \Delta _ { t } ( ( x ^ { * } , y ^ { * } ) , S ) } & { { } = } \end{array}$ $\begin{array} { r l r } { - \frac { \mathrm { d } \ell \left( f _ { t } ( x ^ { * } ) , y ^ { * } \right) } { \mathrm { d } t } } & { { } = } & { \frac { \mathrm { d } \ell ( f _ { t } ( x ^ { * } ) , \bar { y } ^ { * } ) } { \mathrm { d } \mathbf { w } _ { t } } \frac { \mathrm { d } \mathbf { w } _ { t } } { \mathrm { d } t } } \end{array}$ d\`(ft(x⇤),y⇤) dwt nce the weights ar GD, we have . Sitting e updated using S, the result follows. $\begin{array} { r } { \frac { \mathrm { d } \mathbf { w } _ { t } } { \mathrm { d } t } = - \eta \sum _ { ( x _ { j } , y _ { j } ) \in S _ { t } } g _ { t } ( x _ { j } , y _ { j } ) } \end{array}$ $\begin{array} { r } { c = \eta \Vert \frac { \mathrm { d } \ell ( f _ { t } ( x ^ { * } ) , y ^ { * } ) } { \mathrm { d } \mathbf { w } _ { t } } \Vert } \end{array}$ □
+
+At any given training step, given the current location $\mathbf { w } _ { t }$ , the contribution of a training example $( x , y ) ^ { \bar { 2 } }$ to the decrease of loss on any other example, is bounded by Eq. (3). Since the constant $c$ does not depend on the training example $( x , y ) ^ { 3 }$ , we only consider the gradient norm term, $\| g _ { t } ( x , y ) \|$ . The expected value of this gradient norm is exactly the GraNd score of $( x , y )$ . In other words, examples with a small GraNd score in expectation have a bounded influence on learning how to classify the rest of the training data at a given training time4. We therefore propose to rank training examples by their GraNd scores, larger norm meaning more important for preserving $\Delta _ { t } ( x )$ .
+
+For an arbitrary input $x \in \mathbb { R } ^ { d }$ , let $\psi _ { t } ^ { ( k ) } ( x ) = \nabla _ { \mathbf { w } _ { t } } f _ { t } ^ { ( k ) } ( x )$ denote the $k$ th logit gradient. Then GraNd can be written as5
+
+$$
+\begin{array} { r } { \chi _ { t } ( x , y ) = \mathbb { E } \left. \sum _ { k = 1 } ^ { K } \nabla _ { f ^ { ( k ) } } \ell ( f _ { t } ( x ) , y ) ^ { T } \psi _ { t } ^ { ( k ) } ( x ) \right. _ { 2 } . } \end{array}
+$$
+
+Under the cross entropy loss, $\nabla _ { f ^ { ( k ) } } \ell ( f _ { t } ( x ) , y ) ^ { T } = p ( \mathbf { w } _ { t } , x ) ^ { ( k ) } - y _ { k }$ . When $\{ \psi _ { t } ^ { ( k ) } ( x ) \} _ { k }$ are roughly orthogonal across logits, and are of a similar size across logits and training examples $x$ , then we can approximate GraNd by just the norm of the error vector.
+
+Definition 2.3. The EL2N score of a training sample $( x , y )$ is defined to be $\mathbb { E } \| p ( \mathbf { w } _ { t } , x ) - y \| _ { 2 }$ .
+
+Our experimental results suggest that this approximation becomes accurate after a few epochs of training (see Section 3). These approximations are also in agreement with the empirical results reported in [9, 10]. Fort and Ganguli [10, Sec. 5.1] demonstrate that the mean logit gradients are nearly orthogonal among classes throughout training. The authors demonstrate that per-example gradients cluster around the mean logit gradient. Fort et al. [9, Figs. 12D-14D] provide evidence that the mean logit gradient directions evolve rapidly early in training and then stabilize (as measured by the cosine distance between mean logit gradient vectors at different times in training).
+
+# 2.3 Comparison to forgetting scores
+
+Toneva et al. [8] define a “forgetting event” for a training sample to be a point in training when the classifier switches from making a correct classification decision to an incorrect one. They define an approximate forgetting score for each training example as the number of times during training when it was included in a minibatch and underwent a forgetting event. Toneva et al. demonstrate that examples with low forgetting score may be completely omitted during training without any noticeable effect on the accuracy of the learned predictor. In Fig. 1 and Appendix E.5, we make an empirical comparison of forgetting scores to our proposed GraNd and EL2N scores.
+
+In Lemma 2.2, we bounded the contribution of a training example to the decrease of the loss of any other sample over a single gradient step. Due to $\psi _ { t } ( \cdot )$ ’s being time-dependent, it is complicated to extend the analysis to multiple steps. However, it is interesting to consider a case when $\psi _ { t } ( x _ { i } ) =$ $\psi ( x _ { i } )$ for all $x _ { i }$ in the training set, and $K = 1$ . Then summing the bound in Eq. (3) on how much a sample $( x _ { j } , y _ { j } )$ affects the logit output on an arbitrary point at each time $t \in \{ 1 , . . , T \}$ , we obtain a score that depends on $\| \psi ( x _ { j } ) \| | \sum _ { t } ( p _ { t } ( x _ { j } ) - y _ { j } ) |$ . For two examples, $( x , y )$ and $( x ^ { \prime } , y ^ { \prime } )$ , such that $\| \psi ( x ^ { \prime } ) \| \approx \| \psi ( x ) \|$ , we see that the example that is learned faster and maintains small error over training time will have a smaller GraNd score on average throughout training. Note that $| ( p _ { t } ( x _ { j } ) - y _ { j } ) |$ , if rescaled, is an upper bound on 0–1 loss, and therefore $\begin{array} { r } { \sum _ { t } | ( p _ { t } ( x _ { j } ) - y _ { j } ) | } \end{array}$ upper bounds the number of forgetting events during training (after rescaling). In this simplified setting an example with a high number of forgetting events will also have a high GraNd score.
+
+# 3 Empirical Evaluation of GraNd and EL2N Scores via Data Pruning
+
+In the previous section, we motivated GraNd and EL2N scores by quantifying the influence of a training example on the loss of an arbitrary example after one optimization step. In this section, we evaluate these scores empirically, and verify that they identify examples important for generalization. Networks trained on subsets of the data with high scores achieve levels of test accuracy comparable to training on the full dataset and are competitive with other state of the art data pruning methods. Perhaps most remarkably, these scores are effective even when computed early in training and perform significantly better than a random baseline, even at initialization.
+
+![](images/de5af3c5a609fd0da97bc2ce8dd9af85b689ca65e8e7bf483be222f7cfa2b8da.jpg)  
+Figure 1: Columns correspond to three different dataset and network combinations (labeled at the top). Each legend applies to all 3 figures in its row. First row: Final test accuracy achieved by training on a subset of training data comprised of examples with maximum forgetting, EL2N and GraNd scores computed at different times early in training. Subsets of a fixed size are used: networks are trained on $50 \%$ of training data for CIFAR-10, $60 \%$ for CINIC-10 and $7 5 \%$ for CIFAR-100. Second row: Final test accuracy achieved by training after different fractions of the dataset are pruned. Here we compare forgetting scores at the end of training, EL2N scores early in training (at epoch 20) and GraNd scores at initialization. In each case, examples with the lowest scores are pruned at initialization. In all experiments accuracies achieved by training on the full dataset and on a random subset of the corresponding size are used as baselines.
+
+Data pruning experiments. We train convolutional neural networks of varying depth–ResNet18 and ResNet50 [11]–on standard vision datasets of varying difficulty–CIFAR-10, CIFAR-100 [12], and CINIC-10 [13]. All scores are calculated by averaging the scores from ten independent training runs. After calculating scores and selecting a training subset, final test accuracies are obtained by retraining networks from new random initializations on only the selected subset. Networks used for evaluating the scores are initialized with seeds that are different from those used to calculate the scores. For each experiment, we report the mean of four independent runs and represent variability across runs by shading the region which spans the 16th to 84th percentile of obtained accuracies. See Appendix B for more implementation details and Appendix E for additional experiments.
+
+In Fig. 1, we show the results of two sets of experiments (top and bottom) on three different network and dataset combinations. The first experiment asks, how early in training are forgetting, GraNd and EL2N scores effective at identifying examples important for generalization? We compare the final test accuracy from training on subsets of fixed size but pruned based on scores computed at different times early in training. The second experiment compares how GraNd scores at initialization, EL2N scores early in training and forgetting scores at the end of training negotiate the trade-off between generalization performance and training set size. The training sets are constructed by pruning different fractions of the lowest score examples. In all examples, training on the full dataset and a random subset of the corresponding size are used as baselines. We make the following observations.
+
+Pruning at initialization. In all settings, GraNd scores can be used to select a training subset at initialization that achieves test accuracy significantly better than random, and in some cases, competitive with training on all the data. This is remarkable because GraNd only contains information about the gradient norm at initializion, averaged over initializations. This suggests that the geometry of the training distribution induced by a random network contains a surprising amount of information about the structure of the classification problem. EL2N scores, which only contain information about errors, are not consistently effective at initialization and forgetting scores, which require counting forgetting events over training, are not defined at initialization.
+
+Pruning early in training. We find that, after only a few epochs of training, EL2N scores are extremely effective at identifying important examples for generalization. For a wide range of intermediate pruning levels, training on the highest scores performs on par with or better than training on the full dataset. Even at higher pruning levels, EL2N scores computed using local information early in training are competitive with forgetting scores which integrate information over the training trajectory. This suggests that the average error vector a few epochs into training can identify examples that the network heavily uses to shape the decision boundary throughout training.
+
+Interestingly, at extreme levels of pruning with either EL2N or GraNd scores, we observe a sharp drop in performance. We hypothesize that this is because at high levels of pruning, using either GraNd or EL2N scores leads to bad coverage of the data distribution. By only focusing on the highest error examples, it is likely that an entire subpopulation of significant size that is present in the test data is now excluded from the training set. We only fit a small number of very difficult examples and do not keep enough of a variety of examples for training models with good test error.
+
+A property of the data. Our results suggest that the ranking of important examples induced by EL2N scores is a property of the dataset and not specific to a network. First, in Appendix E.2, we show that a ResNet18 and a ResNet50 trained on CIFAR-10 have similar performance curves and the same amount of data can be pruned, even though ResNet50 is a much deeper network with more parameters. Second, EL2N scores calculated on one set of network architecture and hyperparameter configurations can be used to prune data for training with a different network architecture or hyperparameter configuration. The set of important examples generalizes across architectures and hyperparameters. See Appendix E.3 for the experiment on generalization across architectures and Appendix E.4 for the experiment on using scores calculated during hyperparameter optimization. Additionally, in an analysis of the sensitivity of the scoring methods to hyperparameters in Appendix E.1, we observe that scores calculated on a single network do not perform as well as those averaged across networks.
+
+We hypothesize that averaging the gradient or error norms over multiple initializations or training trajectories removes dependence on specific weights, allowing a more accurate distillation of the properties of the dataset. EL2N scores can thus be used to probe and understand how the distribution of the training data impacts dynamics (as we show in the next sections). Additionally, it can also reduce the computational burden of training neural networks; once we compute the scores, future networks can be trained on the pruned dataset.
+
+In the following experiments, we focus on EL2N scores computed early in training, as they appear to more accurately identify important examples.
+
+# 4 Identifying noise examples
+
+In the previous section, we studied the effect of keeping the highest-scoring examples, and found that we could train on only the top $50 \%$ of examples by score without a drop in accuracy (CIFAR-10). What is the nature of subpopulations of examples that allow us to reach high accuracy? One hypothesis is that the highest-scoring examples are the most important ones for achieving an accurate classifier. In this section, we refute this hypothesis, and demonstrate the role of label noise.
+
+![](images/f03b77e3d671d9eb8d8b4b2f965c6b1156f6ac57c90d2f23891b55a6551c8a9a.jpg)  
+Figure 2: ResNet18 trained on a $40 \%$ subset of CIFAR-10 with clean (left) and $10 \%$ randomized labels (right). The training subset contains the lowest scoring examples after examples with scores below the offset are discarded. Scores computed at epoch 10.
+
+To test whether the highest-scoring examples are most important for achieving high accuracy, we first sort the examples by increasing EL2N score computed after a small number of training epochs.6 Then we perform a sliding window analysis by training on a subset of examples with scores within a window from percentile $f$ to percentile $f + P$ percentile, always keep $P \%$ of the data but sliding up $f$ . As this window slides to higher percentiles, performance increases, except when the window includes examples with the very highest scores Fig. 2 (left). Indeed the the optimal sliding window actually excludes approximately 500 of the highest-scoring training examples. These effects are reduced in the low pruning regime (see Appendix F.1). In Appendix C, we visualize some of the images that are excluded from each class.
+
+Before we analyze these results, we first place them into a wider context, where we also change the amount of noise in the underlying label distribution. We repeat the experiment outlined above, but corrupt a random $K \%$ of labels, replacing them with a random label, mirroring the protocol popularized by Zhang et al. [14]. Fig. 2 reveals that with increased label corruption, the optimal window shifts and excludes a higher number of examples. Therefore, the effect we see in the noiseless case appears to be magnified in the presence of label noise. Appendix F.2 examines how adding label noise influences the distribution of EL2N scores of examples.
+
+These findings have several implications. The most obvious implication is that training with only the highest-scoring samples may not be optimal, especially when there is label noise. When the population has a low Bayes error rate, using only the highest scoring samples yields optimal results. However, without a validation set, one should be cautious in excluding high-score examples. Feldman [15] discusses memorization in a noisy-label setup and gives conditions under which one should memorize in order to not misclassify singleton examples ( examples in the training data that are the sole representatives of a subpopulation). For example, if the subpopulation appears with a frequency $\Omega ( 1 \bar { / } N )$ , memorizing such examples can improve generalization. In practice, we may not know whether our data fits these conditions. However, our analysis in Fig. 2 suggests a simple and powerful method to prune data for optimal performance by optimizing just two hyperparameters of a sliding window using a validation set.
+
+# 5 Optimization landscape and the training dynamics
+
+# 5.1 Evolution of the data-dependent NTK
+
+The dynamics of neural-network training in the infinite-width limit are now well understood [16, 17]: for an appropriate scaling of the learning rate and initial weights, the neural network behaves like a linear model in which the data is transformed by the Neural Tangent Kernel (NTK) at initialization, which is defined as the product of the Jacobians of the logits at initialization. In the limit, neural network training implements kernel regression with the fixed NTK as the kernel.
+
+However, finite neural networks outperform their infinitewidth limits [18] and have different dynamics early in training [19]. In fact, rather than being constant, the datadependent NTK, defined by Fort et al. [9] as the Gram matrix of the logit Jacobian, evolves with high velocity in the initial phase of training. Then, around the time of onset of linear mode connectivity, the NTK velocity stabilizes at a smaller value and remains nearly constant for the rest of the high learning rate training time.
+
+![](images/be06056521925d5e757e883f793e4b50e8e147bb05901f045efac7f85afdc315.jpg)  
+Figure 3: Kernel velocity for different subsets of images when ResNet18 is trained on CIFAR-10 with all true labels (left) and $10 \%$ label noise (right). Examples are sorted in ascending order by EL2N scores and each point corresponds to the kernel velocity of 100 contiguous images starting at example index. Both scores and velocities are computed at the same epoch indicated by color.
+
+Here we seek to understand which training samples contribute to the NTK gram matrix evolution. To empirically approximate the velocity of a NTK submatrix corresponding to a subset of images in a scale invariant way, we follow [9]. We compute the cosine distance between two NTK gram matrices on the given subset, one computed at epoch $t$ , and another one at epoch $t { + } 1$ , one epoch later (see Appendix B.3). We look at submatrices of a fixed size, formed by examples with contiguous EL2N scores. Fig. 3 shows that higher EL2N scores lead to higher velocities. This relationship is not affected by the time at which both are computed.
+
+Interestingly, the kernel velocity drops off sharply for examples with the very highest scores when label noise is introduced. In Section 4, we showed that dropping these examples boosts the accuracy of the final predictor. We hypothesize that, while the kernel velocity is higher for harder examples that the model is actively trying to fit, the kernel velocity drops off for the very highest scoring examples that might be too difficult to learn, perhaps because they are unrepresentative samples or they have have label noise.
+
+# 5.2 Connections to the Linear Mode Connectivity
+
+We now examine how the ranking of the examples by EL2N connects to the geometry of the loss surface. In particular, Frankle et al. [20] studied the effect of minibatch randomness on the training trajectory, focusing on identifying the point in training when two networks, starting from the same weights, but trained with independent minibatches, converge to the same “linearly connected” mode. They find that, for standard vision datasets, the onset of this “linear mode connectivity” (LMC) happens early in training.
+
+More precisely, let $w _ { 1 } , w _ { 2 } , \dots , w _ { T }$ be the training trajectory of a parent network, fix a spawning time $t ^ { * }$ , and let $v _ { t ^ { * } }$ , $v _ { t ^ { * } + 1 }$ , $v _ { t ^ { * } + 2 } , \ldots , v _ { T }$ be an independent training trajectory (i.e., with independent minibatches), beginning at $v _ { t ^ { * } } = w _ { t ^ { * } }$ . We call $v _ { T }$ the child network and $v _ { t ^ { * } } , v _ { t ^ { * } + 1 } , \ldots .$ the child trajectory. The (training) error barrier between two weights $w$ and $w ^ { \prime }$ , denoted $\mathrm { e r r } ( w , w ^ { \prime } ; S )$ , is the maximum deviation of the training error surface ${ \hat { R } } _ { S } ( \cdot )$ above the line connecting the empirical risk at $w$ and $w ^ { \prime }$ . That is,
+
+$$
+\begin{array} { r } { \mathrm { e r r } ( w , w ^ { \prime } ; S ) = \operatorname* { s u p } _ { \alpha \in [ 0 , 1 ] } \left\{ \hat { R } _ { S } ( \alpha w + ( 1 - \alpha ) w ^ { \prime } ) - \alpha \hat { R } _ { S } ( w ) - ( 1 - \alpha ) \hat { R } _ { S } ( w ^ { \prime } ) \right\} . } \end{array}
+$$
+
+We then define the mean (training) error barrier, spawning at $t ^ { * }$ , at time $t$ , for $t ^ { * } \leq t \leq T$ , denoted $\mathrm { e r r } _ { t } ^ { t ^ { * } } ( S )$ , to be the expected error barrier between $w _ { t }$ and $v _ { t }$ on the data $S$ . That is,
+
+$$
+\mathrm { e r r } _ { t } ^ { t ^ { * } } ( S ) = \mathbb { E } _ { w _ { t ^ { * } + 1 : t } , v _ { t ^ { * } + 1 , t } } [ \mathrm { e r r } ( w _ { t } , v _ { t } ; S ) ] ,
+$$
+
+where the expectation is taken over the randomness in the trajectories of $w$ and $v$ after $t ^ { * }$ due to the choice of minibatches, conditional on the initial trajectories up through time $t ^ { * }$ . (Note that, at the end of training $t = T$ , the supremum in $\mathrm { e r r } ( w _ { T } , v _ { T } ; S )$ is often achieved near $\alpha = 1 / 2$ , and so this is a cheap approximation used in practice.) The “onset” of linear mode connectivity is the earliest spawning time $t ^ { * }$ at which point $\mathrm { e r r } _ { T } ^ { t ^ { * } } ( S ) \approx 0$ , where $S$ is the whole training set. In our work, we instead compute the error barrier on subsets of the training set, which allows us to compare the training dynamics and modes on subpopulations.
+
+In Fig. 4, we measure the mean error barrier $\mathrm { e r r } _ { t } ^ { t ^ { * } } ( S ^ { \prime } )$ as a function of the spawning time $t ^ { * }$ , in the cases where $S ^ { \prime }$ are either 1) the training examples with the smallest scores, 2) the largest scores, or 3) a random subset of training examples. We find that the error barrier falls close to zero very rapidly for examples that have low EL2N scores, and stays high for high score examples. These findings suggest that the loss landscape derived from restricted subsets of examples with low and high EL2N behave very differently. The loss landscape derived from easy subsets of examples with low scores is quite flat, in the sense that error barriers between children as a function of spawn time rapidly diminish. On the other hand, the loss landscape derived from harder subsets of examples with higher scores is rougher, with higher error barriers that persist for longer in the spawn time. Further, this result is in agreement with the results presented in Section 5.1, showing that most of the learning happens in the high EL2N score examples.
+
+# 6 Related Work
+
+As discussed earlier, our work is closely related to an empirical study by Toneva et al. [8], which examines the frequency with which correct classification decisions are forgotten during training.
+
+![](images/774d18f9da13c888136150d8efa81dd83fcc166153e431f3b2c92f0cb3ec0bf4.jpg)  
+Figure 4: The final training error barrier between children on subsets of a 1000 highest (green) and lowest (orange) EL2N score examples, and randomly selected training subset (blue) as a function of the spawning time. Left to right: different dataset and network combinations.
+
+The authors observe that examples that are rarely forgotten are also ones that do not contribute much to the final accuracy of the predictor. In particular, if we retrain from initialization after having removed rarely forgotten examples from the training data, we achieve the same accuracy. Similar to our work, this work analyzes the dynamics of training in deep learning through the lens of training examples. However, unlike forgetting scores, our proposed methods use only local information early in training. This highlights two properties: example importance is reflected in the local properties of the loss landscape after a few epochs and the ordering of examples by importance is roughly preserved throughout training. We think that this is a key contribution and hope it prompts future empirical and theoretical work exploring the early stage of learning.
+
+Coleman et al. [1] use a small proxy network in combination with other training data selection methods to find a small subset of important-for-training examples, that can then be used to train a large state-of-the-art (SOTA) deep neural network. In their empirical study, they observe that most important examples selected via a proxy model are also important for training a SOTA network. In addition, they study a proxy which reuses SOTA network’s architecture but is trained for a shorter time. The authors observe that selecting the important examples after at least 50 epochs of training works better than selecting them at random, but not as well as after the full training run. They do not study shorter training times for proxies or relate it to the training dynamics in any other way.
+
+Another line of related work is on coresets (see, e.g., [4, 5, 7, 21–23], and many others). The term coresets generally refers to a possibly weighted subset of training data. Much of the work on coresets is focused on identifying small training data subsets that provably yield an $\epsilon$ -approximate solution to the original objective (on all the training data). Most guarantees require the problem to have special structure, such as convexity. For nonconvex problems, like training deep neural networks, guarantees are provided for very conservative proxies, e.g., based on Lipschitz constants or smoothness. While coreset selection comes with nice theoretical guarantees, in our opinion, the utility of these methods is best considered an empirical question.
+
+Coresets have also been studied in the active learning community. Here, the goal is to select a small set of examples to label at any given iteration of training (see, e.g., [24–28], and references therein). Coreset selection has also been proposed as a way to increase model robustness [29].
+
+Pleiss et al. use a similar method, the Area Under the Margin (AUM) statistic, but with a slightly different goal: identifying noisy and mislabeled examples. Their proposed method exploits differences in the training dynamics of clean and mislabeled samples by keeping track of statistics through the course of training. The AUM statistic is similar to forgetting scores in that it uses information from the whole training run. In contrast, we focus on instantaneous information in the early phase of training. In addition to identifying noisy examples, we aim to rank points by importance and therefore also identify redundant/easy examples. Thus our approach is complimentary to the AUM statistic and can be used together to obtain higher levels of pruning on noisy datasets.
+
+There have been a number of recent studies looking at the problem of estimating example difficulty. One such approach for identifying difficult examples within a given class is the Variance of Gradients (VoG) score proposed by Agarwal, D’souza, and Hooker [31]. For each image, they calculate the gradient of the activations with respect to the pixels at $K$ different checkpoints over training. The VoG score is the average (over pixels) of the per-pixel variance across these $K$ checkpoints. The authors conclude that the images that appear more difficult also have a higher VoG score. Understanding the connections between these two scores calculated in entirely different spaces is an interesting direction for future work.
+
+Another quite different approach estimates example difficulty using prediction depth [32], which is defined as the first layer at which a $\mathbf { k }$ -Nearest Neighbor classifier can correctly classify an example using the representation of the image in all subsequent layers. In additional to methodological differences, this method uses the final trained network. To our knowledge, we are the first to highlight the existence of a strong signal for estimating example difficulty early in training.
+
+Informally, removing a training example from the training data and not hurting the generalization error suggests that the example has small “influence” on the test data. Influence of the training examples on test examples is studied in sample-based explainability [33–35]. On the theory side, Feldman [15] recently proposed to model data as a mixture of populations and study the role of memorization when the data distribution is long-tailed. Feldman demonstrates conditions under which memorization is necessary for good generalization. In doing so, he proposes a definition of example memorization and influence, which can be interpreted as a leave-one-out notion of stability. In an empirical study following this work, Feldman and Zhang [36] demonstrate that classifiers trained on computer vision benchmarks benefit from memorization. In particular, training without high-memorization-value examples comes at a cost of accuracy of the learned neural network classifier. In Appendix G, we compare GraNd, EL2N, forgetting scores, and memorization values on CIFAR-100-trained Resnet50 networks; memorization values do not correlate with the other scores.
+
+# 7 Discussion
+
+In summary, our work both (1) introduces methods to significantly prune data without sacrificing test accuracy using only local information very early in training (Fig. 1), sometimes even at initialization, and (2) uses the resulting methods to obtain new scientific insights into how different subsets of training examples drive the dynamics of deep learning. We start from a principled approach by asking how much on average each training example influences the loss reduction of other examples, and from that starting point, we obtain 2 scores, namely gradient norm (GraNd) and error norm (EL2N) that bound or approximate this influence, with higher scores indicating higher potential influence. We find that examples with higher scores tend to be harder to learn, in the sense that they are forgotten more often over the entire course of training. We also find that the very highest scoring examples tend to be either unrepresentative outliers of a class, have non standard backgrounds or odd angles, are subject to label noise, or are otherwise difficult. This observation yields a simple and powerful sliding window method (Fig. 2) to prune data by keeping examples within a range of scores, where the start and the end of the range constitute just 2 hyperparmeters that can be tuned via a validation set. This tuning can be done using different hyperparameter settings or on a different network saving computation time (Appendix E.3). Furthermore, we find that high-scoring examples primarily drive feature learning by maximally supporting the velocity of the NTK, whereas learning dynamics might actually give up on the very highest scoring examples that may correspond to unrepresentative examples or noise (Fig. 3). Finally we show that higher (lower) scoring subsets of examples contribute to a rougher (smoother) loss landscape (Fig. 4). Overall this decomposition of both loss landscape geometry and learning dynamics into differential contributions from different types of examples constitutes an exciting new methodology for analyzing deep learning. A deeper understanding of the differential role played by different subsets of examples could aid not only in data pruning, but also in curriculum design, active learning, federated learning with privacy, and analysis of fairness and bias. Our empirical findings raise a number of interesting theoretical questions, some of which we discuss in Appendix D.
+
+# Acknowledgements
+
+The authors would like to thank Blair Bilodeau, Alex Drouin, Étienne Marcotte, and Daniel M. Roy for feedback on drafts, the Toolkit team at ServiceNow for providing the tools and computation resources that greatly accelerated our empirical work, and the NeurIPS reviewers for their thorough engagement and invaluable feedback on label-dependence and practical applications. S.G. thanks the Simons Foundation, NTT Research and an NSF Career award for funding while at Stanford.
+
+# References
+
+Zaharia. Selection via proxy: Efficient data selection for deep learning. 2019. arXiv: 1906. 11829.   
+[2] M. Hwang, Y. Jeong, and W. Sung. “Data distribution search to select core-set for machine learning”. In: Proc. 9th Int. Conf. Smart Media & Appl. (SMA 2020), Jeju, Korea. 2020, pp. 17–19.   
+[3] S. Har-Peled and A. Kushal. “Smaller coresets for $\mathbf { k }$ -median and $\mathbf { k }$ -means clustering”. Discrete & Computational Geometry 37.1 (2007), pp. 3–19.   
+[4] J. H. Huggins, T. Campbell, and T. Broderick. “Coresets for scalable bayesian logistic regression” (2016). arXiv: 1605.06423.   
+[5] T. Campbell and T. Broderick. “Bayesian coreset construction via greedy iterative geodesic ascent”. In: Int. Conf. Machine Learning. PMLR. 2018, pp. 698–706.   
+[6] I. W. Tsang, J. T. Kwok, P.-M. Cheung, and N. Cristianini. “Core vector machines: Fast SVM training on very large data sets.” Journal of Machine Learning Research 6.4 (2005).   
+[7] A. Munteanu, C. Schwiegelshohn, C. Sohler, and D. P. Woodruff. On coresets for logistic regression. 2018. arXiv: 1805.08571.   
+[8] M. Toneva, A. Sordoni, R. T. d. Combes, A. Trischler, Y. Bengio, and G. J. Gordon. An empirical study of example forgetting during deep neural network learning. 2018. arXiv: 1812.05159.   
+[9] S. Fort, G. K. Dziugaite, M. Paul, S. Kharaghani, D. M. Roy, and S. Ganguli. “Deep learning versus kernel learning: an empirical study of loss landscape geometry and the time evolution of the Neural Tangent Kernel”. In: Advances in Neural Information Processing Systems. 2020. arXiv: 2010.15110.   
+[10] S. Fort and S. Ganguli. “Emergent properties of the local geometry of neural loss landscapes”. arXiv preprint arXiv:1910.05929 (2019).   
+[11] K. He, X. Zhang, S. Ren, and J. Sun. “Deep residual learning for image recognition”. In: Proceedings of the IEEE conference on computer vision and pattern recognition. 2016, pp. 770– 778.   
+[12] A. Krizhevsky, V. Nair, and G. Hinton. “Learning multiple layers of features from tiny images” (2009).   
+[13] L. N. Darlow, E. J. Crowley, A. Antoniou, and A. J. Storkey. “CINIC-10 is not ImageNet or CIFAR-10”. CoRR abs/1810.03505 (2018). arXiv: 1810.03505.   
+[14] C. Zhang, S. Bengio, M. Hardt, B. Recht, and O. Vinyals. “Understanding deep learning requires rethinking generalization”. In: Int. Conf. Representation Learning (ICLR). 2017. arXiv: 1611.03530v2.   
+[15] V. Feldman. “Does learning require memorization? a short tale about a long tail”. In: Proc. 52nd Ann. ACM SIGACT Symp. Theory of Comput. (STOC). 2020, pp. 954–959.   
+[16] A. Jacot, F. Gabriel, and C. Hongler. “Neural tangent kernel: Convergence and generalization in neural networks”. In: Advances in Information Processing Systems (NeurIPS). 2018. arXiv: 1806.07572.   
+[17] J. Lee, L. Xiao, S. S. Schoenholz, Y. Bahri, R. Novak, J. Sohl-Dickstein, and J. Pennington. Wide neural networks of any depth evolve as linear models under gradient descent. 2019. arXiv: 1902.06720.   
+[18] S. Arora, S. S. Du, Z. Li, R. Salakhutdinov, R. Wang, and D. Yu. Harnessing the power of infinitely wide deep nets on small-data tasks. 2019. arXiv: 1910.01663.   
+[19] A. Lewkowycz, Y. Bahri, E. Dyer, J. Sohl-Dickstein, and G. Gur-Ari. The large learning rate phase of deep learning: the catapult mechanism. 2020. arXiv: 2003.02218.   
+[20] J. Frankle, G. K. Dziugaite, D. Roy, and M. Carbin. “Linear mode connectivity and the lottery ticket hypothesis”. In: Int. Conf. Machine Learning (ICML). 2020, pp. 3259–3269. arXiv: 1912.05671.   
+[21] P. K. Agarwal, S. Har-Peled, K. R. Varadarajan, et al. “Geometric approximation via coresets”. Combinatorial and computational geometry 52 (2005), pp. 1–30.   
+[22] D. Feldman, M. Schmidt, and C. Sohler. “Turning big data into tiny data: Constant-size coresets for k-means, PCA, and projective clustering”. SIAM J. Computing 49.3 (2020), pp. 601– 657.   
+[23] E. Tolochinsky and D. Feldman. Coresets for monotonic functions with applications to deep learning. 2018. arXiv: 1802.07382.   
+[24] K. Wei, R. Iyer, and J. Bilmes. “Submodularity in data subset selection and active learning”. In: Int. Conf. Machine Learning. PMLR. 2015, pp. 1954–1963.   
+[25] O. Sener and S. Savarese. Active learning for convolutional neural networks: A core-set approach. 2017. arXiv: 1708.00489.   
+[26] K. Killamsetty, D. Sivasubramanian, G. Ramakrishnan, and R. Iyer. GLISTER: Generalization based Data Subset Selection for Efficient and Robust Learning. 2020. arXiv: 2012 . 10630.   
+[27] B. Mirzasoleiman, J. Bilmes, and J. Leskovec. “Coresets for data-efficient training of machine learning models”. In: Int. Conf. Machine Learning (ICML). PMLR. 2020, pp. 6950–6960. arXiv: 1906.01827.   
+[28] Y. Shen, H. Yun, Z. C. Lipton, Y. Kronrod, and A. Anandkumar. Deep active learning for named entity recognition. 2017. arXiv: 1707.05928.   
+[29] B. Mirzasoleiman, K. Cao, and J. Leskovec. “Coresets for Robust Training of Neural Networks against Noisy Labels” (2020). arXiv: 2011.07451.   
+[30] G. Pleiss, T. Zhang, E. R. Elenberg, and K. Q. Weinberger. “Identifying mislabeled data using the area under the margin ranking”. arXiv preprint arXiv:2001.10528 (2020).   
+[31] C. Agarwal, D. D’souza, and S. Hooker. “Estimating example difficulty using variance of gradients”. arXiv preprint arXiv:2008.11600 (2020).   
+[32] R. J. N. Baldock, H. Maennel, and B. Neyshabur. Deep Learning Through the Lens of Example Difficulty. 2021. arXiv: 2106.09647 [cs.LG].   
+[33] P. W. Koh and P. Liang. “Understanding black-box predictions via influence functions”. In: Int. Conf. Machine Learning. PMLR. 2017, pp. 1885–1894.   
+[34] E. Barshan, M.-E. Brunet, and G. K. Dziugaite. “Relatif: Identifying explanatory training samples via relative influence”. In: Int. Conf. Artificial Intelligence and Statistics (AISTATS). 2020, pp. 1899–1909.   
+[35] G. Pruthi, F. Liu, S. Kale, and M. Sundararajan. “Estimating Training Data Influence by Tracing Gradient Descent”. In: Advances in Neural Information Processing Systems. 2020.   
+[36] V. Feldman and C. Zhang. What neural networks memorize and why: Discovering the long tail via influence estimation. 2020. arXiv: 2008.03703.   
+[37] J. Bradbury, R. Frostig, P. Hawkins, M. J. Johnson, C. Leary, D. Maclaurin, G. Necula, A. Paszke, J. VanderPlas, S. Wanderman-Milne, and Q. Zhang. JAX: composable transformations of Python+NumPy programs. Version 0.2.5. 2018.   
+[38] J. Heek, A. Levskaya, A. Oliver, M. Ritter, B. Rondepierre, A. Steiner, and M. van Zee. Flax: A neural network library and ecosystem for JAX. Version 0.3.4. 2020.

parse/train/Uj7pF-D-YvT/Uj7pF-D-YvT_content_list.json

@@ -0,0 +1,1147 @@
+[
+    {
+        "type": "text",
+        "text": "Deep Learning on a Data Diet: Finding Important Examples Early in Training ",
+        "text_level": 1,
+        "bbox": [
+            215,
+            122,
+            784,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mansheej Paul Stanford University mansheej@stanford.edu ",
+        "bbox": [
+            230,
+            226,
+            415,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Surya Ganguli Stanford University; Facebook AI Research sganguli@stanford.edu ",
+        "bbox": [
+            478,
+            226,
+            766,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Gintare Karolina Dziugaite Mila ⇤ gkdz@google.com ",
+        "bbox": [
+            401,
+            289,
+            594,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            367,
+            535,
+            383
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent success in deep learning has partially been driven by training increasingly overparametrized networks on ever larger datasets. It is therefore natural to ask: how much of the data is superfluous, which examples are important for generalization, and how do we find them? In this work, we make the striking observation that, in standard vision datasets, simple scores averaged over several weight initializations can be used to identify important examples very early in training. We propose two such scores—the Gradient Normed (GraNd) and the Error L2-Norm (EL2N) scores—and demonstrate their efficacy on a range of architectures and datasets by pruning significant fractions of training data without sacrificing test accuracy. In fact, using EL2N scores calculated a few epochs into training, we can prune half of the CIFAR10 training set while slightly improving test accuracy. Furthermore, for a given dataset, EL2N scores from one architecture or hyperparameter configuration generalize to other configurations. Compared to recent work that prunes data by discarding examples that are rarely forgotten over the course of training, our scores use only local information early in training. We also use our scores to detect noisy examples and study training dynamics through the lens of important examples—we investigate how the data distribution shapes the loss surface and identify subspaces of the model’s data representation that are relatively stable over training. ",
+        "bbox": [
+            233,
+            400,
+            764,
+            662
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            691,
+            310,
+            709
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, deep learning has made remarkable progress driven, in part, by training overparameterized models on ever larger datasets. This trend creates new challenges: the large computational resources required pose a roadblock to the democratization of AI. Memory and resource constrained settings, such as on-device computing, require smaller models and datasets. Identifying important training data plays a role in online and active learning. Finally, it is of theoretical interest to understand how individual examples and sub-populations of training examples influence learning. ",
+        "bbox": [
+            174,
+            726,
+            823,
+            809
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To address these challenges, we propose a scoring method that can be used to identify important and difficult examples early in training, and prune the training dataset without large sacrifices in test accuracy. We also investigate how different sub-populations of the training data identified by our score affect the loss surface and training dynamics of the model. ",
+        "bbox": [
+            176,
+            815,
+            823,
+            869
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent work on pruning data [1, 2], can be placed in the broader context of identifying coresets— examples that provably guarantee a small gap in training error on the full dataset [3–7]. However, due to the nonconvex nature of deep learning, coreset techniques make conservative estimates that lead to weak theoretical guarantees and are less effective in practice. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            147
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A different approach recently proposed by Toneva et al. [8] tracks the number of times through training an example transitions from being correctly classified to misclassified, called a \"forgetting event\", and find that some examples are rarely forgotten, while others are forgotten repeatedly. Empirically, they observed that training accuracy is not affected by the rarely forgotten training examples and a large fraction of the training data can be removed without any impact on test accuracy. However, since this method relies on collecting forgetting statistics throughout training, the forgetting score is typically calculated in the middle of or at the end of training. Toneva et al. [8] find that, in their example of a ResNet18 trained on CIFAR-10 for 200 epochs, the Spearman rank correlation between early and late scores is good after about 25 epochs and stabilizes after 75 epochs. ",
+        "bbox": [
+            174,
+            154,
+            823,
+            279
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Broadly speaking, the ability to prune datasets raises a number of questions: What is the nature of examples that can be removed from the training data without hurting accuracy? How early in training can we recognize such examples? How many examples do we need and how does this depend on the data distribution? These questions may have no generic answers and so, in this work, we begin to pursue them empirically in the context of several standard vision benchmarks and standard network architectures. Answers to these questions may both (1) lead to new methodologies that could dramatically reduce training times and memory requirements, and (2) offer important insights into the training dynamics of deep neural networks, and the role of data. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            395
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our first finding is that very early in training (just a few epochs), partial forgetting scores identify large fractions of data that can be pruned. Analyzing this puzzling result with a one gradient step analysis of training suggests a very simple heuristic: use the loss gradient norm of individual examples to identify important examples. While this approach does not work when the loss gradient norms are computed at the weights early in training of a single trajectory, we find that, surprisingly, averaging these norms over multiple weight initializations does produce a ranking that correlates strongly with forgetting scores and allows us to prune a significant fraction of examples early in training. Indeed, we can prune $50 \\%$ of examples from CIFAR-10 without affecting accuracy, while on the more challenging CIFAR-100 dataset, we can prune $2 5 \\%$ of examples with only a $1 \\%$ drop in accuracy. ",
+        "bbox": [
+            174,
+            401,
+            825,
+            540
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Through a series of empirical studies, we have begun to tease apart the properties of important examples and how they can depend on the data distribution. In particular, we find that the examples with the very highest norms become superfluous as the amount of label noise increases. Indeed, even on clean data, we find that in the high pruning regime, the best population excludes the very highest-scoring examples. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            616
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 Contributions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            637,
+            310,
+            651
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose to score the importance of each training example $( x _ { i } , y _ { i } )$ by its expected loss gradient norm (GraNd score), which, up to a constant, bounds the expected change in loss for an arbitrary example $( x , y )$ caused by removing $( x _ { i } , y _ { i } )$ . ",
+        "bbox": [
+            192,
+            662,
+            825,
+            704
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We show that pruning training samples with small GraNd scores at initialization allows one to train on much smaller subset of the training data without significant loss in accuracy. While the pruning levels are comparable to those provided by other methods [1, 8], our score is the only one that is well-defined at initialization and early in training. ",
+        "bbox": [
+            192,
+            712,
+            825,
+            768
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Our experimental findings suggest that, within the first few epochs of training, the GraNd score is well-approximated by the norm of the error vector (EL2N score), where the error vector is the predicted class probabilities minus one-hot label encoding. In fact, we find that the EL2N score provides an even stronger signal for data-pruning—for CIFAR10 we can prune $50 \\%$ of the data, and for the harder CIFAR100, we can prune as much as $2 5 \\%$ of the data without any loss in test accuracy. ",
+        "bbox": [
+            192,
+            776,
+            825,
+            859
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We study the role of examples with the highest EL2N scores, and find that excluding a small subset of the very highest scoring examples produces a boost in performance. This boost in performance is enhanced in a corrupted label regime. ",
+        "bbox": [
+            192,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We introduce a method, based on linearly connected modes, for studying the empirical risk surface in terms of the modes of subsets of data, allowing us to identify when, in training, the final performance on subpopulations is determined. We demonstrate that the linearly connected mode at-convergence of empirical risk surface computed on low EL2N score examples is determined much earlier in training compared to high score examples. ",
+        "bbox": [
+            192,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Finally, we study how an example’s EL2N score connects to the network’s training dynamics. We do so by tracking the data-dependent NTK submatrices corresponding to the low or high score examples, and measuring the rate at which it evolves in a scale-invariant way. We find that the NTK submatrix for the high score examples evolves faster throughout training, supporting our hypothesis that high-scoring examples are the ones driving the learning and the changes in the NTK feature space [9]. ",
+        "bbox": [
+            192,
+            165,
+            825,
+            248
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Which samples are important for learning? ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            267,
+            566,
+            284
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            297,
+            308,
+            313
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider supervised classification, where ${ \\cal { S } } = \\{ ( x _ { i } , y _ { i } ) \\} _ { i = 1 } ^ { N }$ denotes the training set, drawn i.i.d. from an unknown data distribution $\\mathcal { D }$ , with input vectors $x \\in \\mathbb { R } ^ { d }$ and one-hot vectors $y \\in \\{ 0 , 1 \\} ^ { K }$ encoding labels. For a fixed neural network architecture, let $f _ { \\mathbf { w } } ( x ) \\in \\mathbb { R } ^ { K }$ be the logit outputs of the neural network with weights w $\\in \\mathcal { W } \\subseteq \\mathbb { R } ^ { D }$ on input $\\boldsymbol { x } ~ \\in ~ \\mathbb { R } ^ { d }$ . Let $\\sigma$ be the softmax function given by $\\begin{array} { r } { \\sigma ( z _ { 1 } , . . . , z _ { K } ) _ { k } = \\exp \\{ z _ { k } \\} / \\sum _ { k ^ { \\prime } = 1 } ^ { K } \\exp \\{ z _ { k ^ { \\prime } } \\} } \\end{array}$ . Let $p ( \\mathbf { w } , x ) = \\sigma ( f ( \\mathbf { w } , x ) )$ denote the neural network output in the form of a probability vector. For any probability vector $\\begin{array} { r } { \\ell ( \\hat { p } , y ) = \\sum _ { k = 1 } ^ { K } y ^ { ( k ) } \\log \\hat { p } ^ { ( k ) } } \\end{array}$ denote cross-entropy loss. $\\hat { p }$ , let ",
+        "bbox": [
+            173,
+            320,
+            825,
+            429
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathbf { w } _ { 0 } , \\mathbf { w } _ { 1 } , \\mathbf { w } _ { 2 } , \\ldots , \\mathbf { w } _ { T }$ be the iterates of stochastic gradient descent (SGD), where, for some sequence of minibatches $S _ { 0 } , S _ { 1 } , \\ldots , S _ { T - 1 } \\subseteq S$ of size $M$ , we have ",
+        "bbox": [
+            173,
+            434,
+            820,
+            463
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/61c6de147ea417a283c3b4c36fee7166fb3e317f9834ef7909961584b1d90798.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { w } _ { t } = \\mathbf { w } _ { t - 1 } - \\eta \\sum _ { ( x , y ) \\in S _ { t - 1 } } g _ { t - 1 } ( x , y ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            467,
+            633,
+            487
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "for $g _ { t - 1 } ( x , y ) = \\nabla _ { \\mathbf { w } _ { t - 1 } } \\ell ( p ( \\mathbf { w } _ { t - 1 } , x ) , y )$ , and $t = 1 , \\dots , T$ . ",
+        "bbox": [
+            173,
+            491,
+            566,
+            507
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Gradient Norm Score and an infinitesimal analysis ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            521,
+            566,
+            536
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Fix a training set $S$ . Due to training with SGD from a random initialization, the weight vector at time $t > 0$ , $\\mathbf { w } _ { t }$ , is a random variable. The expected magnitude of the loss vector is our primary focus: ",
+        "bbox": [
+            173,
+            546,
+            826,
+            588
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 2.1. The GraNd score of a training example $( x , y )$ at time $t$ is $\\chi _ { t } ( x , y ) = \\mathbb { E } _ { \\mathbf { w } _ { t } } \\left\\| g _ { t } ( x , y ) \\right\\| _ { 2 }$ ",
+        "bbox": [
+            171,
+            592,
+            838,
+            608
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here we describe conditions under which the GraNd score controls the contribution of a training example to the change in the training loss. In order to simplify our analysis, we approximate the training dynamics as if they were in continuous time. ",
+        "bbox": [
+            173,
+            616,
+            826,
+            660
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A key quantity in our analysis is the time derivative of the loss for a generic labeled example $( x , y )$ : $\\begin{array} { r } { \\Delta _ { t } ( ( x , y ) , S _ { t } ) = - \\frac { \\mathrm { d } \\ell ( f _ { t } ( x ) , y ) } { \\mathrm { d } t } } \\end{array}$ (where $f _ { t } ( \\cdot ) = f _ { \\mathbf { w } _ { t } } ( \\cdot ) )$ , i.e., the instantaneous rate of change in the loss on $( x , y )$ at time $t$ , where the gradient is computed on the minibatch $S _ { t }$ . By the chain rule, ",
+        "bbox": [
+            174,
+            665,
+            825,
+            712
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0c1a1ab294e556aabfc364990fd04eabeb9f797c8e54fac2a22c7c283f2af12c.jpg",
+        "text": "$$\n\\begin{array} { r } { \\Delta _ { t } ( ( x , y ) , S _ { t } ) = g _ { t } ( x , y ) \\frac { \\mathrm { d } { \\mathbf w } _ { t } } { \\mathrm { d } t } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            715,
+            598,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This relates to our discrete time dynamics via $\\begin{array} { r } { \\frac { \\mathrm { d } \\mathbf { w } _ { t } } { \\mathrm { d } t } \\approx \\mathbf { w } _ { t + 1 } - \\mathbf { w } _ { t } = - \\eta \\sum _ { ( x ^ { \\prime } , y ^ { \\prime } ) \\in S _ { t } } g _ { t } ( x ^ { \\prime } , y ^ { \\prime } ) } \\end{array}$ ",
+        "bbox": [
+            174,
+            739,
+            790,
+            760
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to understand how removing a training point from minibatch $S _ { t }$ affects $\\Delta _ { t } ( ( x ^ { * } , y ^ { * } ) , S _ { t } )$ for any $( x ^ { * } , y ^ { * } )$ . If a training point $( x , y )$ is not in the minibatch $S _ { t }$ , then the effect is trivial. We thus study $\\Delta _ { t } ( ( x ^ { * } , y ^ { * } ) , S )$ in order to be able to rank all the training examples. ",
+        "bbox": [
+            174,
+            765,
+            826,
+            808
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Lemma 2.2. Let $S _ { \\neg j } = S \\setminus ( x _ { j } , y _ { j } )$ . Then for all $( x ^ { * } , y ^ { * } )$ , there exists c such that ",
+        "bbox": [
+            174,
+            809,
+            715,
+            825
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ff5715e1708b63db7a7a27218cc446bed99505c577858620bb0b455cf142d2a6.jpg",
+        "text": "$$\n\\begin{array} { r } { \\| \\Delta _ { t } ( ( x ^ { * } , y ^ { * } ) , S ) - \\Delta _ { t } ( ( x ^ { * } , y ^ { * } ) , S _ { - j } ) \\| \\leq c \\| g _ { t } ( x _ { j } , y _ { j } ) \\| . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            829,
+            686,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Proof. For a given example $( x ^ { * } , y ^ { * } )$ , the chain rule yields $\\begin{array} { r l } { \\Delta _ { t } ( ( x ^ { * } , y ^ { * } ) , S ) } & { { } = } \\end{array}$ $\\begin{array} { r l r } { - \\frac { \\mathrm { d } \\ell \\left( f _ { t } ( x ^ { * } ) , y ^ { * } \\right) } { \\mathrm { d } t } } & { { } = } & { \\frac { \\mathrm { d } \\ell ( f _ { t } ( x ^ { * } ) , \\bar { y } ^ { * } ) } { \\mathrm { d } \\mathbf { w } _ { t } } \\frac { \\mathrm { d } \\mathbf { w } _ { t } } { \\mathrm { d } t } } \\end{array}$ d\\`(ft(x⇤),y⇤) dwt nce the weights ar GD, we have . Sitting e updated using S, the result follows. $\\begin{array} { r } { \\frac { \\mathrm { d } \\mathbf { w } _ { t } } { \\mathrm { d } t } = - \\eta \\sum _ { ( x _ { j } , y _ { j } ) \\in S _ { t } } g _ { t } ( x _ { j } , y _ { j } ) } \\end{array}$ $\\begin{array} { r } { c = \\eta \\Vert \\frac { \\mathrm { d } \\ell ( f _ { t } ( x ^ { * } ) , y ^ { * } ) } { \\mathrm { d } \\mathbf { w } _ { t } } \\Vert } \\end{array}$ □ ",
+        "bbox": [
+            174,
+            859,
+            825,
+            915
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "At any given training step, given the current location $\\mathbf { w } _ { t }$ , the contribution of a training example $( x , y ) ^ { \\bar { 2 } }$ to the decrease of loss on any other example, is bounded by Eq. (3). Since the constant $c$ does not depend on the training example $( x , y ) ^ { 3 }$ , we only consider the gradient norm term, $\\| g _ { t } ( x , y ) \\|$ . The expected value of this gradient norm is exactly the GraNd score of $( x , y )$ . In other words, examples with a small GraNd score in expectation have a bounded influence on learning how to classify the rest of the training data at a given training time4. We therefore propose to rank training examples by their GraNd scores, larger norm meaning more important for preserving $\\Delta _ { t } ( x )$ . ",
+        "bbox": [
+            173,
+            90,
+            825,
+            189
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For an arbitrary input $x \\in \\mathbb { R } ^ { d }$ , let $\\psi _ { t } ^ { ( k ) } ( x ) = \\nabla _ { \\mathbf { w } _ { t } } f _ { t } ^ { ( k ) } ( x )$ denote the $k$ th logit gradient. Then GraNd can be written as5 ",
+        "bbox": [
+            174,
+            194,
+            823,
+            226
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bee89d444feb4659f388e7e36d24cfce536832002813b5710350ebc45de35394.jpg",
+        "text": "$$\n\\begin{array} { r } { \\chi _ { t } ( x , y ) = \\mathbb { E } \\left. \\sum _ { k = 1 } ^ { K } \\nabla _ { f ^ { ( k ) } } \\ell ( f _ { t } ( x ) , y ) ^ { T } \\psi _ { t } ^ { ( k ) } ( x ) \\right. _ { 2 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            224,
+            669,
+            253
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Under the cross entropy loss, $\\nabla _ { f ^ { ( k ) } } \\ell ( f _ { t } ( x ) , y ) ^ { T } = p ( \\mathbf { w } _ { t } , x ) ^ { ( k ) } - y _ { k }$ . When $\\{ \\psi _ { t } ^ { ( k ) } ( x ) \\} _ { k }$ are roughly orthogonal across logits, and are of a similar size across logits and training examples $x$ , then we can approximate GraNd by just the norm of the error vector. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            301
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 2.3. The EL2N score of a training sample $( x , y )$ is defined to be $\\mathbb { E } \\| p ( \\mathbf { w } _ { t } , x ) - y \\| _ { 2 }$ . ",
+        "bbox": [
+            174,
+            303,
+            797,
+            319
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our experimental results suggest that this approximation becomes accurate after a few epochs of training (see Section 3). These approximations are also in agreement with the empirical results reported in [9, 10]. Fort and Ganguli [10, Sec. 5.1] demonstrate that the mean logit gradients are nearly orthogonal among classes throughout training. The authors demonstrate that per-example gradients cluster around the mean logit gradient. Fort et al. [9, Figs. 12D-14D] provide evidence that the mean logit gradient directions evolve rapidly early in training and then stabilize (as measured by the cosine distance between mean logit gradient vectors at different times in training). ",
+        "bbox": [
+            173,
+            327,
+            825,
+            425
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 Comparison to forgetting scores ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            440,
+            434,
+            455
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Toneva et al. [8] define a “forgetting event” for a training sample to be a point in training when the classifier switches from making a correct classification decision to an incorrect one. They define an approximate forgetting score for each training example as the number of times during training when it was included in a minibatch and underwent a forgetting event. Toneva et al. demonstrate that examples with low forgetting score may be completely omitted during training without any noticeable effect on the accuracy of the learned predictor. In Fig. 1 and Appendix E.5, we make an empirical comparison of forgetting scores to our proposed GraNd and EL2N scores. ",
+        "bbox": [
+            174,
+            464,
+            825,
+            563
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Lemma 2.2, we bounded the contribution of a training example to the decrease of the loss of any other sample over a single gradient step. Due to $\\psi _ { t } ( \\cdot )$ ’s being time-dependent, it is complicated to extend the analysis to multiple steps. However, it is interesting to consider a case when $\\psi _ { t } ( x _ { i } ) =$ $\\psi ( x _ { i } )$ for all $x _ { i }$ in the training set, and $K = 1$ . Then summing the bound in Eq. (3) on how much a sample $( x _ { j } , y _ { j } )$ affects the logit output on an arbitrary point at each time $t \\in \\{ 1 , . . , T \\}$ , we obtain a score that depends on $\\| \\psi ( x _ { j } ) \\| | \\sum _ { t } ( p _ { t } ( x _ { j } ) - y _ { j } ) |$ . For two examples, $( x , y )$ and $( x ^ { \\prime } , y ^ { \\prime } )$ , such that $\\| \\psi ( x ^ { \\prime } ) \\| \\approx \\| \\psi ( x ) \\|$ , we see that the example that is learned faster and maintains small error over training time will have a smaller GraNd score on average throughout training. Note that $| ( p _ { t } ( x _ { j } ) - y _ { j } ) |$ , if rescaled, is an upper bound on 0–1 loss, and therefore $\\begin{array} { r } { \\sum _ { t } | ( p _ { t } ( x _ { j } ) - y _ { j } ) | } \\end{array}$ upper bounds the number of forgetting events during training (after rescaling). In this simplified setting an example with a high number of forgetting events will also have a high GraNd score. ",
+        "bbox": [
+            173,
+            568,
+            825,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Empirical Evaluation of GraNd and EL2N Scores via Data Pruning ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            738,
+            767,
+            757
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the previous section, we motivated GraNd and EL2N scores by quantifying the influence of a training example on the loss of an arbitrary example after one optimization step. In this section, we evaluate these scores empirically, and verify that they identify examples important for generalization. Networks trained on subsets of the data with high scores achieve levels of test accuracy comparable to training on the full dataset and are competitive with other state of the art data pruning methods. Perhaps most remarkably, these scores are effective even when computed early in training and perform significantly better than a random baseline, even at initialization. ",
+        "bbox": [
+            176,
+            768,
+            823,
+            797
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/de5af3c5a609fd0da97bc2ce8dd9af85b689ca65e8e7bf483be222f7cfa2b8da.jpg",
+        "image_caption": [
+            "Figure 1: Columns correspond to three different dataset and network combinations (labeled at the top). Each legend applies to all 3 figures in its row. First row: Final test accuracy achieved by training on a subset of training data comprised of examples with maximum forgetting, EL2N and GraNd scores computed at different times early in training. Subsets of a fixed size are used: networks are trained on $50 \\%$ of training data for CIFAR-10, $60 \\%$ for CINIC-10 and $7 5 \\%$ for CIFAR-100. Second row: Final test accuracy achieved by training after different fractions of the dataset are pruned. Here we compare forgetting scores at the end of training, EL2N scores early in training (at epoch 20) and GraNd scores at initialization. In each case, examples with the lowest scores are pruned at initialization. In all experiments accuracies achieved by training on the full dataset and on a random subset of the corresponding size are used as baselines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            89,
+            820,
+            339
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            517,
+            823,
+            587
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Data pruning experiments. We train convolutional neural networks of varying depth–ResNet18 and ResNet50 [11]–on standard vision datasets of varying difficulty–CIFAR-10, CIFAR-100 [12], and CINIC-10 [13]. All scores are calculated by averaging the scores from ten independent training runs. After calculating scores and selecting a training subset, final test accuracies are obtained by retraining networks from new random initializations on only the selected subset. Networks used for evaluating the scores are initialized with seeds that are different from those used to calculate the scores. For each experiment, we report the mean of four independent runs and represent variability across runs by shading the region which spans the 16th to 84th percentile of obtained accuracies. See Appendix B for more implementation details and Appendix E for additional experiments. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            718
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 1, we show the results of two sets of experiments (top and bottom) on three different network and dataset combinations. The first experiment asks, how early in training are forgetting, GraNd and EL2N scores effective at identifying examples important for generalization? We compare the final test accuracy from training on subsets of fixed size but pruned based on scores computed at different times early in training. The second experiment compares how GraNd scores at initialization, EL2N scores early in training and forgetting scores at the end of training negotiate the trade-off between generalization performance and training set size. The training sets are constructed by pruning different fractions of the lowest score examples. In all examples, training on the full dataset and a random subset of the corresponding size are used as baselines. We make the following observations. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            849
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Pruning at initialization. In all settings, GraNd scores can be used to select a training subset at initialization that achieves test accuracy significantly better than random, and in some cases, competitive with training on all the data. This is remarkable because GraNd only contains information about the gradient norm at initializion, averaged over initializations. This suggests that the geometry of the training distribution induced by a random network contains a surprising amount of information about the structure of the classification problem. EL2N scores, which only contain information about errors, are not consistently effective at initialization and forgetting scores, which require counting forgetting events over training, are not defined at initialization. ",
+        "bbox": [
+            176,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            147
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Pruning early in training. We find that, after only a few epochs of training, EL2N scores are extremely effective at identifying important examples for generalization. For a wide range of intermediate pruning levels, training on the highest scores performs on par with or better than training on the full dataset. Even at higher pruning levels, EL2N scores computed using local information early in training are competitive with forgetting scores which integrate information over the training trajectory. This suggests that the average error vector a few epochs into training can identify examples that the network heavily uses to shape the decision boundary throughout training. ",
+        "bbox": [
+            173,
+            154,
+            825,
+            251
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, at extreme levels of pruning with either EL2N or GraNd scores, we observe a sharp drop in performance. We hypothesize that this is because at high levels of pruning, using either GraNd or EL2N scores leads to bad coverage of the data distribution. By only focusing on the highest error examples, it is likely that an entire subpopulation of significant size that is present in the test data is now excluded from the training set. We only fit a small number of very difficult examples and do not keep enough of a variety of examples for training models with good test error. ",
+        "bbox": [
+            174,
+            256,
+            825,
+            340
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A property of the data. Our results suggest that the ranking of important examples induced by EL2N scores is a property of the dataset and not specific to a network. First, in Appendix E.2, we show that a ResNet18 and a ResNet50 trained on CIFAR-10 have similar performance curves and the same amount of data can be pruned, even though ResNet50 is a much deeper network with more parameters. Second, EL2N scores calculated on one set of network architecture and hyperparameter configurations can be used to prune data for training with a different network architecture or hyperparameter configuration. The set of important examples generalizes across architectures and hyperparameters. See Appendix E.3 for the experiment on generalization across architectures and Appendix E.4 for the experiment on using scores calculated during hyperparameter optimization. Additionally, in an analysis of the sensitivity of the scoring methods to hyperparameters in Appendix E.1, we observe that scores calculated on a single network do not perform as well as those averaged across networks. ",
+        "bbox": [
+            174,
+            345,
+            825,
+            512
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We hypothesize that averaging the gradient or error norms over multiple initializations or training trajectories removes dependence on specific weights, allowing a more accurate distillation of the properties of the dataset. EL2N scores can thus be used to probe and understand how the distribution of the training data impacts dynamics (as we show in the next sections). Additionally, it can also reduce the computational burden of training neural networks; once we compute the scores, future networks can be trained on the pruned dataset. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            602
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the following experiments, we focus on EL2N scores computed early in training, as they appear to more accurately identify important examples. ",
+        "bbox": [
+            174,
+            608,
+            820,
+            636
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Identifying noise examples ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            645,
+            428,
+            661
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the previous section, we studied the effect of keeping the highest-scoring examples, and found that we could train on only the top $50 \\%$ of examples by score without a drop in accuracy (CIFAR-10). What is the nature of subpopulations of examples that allow us to reach high accuracy? One hypothesis is that the highest-scoring examples are the most important ones for achieving an accurate classifier. In this section, we refute this hypothesis, and demonstrate the role of label noise. ",
+        "bbox": [
+            173,
+            678,
+            380,
+            910
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/f03b77e3d671d9eb8d8b4b2f965c6b1156f6ac57c90d2f23891b55a6551c8a9a.jpg",
+        "image_caption": [
+            "Figure 2: ResNet18 trained on a $40 \\%$ subset of CIFAR-10 with clean (left) and $10 \\%$ randomized labels (right). The training subset contains the lowest scoring examples after examples with scores below the offset are discarded. Scores computed at epoch 10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            398,
+            694,
+            820,
+            819
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To test whether the highest-scoring examples are most important for achieving high accuracy, we first sort the examples by increasing EL2N score computed after a small number of training epochs.6 Then we perform a sliding window analysis by training on a subset of examples with scores within a window from percentile $f$ to percentile $f + P$ percentile, always keep $P \\%$ of the data but sliding up $f$ . As this window slides to higher percentiles, performance increases, except when the window includes examples with the very highest scores Fig. 2 (left). Indeed the the optimal sliding window actually excludes approximately 500 of the highest-scoring training examples. These effects are reduced in the low pruning regime (see Appendix F.1). In Appendix C, we visualize some of the images that are excluded from each class. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            215
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Before we analyze these results, we first place them into a wider context, where we also change the amount of noise in the underlying label distribution. We repeat the experiment outlined above, but corrupt a random $K \\%$ of labels, replacing them with a random label, mirroring the protocol popularized by Zhang et al. [14]. Fig. 2 reveals that with increased label corruption, the optimal window shifts and excludes a higher number of examples. Therefore, the effect we see in the noiseless case appears to be magnified in the presence of label noise. Appendix F.2 examines how adding label noise influences the distribution of EL2N scores of examples. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            319
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "These findings have several implications. The most obvious implication is that training with only the highest-scoring samples may not be optimal, especially when there is label noise. When the population has a low Bayes error rate, using only the highest scoring samples yields optimal results. However, without a validation set, one should be cautious in excluding high-score examples. Feldman [15] discusses memorization in a noisy-label setup and gives conditions under which one should memorize in order to not misclassify singleton examples ( examples in the training data that are the sole representatives of a subpopulation). For example, if the subpopulation appears with a frequency $\\Omega ( 1 \\bar { / } N )$ , memorizing such examples can improve generalization. In practice, we may not know whether our data fits these conditions. However, our analysis in Fig. 2 suggests a simple and powerful method to prune data for optimal performance by optimizing just two hyperparameters of a sliding window using a validation set. ",
+        "bbox": [
+            174,
+            325,
+            825,
+            478
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Optimization landscape and the training dynamics ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            500,
+            627,
+            517
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Evolution of the data-dependent NTK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            532,
+            475,
+            547
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The dynamics of neural-network training in the infinite-width limit are now well understood [16, 17]: for an appropriate scaling of the learning rate and initial weights, the neural network behaves like a linear model in which the data is transformed by the Neural Tangent Kernel (NTK) at initialization, which is defined as the product of the Jacobians of the logits at initialization. In the limit, neural network training implements kernel regression with the fixed NTK as the kernel. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            630
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "However, finite neural networks outperform their infinitewidth limits [18] and have different dynamics early in training [19]. In fact, rather than being constant, the datadependent NTK, defined by Fort et al. [9] as the Gram matrix of the logit Jacobian, evolves with high velocity in the initial phase of training. Then, around the time of onset of linear mode connectivity, the NTK velocity stabilizes at a smaller value and remains nearly constant for the rest of the high learning rate training time. ",
+        "bbox": [
+            174,
+            636,
+            380,
+            883
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/be06056521925d5e757e883f793e4b50e8e147bb05901f045efac7f85afdc315.jpg",
+        "image_caption": [
+            "Figure 3: Kernel velocity for different subsets of images when ResNet18 is trained on CIFAR-10 with all true labels (left) and $10 \\%$ label noise (right). Examples are sorted in ascending order by EL2N scores and each point corresponds to the kernel velocity of 100 contiguous images starting at example index. Both scores and velocities are computed at the same epoch indicated by color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            398,
+            654,
+            818,
+            779
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here we seek to understand which training samples contribute to the NTK gram matrix evolution. To empirically approximate the velocity of a NTK submatrix corresponding to a subset of images in a scale invariant way, we follow [9]. We compute the cosine distance between two NTK gram matrices on the given subset, one computed at epoch $t$ , and another one at epoch $t { + } 1$ , one epoch later (see Appendix B.3). We look at submatrices of a fixed size, formed by examples with contiguous EL2N scores. Fig. 3 shows that higher EL2N scores lead to higher velocities. This relationship is not affected by the time at which both are computed. ",
+        "bbox": [
+            173,
+            92,
+            825,
+            189
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, the kernel velocity drops off sharply for examples with the very highest scores when label noise is introduced. In Section 4, we showed that dropping these examples boosts the accuracy of the final predictor. We hypothesize that, while the kernel velocity is higher for harder examples that the model is actively trying to fit, the kernel velocity drops off for the very highest scoring examples that might be too difficult to learn, perhaps because they are unrepresentative samples or they have have label noise. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            277
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 Connections to the Linear Mode Connectivity ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            294,
+            529,
+            309
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We now examine how the ranking of the examples by EL2N connects to the geometry of the loss surface. In particular, Frankle et al. [20] studied the effect of minibatch randomness on the training trajectory, focusing on identifying the point in training when two networks, starting from the same weights, but trained with independent minibatches, converge to the same “linearly connected” mode. They find that, for standard vision datasets, the onset of this “linear mode connectivity” (LMC) happens early in training. ",
+        "bbox": [
+            173,
+            319,
+            825,
+            404
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "More precisely, let $w _ { 1 } , w _ { 2 } , \\dots , w _ { T }$ be the training trajectory of a parent network, fix a spawning time $t ^ { * }$ , and let $v _ { t ^ { * } }$ , $v _ { t ^ { * } + 1 }$ , $v _ { t ^ { * } + 2 } , \\ldots , v _ { T }$ be an independent training trajectory (i.e., with independent minibatches), beginning at $v _ { t ^ { * } } = w _ { t ^ { * } }$ . We call $v _ { T }$ the child network and $v _ { t ^ { * } } , v _ { t ^ { * } + 1 } , \\ldots .$ the child trajectory. The (training) error barrier between two weights $w$ and $w ^ { \\prime }$ , denoted $\\mathrm { e r r } ( w , w ^ { \\prime } ; S )$ , is the maximum deviation of the training error surface ${ \\hat { R } } _ { S } ( \\cdot )$ above the line connecting the empirical risk at $w$ and $w ^ { \\prime }$ . That is, ",
+        "bbox": [
+            174,
+            409,
+            825,
+            496
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5cd9ffafea9445fb64ef7fca03f5bfa25b572421ac854513475196f0d325a330.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathrm { e r r } ( w , w ^ { \\prime } ; S ) = \\operatorname* { s u p } _ { \\alpha \\in [ 0 , 1 ] } \\left\\{ \\hat { R } _ { S } ( \\alpha w + ( 1 - \\alpha ) w ^ { \\prime } ) - \\alpha \\hat { R } _ { S } ( w ) - ( 1 - \\alpha ) \\hat { R } _ { S } ( w ^ { \\prime } ) \\right\\} . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            217,
+            498,
+            779,
+            520
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We then define the mean (training) error barrier, spawning at $t ^ { * }$ , at time $t$ , for $t ^ { * } \\leq t \\leq T$ , denoted $\\mathrm { e r r } _ { t } ^ { t ^ { * } } ( S )$ , to be the expected error barrier between $w _ { t }$ and $v _ { t }$ on the data $S$ . That is, ",
+        "bbox": [
+            173,
+            525,
+            823,
+            555
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/87f17fccea0f705c5a68bb0344f533a4d9a0ee4da874f8ce6ce2d9252afec63e.jpg",
+        "text": "$$\n\\mathrm { e r r } _ { t } ^ { t ^ { * } } ( S ) = \\mathbb { E } _ { w _ { t ^ { * } + 1 : t } , v _ { t ^ { * } + 1 , t } } [ \\mathrm { e r r } ( w _ { t } , v _ { t } ; S ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            561,
+            640,
+            583
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where the expectation is taken over the randomness in the trajectories of $w$ and $v$ after $t ^ { * }$ due to the choice of minibatches, conditional on the initial trajectories up through time $t ^ { * }$ . (Note that, at the end of training $t = T$ , the supremum in $\\mathrm { e r r } ( w _ { T } , v _ { T } ; S )$ is often achieved near $\\alpha = 1 / 2$ , and so this is a cheap approximation used in practice.) The “onset” of linear mode connectivity is the earliest spawning time $t ^ { * }$ at which point $\\mathrm { e r r } _ { T } ^ { t ^ { * } } ( S ) \\approx 0$ , where $S$ is the whole training set. In our work, we instead compute the error barrier on subsets of the training set, which allows us to compare the training dynamics and modes on subpopulations. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            685
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 4, we measure the mean error barrier $\\mathrm { e r r } _ { t } ^ { t ^ { * } } ( S ^ { \\prime } )$ as a function of the spawning time $t ^ { * }$ , in the cases where $S ^ { \\prime }$ are either 1) the training examples with the smallest scores, 2) the largest scores, or 3) a random subset of training examples. We find that the error barrier falls close to zero very rapidly for examples that have low EL2N scores, and stays high for high score examples. These findings suggest that the loss landscape derived from restricted subsets of examples with low and high EL2N behave very differently. The loss landscape derived from easy subsets of examples with low scores is quite flat, in the sense that error barriers between children as a function of spawn time rapidly diminish. On the other hand, the loss landscape derived from harder subsets of examples with higher scores is rougher, with higher error barriers that persist for longer in the spawn time. Further, this result is in agreement with the results presented in Section 5.1, showing that most of the learning happens in the high EL2N score examples. ",
+        "bbox": [
+            173,
+            691,
+            825,
+            845
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            864,
+            323,
+            881
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As discussed earlier, our work is closely related to an empirical study by Toneva et al. [8], which examines the frequency with which correct classification decisions are forgotten during training. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/774d18f9da13c888136150d8efa81dd83fcc166153e431f3b2c92f0cb3ec0bf4.jpg",
+        "image_caption": [
+            "Figure 4: The final training error barrier between children on subsets of a 1000 highest (green) and lowest (orange) EL2N score examples, and randomly selected training subset (blue) as a function of the spawning time. Left to right: different dataset and network combinations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            90,
+            820,
+            217
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The authors observe that examples that are rarely forgotten are also ones that do not contribute much to the final accuracy of the predictor. In particular, if we retrain from initialization after having removed rarely forgotten examples from the training data, we achieve the same accuracy. Similar to our work, this work analyzes the dynamics of training in deep learning through the lens of training examples. However, unlike forgetting scores, our proposed methods use only local information early in training. This highlights two properties: example importance is reflected in the local properties of the loss landscape after a few epochs and the ordering of examples by importance is roughly preserved throughout training. We think that this is a key contribution and hope it prompts future empirical and theoretical work exploring the early stage of learning. ",
+        "bbox": [
+            174,
+            296,
+            825,
+            422
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Coleman et al. [1] use a small proxy network in combination with other training data selection methods to find a small subset of important-for-training examples, that can then be used to train a large state-of-the-art (SOTA) deep neural network. In their empirical study, they observe that most important examples selected via a proxy model are also important for training a SOTA network. In addition, they study a proxy which reuses SOTA network’s architecture but is trained for a shorter time. The authors observe that selecting the important examples after at least 50 epochs of training works better than selecting them at random, but not as well as after the full training run. They do not study shorter training times for proxies or relate it to the training dynamics in any other way. ",
+        "bbox": [
+            174,
+            428,
+            825,
+            540
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Another line of related work is on coresets (see, e.g., [4, 5, 7, 21–23], and many others). The term coresets generally refers to a possibly weighted subset of training data. Much of the work on coresets is focused on identifying small training data subsets that provably yield an $\\epsilon$ -approximate solution to the original objective (on all the training data). Most guarantees require the problem to have special structure, such as convexity. For nonconvex problems, like training deep neural networks, guarantees are provided for very conservative proxies, e.g., based on Lipschitz constants or smoothness. While coreset selection comes with nice theoretical guarantees, in our opinion, the utility of these methods is best considered an empirical question. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            656
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Coresets have also been studied in the active learning community. Here, the goal is to select a small set of examples to label at any given iteration of training (see, e.g., [24–28], and references therein). Coreset selection has also been proposed as a way to increase model robustness [29]. ",
+        "bbox": [
+            176,
+            662,
+            825,
+            704
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pleiss et al. use a similar method, the Area Under the Margin (AUM) statistic, but with a slightly different goal: identifying noisy and mislabeled examples. Their proposed method exploits differences in the training dynamics of clean and mislabeled samples by keeping track of statistics through the course of training. The AUM statistic is similar to forgetting scores in that it uses information from the whole training run. In contrast, we focus on instantaneous information in the early phase of training. In addition to identifying noisy examples, we aim to rank points by importance and therefore also identify redundant/easy examples. Thus our approach is complimentary to the AUM statistic and can be used together to obtain higher levels of pruning on noisy datasets. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "There have been a number of recent studies looking at the problem of estimating example difficulty. One such approach for identifying difficult examples within a given class is the Variance of Gradients (VoG) score proposed by Agarwal, D’souza, and Hooker [31]. For each image, they calculate the gradient of the activations with respect to the pixels at $K$ different checkpoints over training. The VoG score is the average (over pixels) of the per-pixel variance across these $K$ checkpoints. The authors conclude that the images that appear more difficult also have a higher VoG score. Understanding the connections between these two scores calculated in entirely different spaces is an interesting direction for future work. ",
+        "bbox": [
+            174,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Another quite different approach estimates example difficulty using prediction depth [32], which is defined as the first layer at which a $\\mathbf { k }$ -Nearest Neighbor classifier can correctly classify an example using the representation of the image in all subsequent layers. In additional to methodological differences, this method uses the final trained network. To our knowledge, we are the first to highlight the existence of a strong signal for estimating example difficulty early in training. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            195
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Informally, removing a training example from the training data and not hurting the generalization error suggests that the example has small “influence” on the test data. Influence of the training examples on test examples is studied in sample-based explainability [33–35]. On the theory side, Feldman [15] recently proposed to model data as a mixture of populations and study the role of memorization when the data distribution is long-tailed. Feldman demonstrates conditions under which memorization is necessary for good generalization. In doing so, he proposes a definition of example memorization and influence, which can be interpreted as a leave-one-out notion of stability. In an empirical study following this work, Feldman and Zhang [36] demonstrate that classifiers trained on computer vision benchmarks benefit from memorization. In particular, training without high-memorization-value examples comes at a cost of accuracy of the learned neural network classifier. In Appendix G, we compare GraNd, EL2N, forgetting scores, and memorization values on CIFAR-100-trained Resnet50 networks; memorization values do not correlate with the other scores. ",
+        "bbox": [
+            174,
+            202,
+            825,
+            367
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            387,
+            294,
+            402
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In summary, our work both (1) introduces methods to significantly prune data without sacrificing test accuracy using only local information very early in training (Fig. 1), sometimes even at initialization, and (2) uses the resulting methods to obtain new scientific insights into how different subsets of training examples drive the dynamics of deep learning. We start from a principled approach by asking how much on average each training example influences the loss reduction of other examples, and from that starting point, we obtain 2 scores, namely gradient norm (GraNd) and error norm (EL2N) that bound or approximate this influence, with higher scores indicating higher potential influence. We find that examples with higher scores tend to be harder to learn, in the sense that they are forgotten more often over the entire course of training. We also find that the very highest scoring examples tend to be either unrepresentative outliers of a class, have non standard backgrounds or odd angles, are subject to label noise, or are otherwise difficult. This observation yields a simple and powerful sliding window method (Fig. 2) to prune data by keeping examples within a range of scores, where the start and the end of the range constitute just 2 hyperparmeters that can be tuned via a validation set. This tuning can be done using different hyperparameter settings or on a different network saving computation time (Appendix E.3). Furthermore, we find that high-scoring examples primarily drive feature learning by maximally supporting the velocity of the NTK, whereas learning dynamics might actually give up on the very highest scoring examples that may correspond to unrepresentative examples or noise (Fig. 3). Finally we show that higher (lower) scoring subsets of examples contribute to a rougher (smoother) loss landscape (Fig. 4). Overall this decomposition of both loss landscape geometry and learning dynamics into differential contributions from different types of examples constitutes an exciting new methodology for analyzing deep learning. A deeper understanding of the differential role played by different subsets of examples could aid not only in data pruning, but also in curriculum design, active learning, federated learning with privacy, and analysis of fairness and bias. Our empirical findings raise a number of interesting theoretical questions, some of which we discuss in Appendix D. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            751
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            770,
+            338,
+            786
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors would like to thank Blair Bilodeau, Alex Drouin, Étienne Marcotte, and Daniel M. Roy for feedback on drafts, the Toolkit team at ServiceNow for providing the tools and computation resources that greatly accelerated our empirical work, and the NeurIPS reviewers for their thorough engagement and invaluable feedback on label-dependence and practical applications. S.G. thanks the Simons Foundation, NTT Research and an NSF Career award for funding while at Stanford. ",
+        "bbox": [
+            174,
+            803,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            266,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zaharia. Selection via proxy: Efficient data selection for deep learning. 2019. arXiv: 1906. 11829.   \n[2] M. Hwang, Y. Jeong, and W. Sung. “Data distribution search to select core-set for machine learning”. In: Proc. 9th Int. Conf. Smart Media & Appl. (SMA 2020), Jeju, Korea. 2020, pp. 17–19.   \n[3] S. Har-Peled and A. Kushal. “Smaller coresets for $\\mathbf { k }$ -median and $\\mathbf { k }$ -means clustering”. Discrete & Computational Geometry 37.1 (2007), pp. 3–19.   \n[4] J. H. Huggins, T. Campbell, and T. Broderick. “Coresets for scalable bayesian logistic regression” (2016). arXiv: 1605.06423.   \n[5] T. Campbell and T. Broderick. “Bayesian coreset construction via greedy iterative geodesic ascent”. In: Int. Conf. Machine Learning. PMLR. 2018, pp. 698–706.   \n[6] I. W. Tsang, J. T. Kwok, P.-M. Cheung, and N. Cristianini. “Core vector machines: Fast SVM training on very large data sets.” Journal of Machine Learning Research 6.4 (2005).   \n[7] A. Munteanu, C. Schwiegelshohn, C. Sohler, and D. P. Woodruff. On coresets for logistic regression. 2018. arXiv: 1805.08571.   \n[8] M. Toneva, A. Sordoni, R. T. d. Combes, A. Trischler, Y. Bengio, and G. J. Gordon. An empirical study of example forgetting during deep neural network learning. 2018. arXiv: 1812.05159.   \n[9] S. Fort, G. K. Dziugaite, M. Paul, S. Kharaghani, D. M. Roy, and S. Ganguli. “Deep learning versus kernel learning: an empirical study of loss landscape geometry and the time evolution of the Neural Tangent Kernel”. In: Advances in Neural Information Processing Systems. 2020. arXiv: 2010.15110.   \n[10] S. Fort and S. Ganguli. “Emergent properties of the local geometry of neural loss landscapes”. arXiv preprint arXiv:1910.05929 (2019).   \n[11] K. He, X. Zhang, S. Ren, and J. Sun. “Deep residual learning for image recognition”. In: Proceedings of the IEEE conference on computer vision and pattern recognition. 2016, pp. 770– 778.   \n[12] A. Krizhevsky, V. Nair, and G. Hinton. “Learning multiple layers of features from tiny images” (2009).   \n[13] L. N. Darlow, E. J. Crowley, A. Antoniou, and A. J. Storkey. “CINIC-10 is not ImageNet or CIFAR-10”. CoRR abs/1810.03505 (2018). arXiv: 1810.03505.   \n[14] C. Zhang, S. Bengio, M. Hardt, B. Recht, and O. Vinyals. “Understanding deep learning requires rethinking generalization”. In: Int. Conf. Representation Learning (ICLR). 2017. arXiv: 1611.03530v2.   \n[15] V. Feldman. “Does learning require memorization? a short tale about a long tail”. In: Proc. 52nd Ann. ACM SIGACT Symp. Theory of Comput. (STOC). 2020, pp. 954–959.   \n[16] A. Jacot, F. Gabriel, and C. Hongler. “Neural tangent kernel: Convergence and generalization in neural networks”. In: Advances in Information Processing Systems (NeurIPS). 2018. arXiv: 1806.07572.   \n[17] J. Lee, L. Xiao, S. S. Schoenholz, Y. Bahri, R. Novak, J. Sohl-Dickstein, and J. Pennington. Wide neural networks of any depth evolve as linear models under gradient descent. 2019. arXiv: 1902.06720.   \n[18] S. Arora, S. S. Du, Z. Li, R. Salakhutdinov, R. Wang, and D. Yu. Harnessing the power of infinitely wide deep nets on small-data tasks. 2019. arXiv: 1910.01663.   \n[19] A. Lewkowycz, Y. Bahri, E. Dyer, J. Sohl-Dickstein, and G. Gur-Ari. The large learning rate phase of deep learning: the catapult mechanism. 2020. arXiv: 2003.02218.   \n[20] J. Frankle, G. K. Dziugaite, D. Roy, and M. Carbin. “Linear mode connectivity and the lottery ticket hypothesis”. In: Int. Conf. Machine Learning (ICML). 2020, pp. 3259–3269. arXiv: 1912.05671.   \n[21] P. K. Agarwal, S. Har-Peled, K. R. Varadarajan, et al. “Geometric approximation via coresets”. Combinatorial and computational geometry 52 (2005), pp. 1–30.   \n[22] D. Feldman, M. Schmidt, and C. Sohler. “Turning big data into tiny data: Constant-size coresets for k-means, PCA, and projective clustering”. SIAM J. Computing 49.3 (2020), pp. 601– 657.   \n[23] E. Tolochinsky and D. Feldman. Coresets for monotonic functions with applications to deep learning. 2018. arXiv: 1802.07382.   \n[24] K. Wei, R. Iyer, and J. Bilmes. “Submodularity in data subset selection and active learning”. In: Int. Conf. Machine Learning. PMLR. 2015, pp. 1954–1963.   \n[25] O. Sener and S. Savarese. Active learning for convolutional neural networks: A core-set approach. 2017. arXiv: 1708.00489.   \n[26] K. Killamsetty, D. Sivasubramanian, G. Ramakrishnan, and R. Iyer. GLISTER: Generalization based Data Subset Selection for Efficient and Robust Learning. 2020. arXiv: 2012 . 10630.   \n[27] B. Mirzasoleiman, J. Bilmes, and J. Leskovec. “Coresets for data-efficient training of machine learning models”. In: Int. Conf. Machine Learning (ICML). PMLR. 2020, pp. 6950–6960. arXiv: 1906.01827.   \n[28] Y. Shen, H. Yun, Z. C. Lipton, Y. Kronrod, and A. Anandkumar. Deep active learning for named entity recognition. 2017. arXiv: 1707.05928.   \n[29] B. Mirzasoleiman, K. Cao, and J. Leskovec. “Coresets for Robust Training of Neural Networks against Noisy Labels” (2020). arXiv: 2011.07451.   \n[30] G. Pleiss, T. Zhang, E. R. Elenberg, and K. Q. Weinberger. “Identifying mislabeled data using the area under the margin ranking”. arXiv preprint arXiv:2001.10528 (2020).   \n[31] C. Agarwal, D. D’souza, and S. Hooker. “Estimating example difficulty using variance of gradients”. arXiv preprint arXiv:2008.11600 (2020).   \n[32] R. J. N. Baldock, H. Maennel, and B. Neyshabur. Deep Learning Through the Lens of Example Difficulty. 2021. arXiv: 2106.09647 [cs.LG].   \n[33] P. W. Koh and P. Liang. “Understanding black-box predictions via influence functions”. In: Int. Conf. Machine Learning. PMLR. 2017, pp. 1885–1894.   \n[34] E. Barshan, M.-E. Brunet, and G. K. Dziugaite. “Relatif: Identifying explanatory training samples via relative influence”. In: Int. Conf. Artificial Intelligence and Statistics (AISTATS). 2020, pp. 1899–1909.   \n[35] G. Pruthi, F. Liu, S. Kale, and M. Sundararajan. “Estimating Training Data Influence by Tracing Gradient Descent”. In: Advances in Neural Information Processing Systems. 2020.   \n[36] V. Feldman and C. Zhang. What neural networks memorize and why: Discovering the long tail via influence estimation. 2020. arXiv: 2008.03703.   \n[37] J. Bradbury, R. Frostig, P. Hawkins, M. J. Johnson, C. Leary, D. Maclaurin, G. Necula, A. Paszke, J. VanderPlas, S. Wanderman-Milne, and Q. Zhang. JAX: composable transformations of Python+NumPy programs. Version 0.2.5. 2018.   \n[38] J. Heek, A. Levskaya, A. Oliver, M. Ritter, B. Rondepierre, A. Steiner, and M. van Zee. Flax: A neural network library and ecosystem for JAX. Version 0.3.4. 2020. ",
+        "bbox": [
+            171,
+            125,
+            828,
+            905
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            89,
+            826,
+            632
+        ],
+        "page_idx": 11
+    }
+]

parse/train/Uwh-v1HSw-x/Uwh-v1HSw-x.md

@@ -0,0 +1,233 @@
+# Training Neural Networks with Fixed Sparse Masks
+
+Yi-Lin Sung∗ UNC Chapel Hill ylsung@cs.unc.edu
+
+Varun Nair∗ Duke University vn40@duke.edu
+
+Colin Raffel UNC Chapel Hill craffel@gmail.com
+
+# Abstract
+
+During typical gradient-based training of deep neural networks, all of the model’s parameters are updated at each iteration. Recent work has shown that it is possible to update only a small subset of the model’s parameters during training, which can alleviate storage and communication requirements. In this paper, we show that it is possible to induce a fixed sparse mask on the model’s parameters that selects a subset to update over many iterations. Our method constructs the mask out of the $k$ parameters with the largest Fisher information as a simple approximation as to which parameters are most important for the task at hand. In experiments on parameter-efficient transfer learning and distributed training, we show that our approach matches or exceeds the performance of other methods for training with sparse updates while being more efficient in terms of memory usage and communication costs. We release our code publicly to promote further applications of our approach.2
+
+# 1 Introduction
+
+Stochastic gradient descent (SGD) is a vital component of the modern pipeline for training deep neural networks. Along with the back-propagation algorithm, gradient descent allows for the efficient minimization of a loss function by gradually updating a model’s parameters. SGD minimizes the loss over a small random subset of the dataset at each training iteration, which allows training over large datasets. In practice, minimizing a large neural network’s training loss using SGD often results in models that generalize well to new data [3, 17, 27], making SGD an invaluable tool.
+
+While effective, standard SGD requires that all model parameters are updated at every iteration of training. As a result, communicating changes to the model requires communicating the updated value of every parameter. Since modern neural networks often have millions or billions of parameters [9, 7, 40], this communication can become excessively expensive. A concrete example of the negative impacts of these costs arises in the setting of transfer learning. In transfer learning, a model’s parameters are initialized from an existing pre-trained model before being fine-tuned (i.e. trained) on a task of interest. Pre-trained models can be fine-tuned a huge number of times – for example, the Hugging Face model repository3 has thousands of fine-tuned variants of the BERT model [12]. Each of these fine-tuned variants requires a unique copy of the model’s parameters, each of which takes up around 500MB of disk space. Relatedly, in distributed training [11] and federated learning [35], workers compute updates for a centralized model in parallel on different subsets of data. After a certain number of updates, the workers each communicate the newly-computed parameter values back to the centralized model. The communication step can cause a significant amount of overhead (particularly when the model is large) since the workers must communicate the updated values of all parameters when using standard SGD.
+
+![](images/1bf43c1ff9e93dadfc033c4f837c48bdac97e690153e19a2e3f7d3022ee485ee.jpg)  
+Figure 1: Diagram comparing our proposed method to standard SGD. In traditional gradient-based training (left), all of a model’s parameters are updated at every iteration. We propose FISH Mask, a method for precomputing a sparse subset of parameters to update over many subsequent training iterations. To construct the FISH Mask, we find the $k$ parameters with the largest Fisher information (right, top). Then, we train the model with traditional gradient descent, but only update those parameters chosen by the mask (right, bottom).
+
+These issues could be mitigated if it was possible to only update a few parameters during training while still maintaining performance close to that of training all parameters. This has led to various work on parameter-efficient training of neural networks. For example, Adapters [19, 41, 5] introduce additional parameters into a pre-trained model in the form of small task-specific modules that are fine-tuned while the rest of the model’s parameters are kept fixed. Diff Pruning [16] and BitFit [6] demonstrate that it is possible to fine-tune a model while only updating a small subset of the existing parameters. In distributed and federated learning settings, Aji and Heafield [2] and Konecnˇ y\` et al. [23] have shown that it is possible for each worker to only update a sparse subset of a model’s parameters, thereby reducing communication costs.
+
+Existing methods for training with sparse updates typically work in one of three ways: they either add parameters to the model (Adapters), choose a hand-defined and heuristically-motivated subset of parameters (BitFit), or allow the subset of parameters to change over the course of training (Diff Pruning and methods in distributed and federated training). In this paper, we argue for pre-computing a sparse subset of existing parameters to update and keeping the subset fixed over many iterations of training. This approach yields various benefits: First, by updating a subset of existing parameters instead of adding parameters (as is done in Adapters), we avoid any increase in the total size of the model. Second, by avoiding hand-defining the mask, we can ensure that our procedure is modelagnostic. Third, by pre-computing a mask, we avoid the computational and memory overhead that are apparent when updating the mask over the course of training. It also allows workers in the distributed training setup to operate on strictly complementary subsets of parameters. Finally, keeping the mask fixed over many iterations, we can ensure that only a specific fixed number of parameters are updated. We are not aware of any existing techniques that satisfy these desiderata.
+
+Motivated by these benefits, we introduce a new method for pre-computing fixed sparse masks. Our approach first estimates the importance of each parameter using an empirical approximation of its Fisher information. Then, we construct the mask by choosing the $k$ parameters with the largest Fisher information. The resulting mask, which we deem a “FISH (Fisher-Induced Sparse uncHanging) mask”, can be re-used for many subsequent training iterations. We demonstrate the effectiveness of using a FISH Mask in a wide variety of settings, including parameter-efficient transfer learning, distributed training with long delays across workers, and reducing checkpoint size. Broadly speaking, FISH Mask training can dramatically reduce storage and communication requirements, while sacrificing minimal performance compared to standard gradient descent and outperforming relevant prior methods for training with sparse updates.
+
+# 2 The Fisher-Induced Sparse uncHanging (FISH) Mask
+
+The main contribution of this paper is a method for pre-computing a sparse subset of a model’s parameters to update over many subsequent training iterations. To construct such a subset, we use an approximation of each parameter’s Fisher information as a signal of how important the parameter is for a given task. We refer to the resulting mask (i.e. binary array indicating which parameters are included in the subset) as a FISH (Fisher-Induced Sparse uncHanging) mask. In this section, we provide the necessary background and detail the steps necessary for computing a FISH Mask. This process is diagrammed in fig. 1.
+
+# 2.1 Fisher Information
+
+Our goal is to select the subset of parameters that are (in some sense) the most important to update. One way to measure a parameter’s importance is to consider how much changing the parameter will change the model’s output. We denote $p _ { \theta } ( y | x )$ as the output distribution over $y$ produced by a model with parameter vector $\theta \in \mathbb { R } ^ { | \theta | }$ given input $x$ . One way to measure how much a change in parameters would change a model’s prediction would be to compute $\mathrm { D } _ { \mathrm { K L } } ( p _ { \boldsymbol { \theta } } ( \boldsymbol { y } | \boldsymbol { x } ) | | p _ { \boldsymbol { \theta } + \delta } ( \boldsymbol { y } | \boldsymbol { x } ) )$ , where $\delta \in \mathbb { R } ^ { | \theta | }$ is a small perturbation. It can be shown [34, 37] that as $\delta  0$ , to second order,
+
+$$
+\mathbb { E } _ { x } \mathrm { D } _ { \mathrm { K L } } \big ( p _ { \theta } ( y | x ) \ | | \ p _ { \theta + \delta } ( y | x ) \big ) = \delta ^ { \mathrm { T } } F _ { \theta } \delta + O ( \delta ^ { 3 } )
+$$
+
+where $F _ { \theta } \in \mathbb { R } ^ { | \theta | \times | \theta | }$ is the Fisher information matrix [14, 4], defined as
+
+$$
+F _ { \theta } = \mathbb { E } _ { x \sim p ( x ) } \left[ \mathbb { E } _ { y \sim p _ { \theta } ( y \vert x ) } \nabla _ { \theta } \log p _ { \theta } ( y \vert x ) \nabla _ { \theta } \log p _ { \theta } ( y \vert x ) ^ { \mathrm { T } } \right]
+$$
+
+Given this relation, it can be seen that the Fisher information matrix is closely connected to how much each parameter affects the model’s predictions. Indeed, this has led the Fisher information matrix to be widely used in modern machine learning, e.g. as a measure of parameter importance [21], as a preconditioner in gradient descent [4, 37, 34], as a way to measure the amount of “information” in each parameter of a neural network [1], or as a way to decide which parameters to prune when performing model compression [43, 10, 47].
+
+When applied to large neural networks, the $\left| \theta \right| \times \left| \theta \right|$ size of the Fisher information matrix makes it intractable to compute. Prior work therefore frequently approximates $F _ { \theta }$ as a diagonal matrix, or equivalently, as a vector in $\mathbb { R } ^ { | \theta | }$ . Separately, when training machine learning models we seldom have the ability to draw samples $x \sim p ( x )$ ; instead, we are given a finite training set of such samples. Furthermore, it is rarely necessary to compute the expectation over $x$ in eq. (2) over the full training set; instead, it can often be well-approximated over $N$ samples $x _ { 1 } , \ldots , x _ { N }$ . These constraints result in the following common approximation:
+
+$$
+\hat { F _ { \theta } } = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \mathbb { E } _ { y \sim p _ { \theta } ( y | x _ { i } ) } ( \nabla _ { \theta } \log p _ { \theta } ( y | x _ { i } ) ) ^ { 2 }
+$$
+
+where $\hat { F } _ { \theta } \in \mathbb { R } ^ { | \theta | }$ . This approximation also has an intuitive interpretation: A given entry in $\hat { F } _ { \theta }$ relates to the average of the square gradient of the model’s output with respect to a given parameter. If a given parameter heavily affects the model’s output, then its corresponding entry in $\hat { F } _ { \theta }$ will be large, so we can reasonably treat $\hat { F } _ { \theta }$ as an approximation of the importance of each parameter.
+
+Note that both eq. (2) and eq. (3) include an expectation over $y \sim p _ { \theta } ( y | x )$ . When the number of classes is small, this expectation can be computed exactly. For tasks with many possible classes, it is common to approximate the expectation with a few samples from $p _ { \theta } ( y | x )$ . In supervised learning settings, we have access to the ground-truth label $y _ { i }$ for each sample $x _ { i }$ in our training set. This leads to the possibility of replacing $\mathbb { E } _ { y \sim p _ { \theta } ( y | x _ { i } ) } ( \nabla _ { \theta } \log p _ { \theta } ( y | x _ { i } ) ) ^ { 2 }$ in eq. (3) with $( \nabla _ { \theta } \mathbf { \bar { l } } _ { 0 } \mathrm { { g } } p _ { \theta } ( y _ { i } | x _ { i } ) ) ^ { 2 }$ Performing this approximation is referred to as the “empirical Fisher”. It has been shown that using the empirical Fisher can lead to degenerate behavior when used as a preconditioner in an optimizer [34, 26]. Since our use of the Fisher information is largely based on a heuristically-motivated notion of parameter importance, we experimented with both the empirical and standard (eq. (3)) Fisher approximations and found that they produced similar performance. Furthermore, the Empirical Fisher is faster to compute than the standard Fisher as long as more than one sample is used to approximate the expectation $\mathbb { E } _ { y \sim p _ { \theta } ( y | x _ { i } ) }$ . We discuss this further in section 4.4.1.
+
+# 2.2 Computing Fixed Sparse Masks
+
+Recall that our goal is to select a subset of parameters (or, equivalently, a sparse mask over parameters) to update over many iterations of training while keeping the remainder of the parameters fixed. Having established the Fisher information as a useful tool for estimating the importance of a given parameter, we therefore first compute the approximate Fisher information (as described in the previous section)
+
+for all of a model’s parameters. Then, to construct the FISH Mask, we simply choose the $k$ parameters with the largest Fisher information, where $k$ is set according to the desired mask sparsity level.4 Specifically, a FISH Mask comprises the parameters $\{ \theta _ { i } \mid \hat { F } _ { \theta _ { i } } \geq \mathsf { s o r t } ( \hat { F } _ { \theta } ) _ { k } \}$ . Computing the FISH Mask is cheap because $\hat { F } _ { \theta }$ can be computed efficiently using backpropagation, and (as we will show in section 4.4.2) we can obtain a reliable mask for relatively small values of $N$ . Further, the fact that we re-use the mask for many iterations prevents us from having to compute $\hat { F } _ { \theta }$ frequently. As we will show in section 4, we find that this simple procedure is sufficient to produce a mask that can be reused for many iterations (over 100,000 iterations in some cases) in a wide variety of settings without sacrificing substantial performance compared to standard gradient-based training.
+
+Note that in some applications of transfer learning, a new linear classifier layer must be added to the model to make it applicable to the downstream task. Since the FISH Mask depends on $p _ { \theta } ( y | x )$ and is computed before training begins, this means that we must compute the FISH Mask using the randomly-initialized classifier before any training has begun. We find that computing the Fisher information through the randomly-initialized classifier layer still provides a good signal of parameter importance. When applying FISH Mask in transfer learning settings where a new classifier layer is added, we always include the parameters of the classifier in the mask.
+
+# 3 Related Work
+
+Our approach bears similarity and takes inspiration from existing approaches for parameter-efficient transfer learning and distributed training of machine learning models. In this section, we outline related methods, some of which we will compare to directly in section 4. We also briefly describe how our work is related to and differs from work in network pruning.
+
+# 3.1 Parameter-Efficient Transfer Learning
+
+Transfer learning [36], where a model is initialized from a pre-trained checkpoint before being finetuned on a related downstream task, can dramatically improve performance and speed up convergence on the downstream task [12, 8, 40]. Standard practice is to update all of the model’s parameters during fine-tuning, though in some cases reasonable performance can be attained by only fine-tuning the output layer of the model [20, 8, 38]. Training only the output layer has the benefit that adapting a given pre-trained model to a downstream task only requires adding a relatively small number of new parameters, but typically results in worse performance compared to training the full model [38, 24].
+
+Various methods have been proposed that endeavor to match the performance of fine-tuning the full model while only updating or adding a small amount of parameters. Adapters [19, 41, 5] are small subnetworks that are added between a pre-trained neural networks layers. Various works [19, 33, 32] have shown that, when appropriately designed, updating only the parameters in the adapters and the output layer can approach the performance of fine-tuning all parameters. For example, Houlsby et al. [19] add on average $3 . 6 \%$ more parameters to adapt a pre-trained BERT model [12] to tasks in the GLUE benchmark [48]. Concurrent work by Mahabadi et al. [33] improves the efficiency of Adapters by generating the weights of task-specific adapters via a hypernetwork. A second concurrent approach by Mahabadi et al. [32] introduces COMPACTER, which utilizes matrix decomposition and low-rank parameterization for the adapters’ weights. COMPACTER is shown to achieve the same performance as standard fine-tuning of the T5 models [40] while only adding $0 . 0 4 7 \%$ as many parameters as the original model. Finally, very recent work has shown that it is possible to train language models to perform a task by only optimizing the parameters of a "prompt" that is injected into the input of the model’s layers [29, 28]. This can yield extremely parameter-efficient results (as low as $0 . 0 1 \%$ task-specific parameters [28]) but this class of methods is only applicable to next-step-prediction language models. The main drawback of all Adapter-style methods is that they increase the parameter count and computational cost of the model. This makes them inapplicable to the distributed training and efficient checkpointing settings consider in this paper. We therefore only compare directly to other methods that do not add any parameters.
+
+More closely related to our approach are methods for choosing a small subset of the model’s existing parameters to update. In an extreme case, Zhao et al. [50] find a sparse mask to multiply against pre-trained parameters (which are not otherwise updated). That is, instead of fine-tuning the models, a binary mask is learned that marks which parameters should be zeroed out. The resulting performance degrades heavily when the mask is made very sparse, suggesting that it is likely beneficial to update parameters. More recently, Guo et al. [16] propose “Diff Pruning”, where a sparse binary mask is found over the course of training that denotes which parameters should be updated or fixed at the value from the pre-trained model. Mask sparsity in the binary mask is enforced through a smooth approximation of the $L _ { 0 }$ norm introduced by Louizos et al. [31]. Guo et al. [16] also show improved performance by imposing a structure on the mask according to which parameters correspond to a particular weight matrix or bias vector. Ultimately, Diff Pruning is shown to both be more parameterefficient and outperform Adapters when applied to fine-tuning BERT on the GLUE benchmark. However, using Diff Pruning requires significantly more memory during training in order to store and update the mask. Another recent result by Ben-Zaken et al. [6] demonstrated that simply updating the bias parameters in BERT can attain competitive performance with Diff Pruning. While this provides a simple and strong baseline, it is not universally applicable – for example, the pre-trained T5 model [40] does not have any bias vectors. In section 4, we show that using a FISH Mask outperforms all of these approaches in parameter-efficient fine-tuning of BERT on GLUE.
+
+# 3.2 Distributed Training
+
+As models and datasets grow, it becomes inefficient or impossible to train a model on a single machine. This has motivated the need for distributed training strategies where computation for training a model is shared across many machines (called workers) [11]. A major consideration in distributed training are communication costs, since workers need to regularly communicate parameter updates with one another. To minimize communication costs, workers can compute multiple updates on their copy of the model before communicating their changes, but this gives rise to the “stale gradient” problem where workers are operating on an out-of-date copy of the model. The standard and straightforward approach to dealing with stale gradients it to simply apply updates in the “wrong” order, which can be effective in practice [11, 42]. An orthogonal approach to reducing communication costs is to have workers only update a small subset of the model’s parameters [2, 13, 44, 45]. For example, Aji and Heafield [2] simply have workers communicate only those updates corresponding to the gradients with top- $k$ largest magnitude at each step. This bears a similar motivation to FISH Mask, but results in a “mask” that changes at every iteration and therefore requires workers communicate after each update. In contrast, pre-computing a FISH Mask allows workers to perform multiple iterations before communicating their updates, thereby further reducing communication costs.
+
+An extreme variant of distributed training is federated learning [22, 35]. In federated learning, asynchronous workers perform many updates on private data before communicating the changes back to a centralized model. The training involves one server and multiple clients, and the server model’s gradient is the combination of the workers’ gradients. As with any form of asynchronous training, communication costs and stale gradients are significant issues. McMahan et al. [35] demonstrated that averaging the updates computed by individual workers is an effective approach to dealing with stale gradients and Konecnˇ y et al. \` [23] investigated techniques for significantly reducing communication costs. Our method is complementary to the techniques for reducing communication proposed by Konecnˇ y et al. [23].\`
+
+# 3.3 Network Pruning
+
+Past work in network pruning has also explored techniques for sparsifying neural networks (i.e. zeroing out many parameters for compression purposes) while sacrificing minimal performance. Most relevant to our work, Theis et al. [46] propose utilizing the Fisher to prune and decrease the overall number of parameters for gaze prediction, and Liu et al. [30] also use the Fisher to discover groups of parameters to prune from common backbone architectures. Critically, these works differ from our work in that we do not train neural networks with sparse weights. Instead, we focus on using the Fisher to inform the selection of a fixed sparse subset of weights in a non-sparse network to update over the course of training.
+
+# 4 Experiments
+
+We evaluate the efficacy of the FISH Mask in three settings: parameter-efficient transfer learning, distributed training, and training with efficient checkpointing. For parameter-efficient transfer learning, we demonstrate that our approach matches the performance of standard gradient-based training on the GLUE benchmark [48] while updating only $0 . 5 \%$ of the model’s parameters per task. For distributed training, we evaluate FISH Mask training for both transfer learning on GLUE and training from scratch on CIFAR-10 [25]. In both settings, we find that we can dramatically reduce communication without sacrificing significant performance, though from-scratch training on CIFAR-10 requires a higher mask sparsity level than fine-tuning on GLUE. Finally, we demonstrate a novel application of training with sparse updates: Minimizing the size of checkpoints over training. We show that using a FISH Mask while training on CIFAR-10 with a mask sparsity level of $10 \%$ can shrink checkpoint size on disk by a factor of 5 while sacrificing only a small amount of accuracy. Throughout our experiments, we report results with varying mask sparsity to get a sense of the savings induced by the FISH Mask. For ease of comparison, we report mask sparsity in terms of the total percentage of parameters that are updated. This percentage can be converted to a value of $k$ used for the top- $k$ operation when constructing the mask simply by multiplying it against the total number of parameters in the model.
+
+We also include ablation studies to measure the impact of the number of samples used to estimate the Fisher information as well as the choice of true or empirical Fisher. All experiments for GLUE are run with the BERTLARGE variant of BERT, which contains 16 attention heads, 24 layers, and 330 million parameters in total [12], and most experiments are run on a RTX 3090 GPU. For experiments on CIFAR-10, we use a ResNet-34 [18] with various optimizations for fast convergence.5 We report the average performance across 5 seeds for all experiments.
+
+# 4.1 Parameter-Efficient Transfer Learning
+
+In parameter-efficient transfer learning, the goal is to fine-tune a pre-trained model while updating as few parameters as possible. We focus on fine-tuning $\mathbf { B E R T _ { L A R G E } }$ on the GLUE benchmark [48], which is the primary setting used for evaluation in prior work. For all experiments, we fine-tune for 7 epochs and perform a hyper-parameter search across learning rate $\in \{ 1 \stackrel { \cdot } { \times } 1 0 ^ { - 4 } , 5 \times 1 0 ^ { - 5 } , 1 \times 1 0 ^ { - 5 } \}$ and batch si $\mathsf { z e } \in \{ 8 , 1 6 \}$ for each GLUE task. We find the learning rate of $5 \times 1 0 ^ { - 5 }$ and batch size of 16 to be effective for most tasks, with the exception of batch $\mathrm { s i z e } = 8$ used for RTE. Additional hyper-parameters, such as choice of optimizer, sequence length, and others, follow from the default configuration for BERTLARGE presented in the Hugging Face library [49]. Test set results are reported by submitting to the GLUE benchmark using the final model checkpoint following a hyper-parameter search on validation results, unless otherwise noted.
+
+Baselines We compare GLUE task performance of the FISH Mask to several other baselines and methods focused on parameter-efficient transfer learning. In Dense Fine-tuning, we fine-tune all parameters of a pre-trained model, as is typical in standard transfer learning. In the Random Mask baseline, we randomly select and fix $k$ parameters to update at the start of training. To compare to prior work, we reproduce Bit-Fit [6], in which only the bias parameters of the BERT model are updated across training. Our reproduction follows the original paper and performs a hyper-parameter search with learning rates in the $[ 1 \times 1 0 ^ { - 3 } , 1 \times 1 0 ^ { - 4 } ]$ range. We also reproduce results from Diff Pruning [16], which updates the sparse mask over the course of training. Our reproduction of Diff Pruning at $0 . 5 \%$ mask sparsity follows the paper’s code-base6 and training settings, and reports the GLUE test set results using the best validation checkpoint. Due to restrictions on the number of permissible submissions to the GLUE test server, we are only able to report results with a mask sparsity of $0 . 5 \%$ for those methods where we can control the mask sparsity level. We therefore include additional validation set results for varying mask sparsity levels when using a FISH Mask.
+
+Results Our results on parameter-efficient transfer learning with the FISH Mask can be seen in table 1. FISH Mask training results in effectively the same performance $( 8 2 . 6 \% )$ as standard “dense” fine-tuning $( 8 2 . 5 \% )$ , despite updating just $0 . 5 \%$ of BERTLARGE parameters. The Random Mask baseline achieves a significantly lower average GLUE score, which demonstrates the value of using
+
+<table><tr><td>Method</td><td>Updated Params/Task</td><td>QNLI</td><td>SST-2</td><td>MNLIm</td><td>MNLImm</td><td>CoLA</td><td>MRPC</td><td>STS-B</td><td>RTE</td><td>QQP</td><td>AVG</td></tr><tr><td>Dense Fine-tuning</td><td>100%</td><td>93.4</td><td>94.9</td><td>87.0</td><td>86.1</td><td>61.0</td><td>86.6</td><td>86.5</td><td>70.9</td><td>80.5</td><td>82.5</td></tr><tr><td>Random Mask</td><td>0.50%</td><td>89.8</td><td>93.4</td><td>83.7</td><td>84.0</td><td>43.2</td><td>77.8</td><td>87.7</td><td>61.3</td><td>77.2</td><td>76.8</td></tr><tr><td>Bit-Fit [6]</td><td>0.08%</td><td>90.4</td><td>94.5</td><td>85.0</td><td>84.8</td><td>60.3</td><td>86.3</td><td>85.0</td><td>69.6</td><td>78.5</td><td>81.2</td></tr><tr><td>Diff Pruning [16]</td><td>0.50%</td><td>91.9</td><td>93.8</td><td>86.0</td><td>85.5</td><td>61.0</td><td>86.2</td><td>85.6</td><td>67.5</td><td>80.1</td><td>81.5</td></tr><tr><td>FISHMask</td><td>0.08%</td><td>93.3</td><td>94.0</td><td>85.3</td><td>84.9</td><td>56.4</td><td>86.2</td><td>85.7</td><td>70.2</td><td>79.3</td><td>81.3</td></tr><tr><td>FISHMask</td><td>0.50%</td><td>93.1</td><td>94.7</td><td>86.5</td><td>85.9</td><td>61.6</td><td>87.1</td><td>86.5</td><td>71.2</td><td>80.2</td><td>82.6</td></tr></table>
+
+Table 1: GLUE test server evaluation results with BERTLARGE. MRPC and QQP are reported as an average of F1-score and accuracy, and STS-B is reported as an average of Pearson and Spearman correlation. Accuracy is reported for all other tasks. All results are reproduced experimentally. Training with the FISH surpasses (82.6) other methods and equals dense fine-tuning performance (82.5) whilst updating only $0 . 5 \%$ of model parameters.
+
+![](images/b9bad8752af76a2f149e5f7491ae5a4d3b8240fba3fc407e81321404b595077f.jpg)  
+Figure 2: (Left) GLUE validation performance of a randomly selected mask and the FISH Mask at varying levels of mask sparsity. Compared to the densely fine-tuned baseline score of $85 \%$ , training with the FISH Mask is competitive at $0 . 5 \%$ mask sparsity. (Right) GLUE validation performance at varying levels of dataset samples used to compute the FISH Mask. Few samples are needed to effectively compute the FISH Mask and obtain good performance. Results in both (Left) and (Right) are averaged over 5 seeds.
+
+the Fisher information in selecting parameters to update. Finally, FISH Mask training is competitive with all other parameter-efficient transfer learning approaches; the next-best score of $8 1 . 5 \%$ is achieved by Diff Pruning [16]. As mentioned in section 3, we do not include a direct comparison to Adapter-based methods since they add parameters to the model, though we note that our method is able to match BERTLARGE’s performance using a significantly lower mask sparsity level $0 . 5 \%$ vs. $3 . 6 \%$ ) than the method proposed by Houlsby et al. [19].
+
+Figure 2 shows the change in performance on the GLUE validation set as we change the mask sparsity level for both a random mask and a FISH Mask. We find that the FISH Mask consistently outperforms the random mask baseline and is still strong even at a lower mask sparsity level of $0 . 1 \%$ . These results demonstrate that the FISH Mask can be a useful tool in mitigating the storage costs of saving many fine-tuned models since it only requires that the updated parameters and their respective indices are saved.
+
+# 4.2 Distributed Training
+
+Now, we turn to using FISH Mask to reduce communication costs in distributed training settings. We consider the setting where distributed workers compute many subsequent updates to a local copy of the model before transmitting their changes back to a central server. In our experiments, we assume all workers sample data i.i.d. from the same dataset and that all workers compute the same number of updates between each communication step, though our results could carry over to settings where workers use different datasets and varying amounts of updates (e.g. in Federated Learning [35]).
+
+Let $\theta$ denote the parameter vector stored on the central server and $\delta _ { i }$ represent the update computed by worker $i$ . After each update/communication step, the server must transmit the updated $\theta$ back to all workers. When standard gradient-based training is used, all parameters are updated, so $| \delta _ { i } | = | \theta |$ . If there are $M$ workers, the communication costs for normal training are then $M | \delta _ { i } | = M | \ddot { \theta } |$ for workerto-server communication and $M | \theta |$ for server-to-worker communication, for a total communication cost of $2 M | \theta |$ .
+
+Using a sparse mask will effectively reduce the size of each $\delta _ { i }$ to $k$ . Without loss of generality, we assume that $| \delta _ { i } |$ is the same across all workers. Furthermore, assuming updates are aggregated on the central server by summing them together, the server can either communicate the full updated parameter vector back to all workers, or the server can communicate all other workers’ updates to a given worker. These two options amount to server-to-worker communication costs of either $M | \theta |$ or $M ( M - \underline { { { 1 } } } ) \lVert \delta _ { i } \rVert \approx M ^ { 2 } | \dot { \delta } _ { i } |$ . In general, we expect $M$ to be small and $| \theta |$ to be large, so we typically have $M ^ { 2 } | \delta _ { i } | < M | \theta |$ . Therefore, we can achieve significant communication savings by using sparse updates. For simplicity, we set $M = 2$ in all of our experiments; this makes the savings in communication equal to the mask sparsity level. To apply FISH in distributed training, the central server computes $\hat { F } _ { \theta }$ and a single FISH Mask which is shared across all workers.
+
+Baselines For distributed training experiments, we compare FISH Mask training to three baselines: First, in standard training, we tune all the parameters in a single machine (i.e. standard, nondistributed training). This provides an upper bound on performance for distributed training techniques. Second, in densely-updated distributed training, workers use standard gradient descent to compute updates over all parameters, and all of the worker’s updates are added together on the centralized server. Third, in random mask distributed training, we randomly select a subset of parameters to update for workers. For a fair comparison, we keep the overall training batches the same for all methods, so the training iterations of a worker are half of that of the single-machine baseline.
+
+Experimental setting In preliminary experiments on the GLUE benchmark (described in appendix A), we found that densely-updated distributed training saw no real degradation in performance even for long communication delays. This suggests that stale gradients could be less of an issue in transfer learning settings. We therefore instead focused on from-scratch training of a ResNet-34 on CIFAR-10. We train the model for 100 total epochs, with 50 epochs performed by each of the two workers. Notably, we found that the performance of sparse update methods was poor for fromscratch training unless we performed 5 epochs of standard training as “warmup” before beginning distributed training. Beyond this change, all the models and hyper-parameters follow those mentioned in section 4.1. We searched for the best initial learning rate in {0.4, 0.2, 0.08, 0.04, 0.02}. We measure performance using a varying number of parameter updates between each worker-server communication step. We report performance in terms of the accuracy achieved under a certain communication budget, where the communication cost is measured in terms of the equivalent number of full model parameter updates. For example, a method that updates $10 \%$ of the model’s parameters and performs 5 communication steps over the course of training has the same cost as a method that communicates all of a model’s parameters once (since we must transmit both the updated parameters and their locations; more details are in section 4.3).
+
+Results Results from training a ResNet-34 on CIFAR-10 are shown in fig. 3. As in section 4.1, using a FISH Mask works better than using a random mask for all communication costs. Furthermore, we generally find that using FISH Mask with a sparsity level of $10 \%$ attains a better commnication/performance trade-off than densely-updated distributed training. For example, FISH Mask training attains comparable performance to standard training when only communicating two copies of the model, whereas densely-updated training performs significantly worse at this communication amount. Notably, performance was relatively poor when only updating $2 \%$ of the model’s parameters with FISH Mask, suggesting there is a lower bound under which it is difficult to attain reasonable results. As a whole, our results show significant promise for dramatically reducing computational costs in distributed training settings.
+
+# 4.3 Efficient Checkpointing
+
+Over the course of training a machine learning model, it is common to save intermediate checkpoint files that store the model’s parameter values. These checkpoints can be useful for restarting training from a given iteration rather than starting from scratch in the event that the training job crashes or is otherwise stopped. They are also commonly used for post-hoc analysis, for example for evaluating a model’s performance on new datasets or metrics over the course of training. Since checkpoints store a full copy of the model’s parameters, they can take up a significant amount of space on disk.
+
+![](images/8998565721af8c8071214bca31df7506ed15f4236f119467ad82f4977cc53755.jpg)  
+Figure 3: CIFAR-10 validation set accuracy achieved by a ResNet-34 through distributed training at different communication costs. $\mathrm { X }$ -axis refers to the total number of model communications required for a single worker. Standard (non-distributed) training achieves an accuracy of $9 3 . 9 \%$ .
+
+Furthermore, depending on the checkpointing frequency, hundreds of checkpoints are often written to disk over the course of a training run. The development cycle of a machine learning model can result in hundreds of different model variants being trained. Combining these factors with the on-disk space needed to store the parameters of modern models (around 1 GB for BERTLARGE) results in potentially massive storage costs.
+
+Training with sparse updates can significantly reduce these storage costs. Specifically, if only a small subset of the parameters are updated between checkpoint saves, then the checkpoint only needs to store the updated parameter values and indices denoting the position of the updated parameters’ values. Assuming that the storage costs for a parameter value and index is the same (e.g. using a 32-bit float for parameter values and a 32-bit integer for indices), using a sparse mask will reduce storage cost when the mask sparsity level is less than $50 \%$ . Note that this setting allows the “mask” to change over the course of training, and is therefore a relaxation of the setting in section 4.1, where the requirement is that the same subset of parameters is updated over the entire fine-tuning run. It follows from our results in section 4.1 that FISH Mask training could be readily applied to reducing checkpoint size in parameter-efficient transfer learning. However, we found that the strict requirement of fixing the mask over an entire from-scratch training run on CIFAR-10 resulted in a significant degradation in performance. This is in line with past work demonstrating the difficulty of identifying fixed sparse subnetworks to train before training begins [15]. We therefore focus on from-scratch training on CIFAR-10 and allow the mask to change every time a checkpoint is written, which does not increase storage requirements over using the same fixed mask from the start of training.
+
+Table 2: CIFAR-10 validation set accuracy when using the FISH Mask and the Random Mask to reduce checkpoint sizes. “Epoch” refers to allowing the mask to change each epoch, and the number is how many epochs we update masks. Standard training achieves an accuracy of 93.9 $( \pm 0 . 1 ) \%$ .
+
+Overall, we use the same experimental setup as in section 4.2. We measure performance when updating the mask every epoch (which is a common choice in practice), every 2 epochs, every 4 epochs, and leaving the mask fixed over the course of training. We performed a new search over learning rates in $\{ 0 . 4 , 0 . 2 , 0 . 0 8 , 0 . 0 4 , 0 . 0 2 \}$ We compare to baselines of standard training (which to serve as an upper bound on the performance of using a FISH Mask) and using a random mask.
+
+<table><tr><td rowspan="2"></td><td colspan="3">Mask sparsity level</td></tr><tr><td>0.5%</td><td>2%</td><td>10%</td></tr><tr><td>Random Mask(1 Epoch)</td><td>74.80.6</td><td>84.40.2</td><td>90.00.2</td></tr><tr><td>FISH Mask (1 Epoch)</td><td>90.50.3</td><td>93.00.3</td><td>93.90.1</td></tr><tr><td>FISH Mask (2 Epochs)</td><td>90.30.5</td><td>92.50.1</td><td>93.70.2</td></tr><tr><td>FISH Mask (4 Epochs)</td><td>89.40.6</td><td>92.10.3</td><td>93.40.2</td></tr><tr><td>FISHMask (Fixed)</td><td>78.50.7</td><td>90.60.2</td><td>93.00.2</td></tr></table>
+
+Results In table 2, we show the results of FISH Mask training when keeping the mask fixed over the course of training or updating it at each epoch. We find that updating the FISH Mask every epoch can match the performance of normal training $9 3 . 9 \%$ accuracy) at a mask sparsity level of $10 \%$ , which would reduce storage requirements by a factor of 5. At lower mask sparsity levels, we see some degradation in performance. We find that accuracy tends to decrease as we decrease the frequency of updating the mask, but this effect is relatively small. As mentioned earlier, we also found that using a fixed mask significantly degraded performance, though only by a few percent at a mask sparsity level of $10 \%$ . This suggests that the FISH Mask could also be useful for identifying sparse subnetworks to train before training begins, as conjectured by the Lottery Ticket Hypothesis [15]. We leave the exploration of this possibility for future work. Lastly, the FISH Mask’s performance is unanimously better than the Random Mask across the three mask sparsity levels.
+
+# 4.4 Ablations
+
+Having established the effectiveness of training with a FISH mask, we now ablate a few design choices to help demonstrate the robustness of our approach. We perform all ablation experiments in the parameter-efficient transfer learning setup described in section 4.1.
+
+# 4.4.1 True Fisher vs. Empirical Fisher
+
+In section 2, we note that past work has approximated the Fisher information matrix (eq. (3)) using either the expectation over $y \sim p _ { \theta } ( y | x )$ (“true Fisher”) or ground-truth labels (“empirical Fisher”). While past work has shown that using the empirical Fisher can be detrimental in optimization settings [34, 26], we mainly use the Fisher information as a signal of parameter importance. The empirical Fisher also has the benefit that it avoids marginalizing over or sampling from $p _ { \theta } ( y | x )$ and only requires computing the gradient for a single value of $y$ . When comparing the performance of using the true or empirical Fisher to compute a $0 . 5 \%$ -sparse FISH Mask for parameter-efficient transfer learning, we observe that both methods achieve near-identical performance with an average validation-set GLUE score of 82.5 in both cases. Since computing the empirical Fisher can be more computationally efficient, we used the empirical Fisher for all experiments.
+
+# 4.4.2 Sample Ablation
+
+We also ablate the number of samples, $N$ , used to compute the FISH Mask to study if more samples are beneficial. The results for parameter-efficient transfer learning on GLUE are shown in fig. 2, right. At a sample count of 0, the FISH Mask is equivalent to the Random Mask baseline presented in section 4.1 in which parameters to update are selected at random instead of informed by the Fisher information. We observe that FISH Mask performance on the GLUE validation set is surprisingly stable across many values of samples, with just 32 samples needed to achieve the highest-possible performance. These suggest that using the approximate Fisher information is a data-efficient approach of computing parameter importance, and we therefore ran all experiments with a sample count $N = 1 0 2 4$ , except in distributed training we use $N = 2 5 6$ for efficiency.
+
+# 5 Conclusion
+
+In this work, we proposed FISH Mask training as a novel method for pre-computing fixed sparse masks of a model’s parameters to update over many subsequent iterations. The FISH Mask estimates the importance of each of a model’s parameters by first approximating the Fisher information of each parameter and then selecting the $k$ parameters with the largest Fisher information to include in the mask. We demonstrate the usefulness of FISH Mask training in several settings, including parameter-efficient transfer learning, distributed training, and reducing storage requirements of model checkpoints. In future work, we hope to explore methods for improving the performance of FISH Mask training at lower mask sparsity levels, possibly by considering other measures of parameter importance. We also hope to further demonstrate the efficacy of FISH Mask in real-world settings where the benefits of sparse parameter updating are even more pronounced, such as in Federated Learning. The integration of FISH Masks across tasks and sharing amongst practitioners could also be a useful line of inquiry, as recent frameworks such as AdapterHub [39] have enabled for Adapter modules [19].
+
+# Acknowledgments and Disclosure of Funding
+
+We thank Yoon Kim, Michael Matena, and Demi Guo for helpful discussions.
+
+References   
+[1] Alessandro Achille, Giovanni Paolini, and Stefano Soatto. Where is the information in a deep neural network? arXiv preprint arXiv:1905.12213, 2019.   
+[2] Alham Fikri Aji and Kenneth Heafield. Sparse communication for distributed gradient descent. arXiv preprint arXiv:1704.05021, 2017.   
+[3] Zeyuan Allen-Zhu, Yuanzhi Li, and Yingyu Liang. Learning and generalization in overparameterized neural networks, going beyond two layers. CoRR, abs/1811.04918, 2018. URL http://arxiv.org/abs/1811.04918.   
+[4] SI Amari. Neural learning in structured parameter spaces-natural riemannian gradient. Advances in neural information processing systems, pages 127–133, 1997.   
+[5] Ankur Bapna, Naveen Arivazhagan, and Orhan Firat. Simple, scalable adaptation for neural machine translation. arXiv preprint arXiv:1909.08478, 2019.   
+[6] Elad Ben-Zaken, Shauli Ravfogel, and Yoav Goldberg. BitFit: Simple parameter-efficient fine-tuning for transformer-based masked language models. 2021.   
+[7] Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. CoRR, abs/2005.14165, 2020. URL https://arxiv.org/abs/2005.14165.   
+[8] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey E. Hinton. A simple framework for contrastive learning of visual representations. CoRR, abs/2002.05709, 2020. URL https: //arxiv.org/abs/2002.05709.   
+[9] Ting Chen, Simon Kornblith, Kevin Swersky, Mohammad Norouzi, and Geoffrey E. Hinton. Big self-supervised models are strong semi-supervised learners. CoRR, abs/2006.10029, 2020. URL https://arxiv.org/abs/2006.10029.   
+[10] Elliot J. Crowley, Jack Turner, Amos Storkey, and Michael O’Boyle. Pruning neural networks: is it time to nip it in the bud? 2018.   
+[11] J. Dean, G. Corrado, Rajat Monga, Kai Chen, M. Devin, Quoc V. Le, Mark Z. Mao, Marc’Aurelio Ranzato, A. Senior, P. Tucker, K. Yang, and A. Ng. Large scale distributed deep networks. In NIPS, 2012.   
+[12] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171–4186, Minneapolis, Minnesota, June 2019. Association for Computational Linguistics. doi: 10.18653/v1/N19-1423. URL https://www.aclweb.org/anthology/N19-1423.   
+[13] Nikoli Dryden, Tim Moon, Sam Ade Jacobs, and Brian Van Essen. Communication quantization for data-parallel training of deep neural networks. In 2nd Workshop on Machine Learning in HPC Environments (MLHPC), 2016.   
+[14] Ronald A Fisher. On the mathematical foundations of theoretical statistics. Philosophical Transactions of the Royal Society of London. Series A, Containing Papers of a Mathematical or Physical Character, 222(594-604):309–368, 1922.   
+[15] Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. arXiv preprint arXiv:1803.03635, 2018.   
+[16] Demi Guo, Alexander M. Rush, and Yoon Kim. Parameter-efficient transfer learning with diff pruning. CoRR, abs/2012.07463, 2020. URL https://arxiv.org/abs/2012.07463.   
+[17] Moritz Hardt, Ben Recht, and Yoram Singer. Train faster, generalize better: Stability of stochastic gradient descent. In International Conference on Machine Learning, 2016.   
+[18] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CoRR, abs/1512.03385, 2015. URL http://arxiv.org/abs/1512.03385.   
+[19] Neil Houlsby, Andrei Giurgiu, Stanislaw Jastrzebski, Bruna Morrone, Quentin de Laroussilhe, Andrea Gesmundo, Mona Attariyan, and Sylvain Gelly. Parameter-efficient transfer learning for NLP. CoRR, abs/1902.00751, 2019. URL http://arxiv.org/abs/1902.00751.   
+[20] Jeremy Howard and Sebastian Ruder. Universal language model fine-tuning for text classification. CoRR, abs/1801.06146, 2018. URL http://arxiv.org/abs/1801.06146.   
+[21] James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, 114(13), 2017.   
+[22] Jakub Konecnˇ y, H Brendan McMahan, Daniel Ramage, and Peter Richtárik. Federated optimiza- \` tion: Distributed machine learning for on-device intelligence. arXiv preprint arXiv:1610.02527, 2016.   
+[23] Jakub Konecnˇ y, H Brendan McMahan, Felix X Yu, Peter Richtárik, Ananda Theertha Suresh, \` and Dave Bacon. Federated learning: Strategies for improving communication efficiency. arXiv preprint arXiv:1610.05492, 2016.   
+[24] Simon Kornblith, Jonathon Shlens, and Quoc V Le. Do better imagenet models transfer better? In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2019.   
+[25] A. Krizhevsky. Learning multiple layers of features from tiny images. 2009.   
+[26] Frederik Kunstner, Lukas Balles, and Philipp Hennig. Limitations of the empirical fisher approximation for natural gradient descent. arXiv preprint arXiv:1905.12558, 2019.   
+[27] Yann A LeCun, Léon Bottou, Genevieve B Orr, and Klaus-Robert Müller. Efficient backprop. In Neural networks: Tricks of the trade, pages 9–48. Springer, 2012.   
+[28] Brian Lester, Rami Al-Rfou, and Noah Constant. The power of scale for parameter-efficient prompt tuning. arXiv preprint arXiv:2104.08691, 2021.   
+[29] Xiang Lisa Li and Percy Liang. Prefix-tuning: Optimizing continuous prompts for generation. arXiv preprint arXiv:2101.00190, 2021.   
+[30] Liyang Liu, Shilong Zhang, Zhanghui Kuang, Aojun Zhou, Jing-Hao Xue, Xinjiang Wang, Yimin Chen, Wenming Yang, Qingmin Liao, and Wayne Zhang. Group fisher pruning for practical network compression. In Marina Meila and Tong Zhang, editors, Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pages 7021–7032. PMLR, 18–24 Jul 2021. URL https://proceedings. mlr.press/v139/liu21ab.html.   
+[31] Christos Louizos, Max Welling, and Diederik P. Kingma. Learning sparse neural networks through l_0 regularization. arXiv preprint arXiv:1712.01312, 2017.   
+[32] Rabeeh Karimi Mahabadi, James Henderson, and Sebastian Ruder. Compacter: Efficient low-rank hypercomplex adapter layers, 2021.   
+[33] Rabeeh Karimi Mahabadi, Sebastian Ruder, Mostafa Dehghani, and James Henderson. Parameter-efficient multi-task fine-tuning for transformers via shared hypernetworks, 2021.
+
+[34] James Martens. New insights and perspectives on the natural gradient method. arXiv preprint arXiv:1412.1193, 2014.
+
+[35] H. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Agüera y Arcas. Communication-efficient learning of deep networks from decentralized data, 2017.
+
+[36] Sinno Jialin Pan and Qiang Yang. A survey on transfer learning. IEEE Transactions on knowledge and data engineering, 22(10):1345–1359, 2009.
+
+[37] Razvan Pascanu and Yoshua Bengio. Revisiting natural gradient for deep networks. arXiv preprint arXiv:1301.3584, 2013.
+
+[38] Matthew E. Peters, Sebastian Ruder, and Noah A. Smith. To tune or not to tune? adapting pretrained representations to diverse tasks. arXiv preprint arXiv:1903.05987, 2019.
+
+[39] Jonas Pfeiffer, Andreas Rücklé, Clifton Poth, Aishwarya Kamath, Ivan Vulic, Sebastian Ruder, Kyunghyun Cho, and Iryna Gurevych. Adapterhub: A framework for adapting transformers. CoRR, abs/2007.07779, 2020. URL https://arxiv.org/abs/2007.07779.
+
+[40] Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21, 2020.
+
+[41] Sylvestre-Alvise Rebuffi, Hakan Bilen, and Andrea Vedaldi. Learning multiple visual domains with residual adapters. arXiv preprint arXiv:1705.08045, 2017.
+
+[42] Benjamin Recht, Christopher Re, Stephen Wright, and Feng Niu. Hogwild!: A lock-free approach to parallelizing stochastic gradient descent. In J. Shawe-Taylor, R. Zemel, P. Bartlett, F. Pereira, and K. Q. Weinberger, editors, Advances in Neural Information Processing Systems, volume 24. Curran Associates, Inc., 2011. URL https://proceedings.neurips.cc/ paper/2011/file/218a0aefd1d1a4be65601cc6ddc1520e-Paper.pdf.
+
+[43] Sidak Pal Singh and Dan Alistarh. Woodfisher: Efficient second-order approximation for neural network compression. Advances in Neural Information Processing Systems, 2020.
+
+[44] Nikko Strom. Scalable distributed dnn training using commodity gpu cloud computing. In Sixteenth Annual Conference of the International Speech Communication Association, 2015.
+
+[45] Zeyi Tao and Qun Li. esgd: Communication efficient distributed deep learning on the edge. In {USENIX} Workshop on Hot Topics in Edge Computing (HotEdge 18), 2018.
+
+[46] Lucas Theis, Iryna Korshunova, Alykhan Tejani, and Ferenc Huszár. Faster gaze prediction with dense networks and fisher pruning. CoRR, abs/1801.05787, 2018. URL http://arxiv. org/abs/1801.05787.
+
+[47] Lucas Theis, Iryna Korshunova, Alykhan Tejani, and Ferenc Huszár. Faster gaze prediction with dense networks and fisher pruning. arXiv preprint arXiv:1801.05787, 2018.
+
+[48] Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. GLUE: A multi-task benchmark and analysis platform for natural language understanding. CoRR, abs/1804.07461, 2018. URL http://arxiv.org/abs/1804.07461.
+
+[49] Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, Rémi Louf, Morgan Funtowicz, et al. Huggingface’s transformers: State-of-the-art natural language processing. arXiv preprint arXiv:1910.03771, 2019.
+
+[50] Mengjie Zhao, Tao Lin, Martin Jaggi, and Hinrich Schütze. Masking as an efficient alternative to finetuning for pretrained language models. CoRR, abs/2004.12406, 2020. URL https: //arxiv.org/abs/2004.12406.

parse/train/Uwh-v1HSw-x/Uwh-v1HSw-x_content_list.json

@@ -0,0 +1,1156 @@
+[
+    {
+        "type": "text",
+        "text": "Training Neural Networks with Fixed Sparse Masks ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            122,
+            812,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yi-Lin Sung∗ UNC Chapel Hill ylsung@cs.unc.edu ",
+        "bbox": [
+            230,
+            200,
+            379,
+            243
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Varun Nair∗ Duke University vn40@duke.edu ",
+        "bbox": [
+            442,
+            202,
+            555,
+            242
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Colin Raffel UNC Chapel Hill craffel@gmail.com ",
+        "bbox": [
+            619,
+            200,
+            766,
+            243
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            279,
+            535,
+            295
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "During typical gradient-based training of deep neural networks, all of the model’s parameters are updated at each iteration. Recent work has shown that it is possible to update only a small subset of the model’s parameters during training, which can alleviate storage and communication requirements. In this paper, we show that it is possible to induce a fixed sparse mask on the model’s parameters that selects a subset to update over many iterations. Our method constructs the mask out of the $k$ parameters with the largest Fisher information as a simple approximation as to which parameters are most important for the task at hand. In experiments on parameter-efficient transfer learning and distributed training, we show that our approach matches or exceeds the performance of other methods for training with sparse updates while being more efficient in terms of memory usage and communication costs. We release our code publicly to promote further applications of our approach.2 ",
+        "bbox": [
+            232,
+            310,
+            764,
+            491
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            517,
+            312,
+            535
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Stochastic gradient descent (SGD) is a vital component of the modern pipeline for training deep neural networks. Along with the back-propagation algorithm, gradient descent allows for the efficient minimization of a loss function by gradually updating a model’s parameters. SGD minimizes the loss over a small random subset of the dataset at each training iteration, which allows training over large datasets. In practice, minimizing a large neural network’s training loss using SGD often results in models that generalize well to new data [3, 17, 27], making SGD an invaluable tool. ",
+        "bbox": [
+            174,
+            550,
+            825,
+            633
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While effective, standard SGD requires that all model parameters are updated at every iteration of training. As a result, communicating changes to the model requires communicating the updated value of every parameter. Since modern neural networks often have millions or billions of parameters [9, 7, 40], this communication can become excessively expensive. A concrete example of the negative impacts of these costs arises in the setting of transfer learning. In transfer learning, a model’s parameters are initialized from an existing pre-trained model before being fine-tuned (i.e. trained) on a task of interest. Pre-trained models can be fine-tuned a huge number of times – for example, the Hugging Face model repository3 has thousands of fine-tuned variants of the BERT model [12]. Each of these fine-tuned variants requires a unique copy of the model’s parameters, each of which takes up around 500MB of disk space. Relatedly, in distributed training [11] and federated learning [35], workers compute updates for a centralized model in parallel on different subsets of data. After a certain number of updates, the workers each communicate the newly-computed parameter values back to the centralized model. The communication step can cause a significant amount of overhead (particularly when the model is large) since the workers must communicate the updated values of all parameters when using standard SGD. ",
+        "bbox": [
+            173,
+            640,
+            826,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/1bf43c1ff9e93dadfc033c4f837c48bdac97e690153e19a2e3f7d3022ee485ee.jpg",
+        "image_caption": [
+            "Figure 1: Diagram comparing our proposed method to standard SGD. In traditional gradient-based training (left), all of a model’s parameters are updated at every iteration. We propose FISH Mask, a method for precomputing a sparse subset of parameters to update over many subsequent training iterations. To construct the FISH Mask, we find the $k$ parameters with the largest Fisher information (right, top). Then, we train the model with traditional gradient descent, but only update those parameters chosen by the mask (right, bottom). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            271,
+            88,
+            728,
+            228
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "These issues could be mitigated if it was possible to only update a few parameters during training while still maintaining performance close to that of training all parameters. This has led to various work on parameter-efficient training of neural networks. For example, Adapters [19, 41, 5] introduce additional parameters into a pre-trained model in the form of small task-specific modules that are fine-tuned while the rest of the model’s parameters are kept fixed. Diff Pruning [16] and BitFit [6] demonstrate that it is possible to fine-tune a model while only updating a small subset of the existing parameters. In distributed and federated learning settings, Aji and Heafield [2] and Konecnˇ y\\` et al. [23] have shown that it is possible for each worker to only update a sparse subset of a model’s parameters, thereby reducing communication costs. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            472
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Existing methods for training with sparse updates typically work in one of three ways: they either add parameters to the model (Adapters), choose a hand-defined and heuristically-motivated subset of parameters (BitFit), or allow the subset of parameters to change over the course of training (Diff Pruning and methods in distributed and federated training). In this paper, we argue for pre-computing a sparse subset of existing parameters to update and keeping the subset fixed over many iterations of training. This approach yields various benefits: First, by updating a subset of existing parameters instead of adding parameters (as is done in Adapters), we avoid any increase in the total size of the model. Second, by avoiding hand-defining the mask, we can ensure that our procedure is modelagnostic. Third, by pre-computing a mask, we avoid the computational and memory overhead that are apparent when updating the mask over the course of training. It also allows workers in the distributed training setup to operate on strictly complementary subsets of parameters. Finally, keeping the mask fixed over many iterations, we can ensure that only a specific fixed number of parameters are updated. We are not aware of any existing techniques that satisfy these desiderata. ",
+        "bbox": [
+            174,
+            478,
+            825,
+            659
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Motivated by these benefits, we introduce a new method for pre-computing fixed sparse masks. Our approach first estimates the importance of each parameter using an empirical approximation of its Fisher information. Then, we construct the mask by choosing the $k$ parameters with the largest Fisher information. The resulting mask, which we deem a “FISH (Fisher-Induced Sparse uncHanging) mask”, can be re-used for many subsequent training iterations. We demonstrate the effectiveness of using a FISH Mask in a wide variety of settings, including parameter-efficient transfer learning, distributed training with long delays across workers, and reducing checkpoint size. Broadly speaking, FISH Mask training can dramatically reduce storage and communication requirements, while sacrificing minimal performance compared to standard gradient descent and outperforming relevant prior methods for training with sparse updates. ",
+        "bbox": [
+            174,
+            664,
+            825,
+            803
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 The Fisher-Induced Sparse uncHanging (FISH) Mask ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            823,
+            653,
+            840
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main contribution of this paper is a method for pre-computing a sparse subset of a model’s parameters to update over many subsequent training iterations. To construct such a subset, we use an approximation of each parameter’s Fisher information as a signal of how important the parameter is for a given task. We refer to the resulting mask (i.e. binary array indicating which parameters are included in the subset) as a FISH (Fisher-Induced Sparse uncHanging) mask. In this section, we provide the necessary background and detail the steps necessary for computing a FISH Mask. This process is diagrammed in fig. 1. ",
+        "bbox": [
+            176,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Fisher Information ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            148,
+            346,
+            164
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to select the subset of parameters that are (in some sense) the most important to update. One way to measure a parameter’s importance is to consider how much changing the parameter will change the model’s output. We denote $p _ { \\theta } ( y | x )$ as the output distribution over $y$ produced by a model with parameter vector $\\theta \\in \\mathbb { R } ^ { | \\theta | }$ given input $x$ . One way to measure how much a change in parameters would change a model’s prediction would be to compute $\\mathrm { D } _ { \\mathrm { K L } } ( p _ { \\boldsymbol { \\theta } } ( \\boldsymbol { y } | \\boldsymbol { x } ) | | p _ { \\boldsymbol { \\theta } + \\delta } ( \\boldsymbol { y } | \\boldsymbol { x } ) )$ , where $\\delta \\in \\mathbb { R } ^ { | \\theta | }$ is a small perturbation. It can be shown [34, 37] that as $\\delta  0$ , to second order, ",
+        "bbox": [
+            173,
+            174,
+            825,
+            262
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3f5279dc88f6a5994131d6c85f7e0faa85a3ddf79f1ad8353e6a36bab7273e56.jpg",
+        "text": "$$\n\\mathbb { E } _ { x } \\mathrm { D } _ { \\mathrm { K L } } \\big ( p _ { \\theta } ( y | x ) \\ | | \\ p _ { \\theta + \\delta } ( y | x ) \\big ) = \\delta ^ { \\mathrm { T } } F _ { \\theta } \\delta + O ( \\delta ^ { 3 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            267,
+            665,
+            286
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $F _ { \\theta } \\in \\mathbb { R } ^ { | \\theta | \\times | \\theta | }$ is the Fisher information matrix [14, 4], defined as ",
+        "bbox": [
+            169,
+            291,
+            647,
+            308
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d2f9f7279abb35adb23dcd45682df5f0da6d583b0d618f6726a1aaaf465ba3de.jpg",
+        "text": "$$\nF _ { \\theta } = \\mathbb { E } _ { x \\sim p ( x ) } \\left[ \\mathbb { E } _ { y \\sim p _ { \\theta } ( y \\vert x ) } \\nabla _ { \\theta } \\log p _ { \\theta } ( y \\vert x ) \\nabla _ { \\theta } \\log p _ { \\theta } ( y \\vert x ) ^ { \\mathrm { T } } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            313,
+            692,
+            332
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given this relation, it can be seen that the Fisher information matrix is closely connected to how much each parameter affects the model’s predictions. Indeed, this has led the Fisher information matrix to be widely used in modern machine learning, e.g. as a measure of parameter importance [21], as a preconditioner in gradient descent [4, 37, 34], as a way to measure the amount of “information” in each parameter of a neural network [1], or as a way to decide which parameters to prune when performing model compression [43, 10, 47]. ",
+        "bbox": [
+            173,
+            335,
+            826,
+            420
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "When applied to large neural networks, the $\\left| \\theta \\right| \\times \\left| \\theta \\right|$ size of the Fisher information matrix makes it intractable to compute. Prior work therefore frequently approximates $F _ { \\theta }$ as a diagonal matrix, or equivalently, as a vector in $\\mathbb { R } ^ { | \\theta | }$ . Separately, when training machine learning models we seldom have the ability to draw samples $x \\sim p ( x )$ ; instead, we are given a finite training set of such samples. Furthermore, it is rarely necessary to compute the expectation over $x$ in eq. (2) over the full training set; instead, it can often be well-approximated over $N$ samples $x _ { 1 } , \\ldots , x _ { N }$ . These constraints result in the following common approximation: ",
+        "bbox": [
+            173,
+            425,
+            825,
+            525
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/21955763df68f06069859fc1c11db6c450f4a7de147dd4b828dd917478deb37f.jpg",
+        "text": "$$\n\\hat { F _ { \\theta } } = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\mathbb { E } _ { y \\sim p _ { \\theta } ( y | x _ { i } ) } ( \\nabla _ { \\theta } \\log p _ { \\theta } ( y | x _ { i } ) ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            530,
+            643,
+            574
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { F } _ { \\theta } \\in \\mathbb { R } ^ { | \\theta | }$ . This approximation also has an intuitive interpretation: A given entry in $\\hat { F } _ { \\theta }$ relates to the average of the square gradient of the model’s output with respect to a given parameter. If a given parameter heavily affects the model’s output, then its corresponding entry in $\\hat { F } _ { \\theta }$ will be large, so we can reasonably treat $\\hat { F } _ { \\theta }$ as an approximation of the importance of each parameter. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            642
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that both eq. (2) and eq. (3) include an expectation over $y \\sim p _ { \\theta } ( y | x )$ . When the number of classes is small, this expectation can be computed exactly. For tasks with many possible classes, it is common to approximate the expectation with a few samples from $p _ { \\theta } ( y | x )$ . In supervised learning settings, we have access to the ground-truth label $y _ { i }$ for each sample $x _ { i }$ in our training set. This leads to the possibility of replacing $\\mathbb { E } _ { y \\sim p _ { \\theta } ( y | x _ { i } ) } ( \\nabla _ { \\theta } \\log p _ { \\theta } ( y | x _ { i } ) ) ^ { 2 }$ in eq. (3) with $( \\nabla _ { \\theta } \\mathbf { \\bar { l } } _ { 0 } \\mathrm { { g } } p _ { \\theta } ( y _ { i } | x _ { i } ) ) ^ { 2 }$ Performing this approximation is referred to as the “empirical Fisher”. It has been shown that using the empirical Fisher can lead to degenerate behavior when used as a preconditioner in an optimizer [34, 26]. Since our use of the Fisher information is largely based on a heuristically-motivated notion of parameter importance, we experimented with both the empirical and standard (eq. (3)) Fisher approximations and found that they produced similar performance. Furthermore, the Empirical Fisher is faster to compute than the standard Fisher as long as more than one sample is used to approximate the expectation $\\mathbb { E } _ { y \\sim p _ { \\theta } ( y | x _ { i } ) }$ . We discuss this further in section 4.4.1. ",
+        "bbox": [
+            173,
+            647,
+            825,
+            815
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Computing Fixed Sparse Masks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            830,
+            434,
+            845
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recall that our goal is to select a subset of parameters (or, equivalently, a sparse mask over parameters) to update over many iterations of training while keeping the remainder of the parameters fixed. Having established the Fisher information as a useful tool for estimating the importance of a given parameter, we therefore first compute the approximate Fisher information (as described in the previous section) ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "for all of a model’s parameters. Then, to construct the FISH Mask, we simply choose the $k$ parameters with the largest Fisher information, where $k$ is set according to the desired mask sparsity level.4 Specifically, a FISH Mask comprises the parameters $\\{ \\theta _ { i } \\mid \\hat { F } _ { \\theta _ { i } } \\geq \\mathsf { s o r t } ( \\hat { F } _ { \\theta } ) _ { k } \\}$ . Computing the FISH Mask is cheap because $\\hat { F } _ { \\theta }$ can be computed efficiently using backpropagation, and (as we will show in section 4.4.2) we can obtain a reliable mask for relatively small values of $N$ . Further, the fact that we re-use the mask for many iterations prevents us from having to compute $\\hat { F } _ { \\theta }$ frequently. As we will show in section 4, we find that this simple procedure is sufficient to produce a mask that can be reused for many iterations (over 100,000 iterations in some cases) in a wide variety of settings without sacrificing substantial performance compared to standard gradient-based training. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            223
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that in some applications of transfer learning, a new linear classifier layer must be added to the model to make it applicable to the downstream task. Since the FISH Mask depends on $p _ { \\theta } ( y | x )$ and is computed before training begins, this means that we must compute the FISH Mask using the randomly-initialized classifier before any training has begun. We find that computing the Fisher information through the randomly-initialized classifier layer still provides a good signal of parameter importance. When applying FISH Mask in transfer learning settings where a new classifier layer is added, we always include the parameters of the classifier in the mask. ",
+        "bbox": [
+            174,
+            229,
+            825,
+            325
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            344,
+            321,
+            362
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our approach bears similarity and takes inspiration from existing approaches for parameter-efficient transfer learning and distributed training of machine learning models. In this section, we outline related methods, some of which we will compare to directly in section 4. We also briefly describe how our work is related to and differs from work in network pruning. ",
+        "bbox": [
+            174,
+            377,
+            825,
+            433
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Parameter-Efficient Transfer Learning ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            449,
+            483,
+            463
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Transfer learning [36], where a model is initialized from a pre-trained checkpoint before being finetuned on a related downstream task, can dramatically improve performance and speed up convergence on the downstream task [12, 8, 40]. Standard practice is to update all of the model’s parameters during fine-tuning, though in some cases reasonable performance can be attained by only fine-tuning the output layer of the model [20, 8, 38]. Training only the output layer has the benefit that adapting a given pre-trained model to a downstream task only requires adding a relatively small number of new parameters, but typically results in worse performance compared to training the full model [38, 24]. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            571
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Various methods have been proposed that endeavor to match the performance of fine-tuning the full model while only updating or adding a small amount of parameters. Adapters [19, 41, 5] are small subnetworks that are added between a pre-trained neural networks layers. Various works [19, 33, 32] have shown that, when appropriately designed, updating only the parameters in the adapters and the output layer can approach the performance of fine-tuning all parameters. For example, Houlsby et al. [19] add on average $3 . 6 \\%$ more parameters to adapt a pre-trained BERT model [12] to tasks in the GLUE benchmark [48]. Concurrent work by Mahabadi et al. [33] improves the efficiency of Adapters by generating the weights of task-specific adapters via a hypernetwork. A second concurrent approach by Mahabadi et al. [32] introduces COMPACTER, which utilizes matrix decomposition and low-rank parameterization for the adapters’ weights. COMPACTER is shown to achieve the same performance as standard fine-tuning of the T5 models [40] while only adding $0 . 0 4 7 \\%$ as many parameters as the original model. Finally, very recent work has shown that it is possible to train language models to perform a task by only optimizing the parameters of a \"prompt\" that is injected into the input of the model’s layers [29, 28]. This can yield extremely parameter-efficient results (as low as $0 . 0 1 \\%$ task-specific parameters [28]) but this class of methods is only applicable to next-step-prediction language models. The main drawback of all Adapter-style methods is that they increase the parameter count and computational cost of the model. This makes them inapplicable to the distributed training and efficient checkpointing settings consider in this paper. We therefore only compare directly to other methods that do not add any parameters. ",
+        "bbox": [
+            174,
+            578,
+            825,
+            840
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "More closely related to our approach are methods for choosing a small subset of the model’s existing parameters to update. In an extreme case, Zhao et al. [50] find a sparse mask to multiply against pre-trained parameters (which are not otherwise updated). That is, instead of fine-tuning the models, a binary mask is learned that marks which parameters should be zeroed out. The resulting performance degrades heavily when the mask is made very sparse, suggesting that it is likely beneficial to update parameters. More recently, Guo et al. [16] propose “Diff Pruning”, where a sparse binary mask is found over the course of training that denotes which parameters should be updated or fixed at the value from the pre-trained model. Mask sparsity in the binary mask is enforced through a smooth approximation of the $L _ { 0 }$ norm introduced by Louizos et al. [31]. Guo et al. [16] also show improved performance by imposing a structure on the mask according to which parameters correspond to a particular weight matrix or bias vector. Ultimately, Diff Pruning is shown to both be more parameterefficient and outperform Adapters when applied to fine-tuning BERT on the GLUE benchmark. However, using Diff Pruning requires significantly more memory during training in order to store and update the mask. Another recent result by Ben-Zaken et al. [6] demonstrated that simply updating the bias parameters in BERT can attain competitive performance with Diff Pruning. While this provides a simple and strong baseline, it is not universally applicable – for example, the pre-trained T5 model [40] does not have any bias vectors. In section 4, we show that using a FISH Mask outperforms all of these approaches in parameter-efficient fine-tuning of BERT on GLUE. ",
+        "bbox": [
+            176,
+            847,
+            821,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            313
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Distributed Training ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            352,
+            356,
+            367
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As models and datasets grow, it becomes inefficient or impossible to train a model on a single machine. This has motivated the need for distributed training strategies where computation for training a model is shared across many machines (called workers) [11]. A major consideration in distributed training are communication costs, since workers need to regularly communicate parameter updates with one another. To minimize communication costs, workers can compute multiple updates on their copy of the model before communicating their changes, but this gives rise to the “stale gradient” problem where workers are operating on an out-of-date copy of the model. The standard and straightforward approach to dealing with stale gradients it to simply apply updates in the “wrong” order, which can be effective in practice [11, 42]. An orthogonal approach to reducing communication costs is to have workers only update a small subset of the model’s parameters [2, 13, 44, 45]. For example, Aji and Heafield [2] simply have workers communicate only those updates corresponding to the gradients with top- $k$ largest magnitude at each step. This bears a similar motivation to FISH Mask, but results in a “mask” that changes at every iteration and therefore requires workers communicate after each update. In contrast, pre-computing a FISH Mask allows workers to perform multiple iterations before communicating their updates, thereby further reducing communication costs. ",
+        "bbox": [
+            174,
+            387,
+            825,
+            594
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "An extreme variant of distributed training is federated learning [22, 35]. In federated learning, asynchronous workers perform many updates on private data before communicating the changes back to a centralized model. The training involves one server and multiple clients, and the server model’s gradient is the combination of the workers’ gradients. As with any form of asynchronous training, communication costs and stale gradients are significant issues. McMahan et al. [35] demonstrated that averaging the updates computed by individual workers is an effective approach to dealing with stale gradients and Konecnˇ y et al. \\` [23] investigated techniques for significantly reducing communication costs. Our method is complementary to the techniques for reducing communication proposed by Konecnˇ y et al. [23].\\` ",
+        "bbox": [
+            174,
+            601,
+            825,
+            726
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Network Pruning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            765,
+            334,
+            780
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Past work in network pruning has also explored techniques for sparsifying neural networks (i.e. zeroing out many parameters for compression purposes) while sacrificing minimal performance. Most relevant to our work, Theis et al. [46] propose utilizing the Fisher to prune and decrease the overall number of parameters for gaze prediction, and Liu et al. [30] also use the Fisher to discover groups of parameters to prune from common backbone architectures. Critically, these works differ from our work in that we do not train neural networks with sparse weights. Instead, we focus on using the Fisher to inform the selection of a fixed sparse subset of weights in a non-sparse network to update over the course of training. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            312,
+            107
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the efficacy of the FISH Mask in three settings: parameter-efficient transfer learning, distributed training, and training with efficient checkpointing. For parameter-efficient transfer learning, we demonstrate that our approach matches the performance of standard gradient-based training on the GLUE benchmark [48] while updating only $0 . 5 \\%$ of the model’s parameters per task. For distributed training, we evaluate FISH Mask training for both transfer learning on GLUE and training from scratch on CIFAR-10 [25]. In both settings, we find that we can dramatically reduce communication without sacrificing significant performance, though from-scratch training on CIFAR-10 requires a higher mask sparsity level than fine-tuning on GLUE. Finally, we demonstrate a novel application of training with sparse updates: Minimizing the size of checkpoints over training. We show that using a FISH Mask while training on CIFAR-10 with a mask sparsity level of $10 \\%$ can shrink checkpoint size on disk by a factor of 5 while sacrificing only a small amount of accuracy. Throughout our experiments, we report results with varying mask sparsity to get a sense of the savings induced by the FISH Mask. For ease of comparison, we report mask sparsity in terms of the total percentage of parameters that are updated. This percentage can be converted to a value of $k$ used for the top- $k$ operation when constructing the mask simply by multiplying it against the total number of parameters in the model. ",
+        "bbox": [
+            174,
+            119,
+            825,
+            342
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also include ablation studies to measure the impact of the number of samples used to estimate the Fisher information as well as the choice of true or empirical Fisher. All experiments for GLUE are run with the BERTLARGE variant of BERT, which contains 16 attention heads, 24 layers, and 330 million parameters in total [12], and most experiments are run on a RTX 3090 GPU. For experiments on CIFAR-10, we use a ResNet-34 [18] with various optimizations for fast convergence.5 We report the average performance across 5 seeds for all experiments. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            430
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Parameter-Efficient Transfer Learning ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            445,
+            483,
+            462
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In parameter-efficient transfer learning, the goal is to fine-tune a pre-trained model while updating as few parameters as possible. We focus on fine-tuning $\\mathbf { B E R T _ { L A R G E } }$ on the GLUE benchmark [48], which is the primary setting used for evaluation in prior work. For all experiments, we fine-tune for 7 epochs and perform a hyper-parameter search across learning rate $\\in \\{ 1 \\stackrel { \\cdot } { \\times } 1 0 ^ { - 4 } , 5 \\times 1 0 ^ { - 5 } , 1 \\times 1 0 ^ { - 5 } \\}$ and batch si $\\mathsf { z e } \\in \\{ 8 , 1 6 \\}$ for each GLUE task. We find the learning rate of $5 \\times 1 0 ^ { - 5 }$ and batch size of 16 to be effective for most tasks, with the exception of batch $\\mathrm { s i z e } = 8$ used for RTE. Additional hyper-parameters, such as choice of optimizer, sequence length, and others, follow from the default configuration for BERTLARGE presented in the Hugging Face library [49]. Test set results are reported by submitting to the GLUE benchmark using the final model checkpoint following a hyper-parameter search on validation results, unless otherwise noted. ",
+        "bbox": [
+            174,
+            472,
+            825,
+            609
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines We compare GLUE task performance of the FISH Mask to several other baselines and methods focused on parameter-efficient transfer learning. In Dense Fine-tuning, we fine-tune all parameters of a pre-trained model, as is typical in standard transfer learning. In the Random Mask baseline, we randomly select and fix $k$ parameters to update at the start of training. To compare to prior work, we reproduce Bit-Fit [6], in which only the bias parameters of the BERT model are updated across training. Our reproduction follows the original paper and performs a hyper-parameter search with learning rates in the $[ 1 \\times 1 0 ^ { - 3 } , 1 \\times 1 0 ^ { - 4 } ]$ range. We also reproduce results from Diff Pruning [16], which updates the sparse mask over the course of training. Our reproduction of Diff Pruning at $0 . 5 \\%$ mask sparsity follows the paper’s code-base6 and training settings, and reports the GLUE test set results using the best validation checkpoint. Due to restrictions on the number of permissible submissions to the GLUE test server, we are only able to report results with a mask sparsity of $0 . 5 \\%$ for those methods where we can control the mask sparsity level. We therefore include additional validation set results for varying mask sparsity levels when using a FISH Mask. ",
+        "bbox": [
+            173,
+            625,
+            826,
+            804
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results Our results on parameter-efficient transfer learning with the FISH Mask can be seen in table 1. FISH Mask training results in effectively the same performance $( 8 2 . 6 \\% )$ as standard “dense” fine-tuning $( 8 2 . 5 \\% )$ , despite updating just $0 . 5 \\%$ of BERTLARGE parameters. The Random Mask baseline achieves a significantly lower average GLUE score, which demonstrates the value of using ",
+        "bbox": [
+            174,
+            819,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/ece171cdc4649c87d3444f15ad2f38556040960ce3068dd4cddff022696ea22c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Updated Params/Task</td><td>QNLI</td><td>SST-2</td><td>MNLIm</td><td>MNLImm</td><td>CoLA</td><td>MRPC</td><td>STS-B</td><td>RTE</td><td>QQP</td><td>AVG</td></tr><tr><td>Dense Fine-tuning</td><td>100%</td><td>93.4</td><td>94.9</td><td>87.0</td><td>86.1</td><td>61.0</td><td>86.6</td><td>86.5</td><td>70.9</td><td>80.5</td><td>82.5</td></tr><tr><td>Random Mask</td><td>0.50%</td><td>89.8</td><td>93.4</td><td>83.7</td><td>84.0</td><td>43.2</td><td>77.8</td><td>87.7</td><td>61.3</td><td>77.2</td><td>76.8</td></tr><tr><td>Bit-Fit [6]</td><td>0.08%</td><td>90.4</td><td>94.5</td><td>85.0</td><td>84.8</td><td>60.3</td><td>86.3</td><td>85.0</td><td>69.6</td><td>78.5</td><td>81.2</td></tr><tr><td>Diff Pruning [16]</td><td>0.50%</td><td>91.9</td><td>93.8</td><td>86.0</td><td>85.5</td><td>61.0</td><td>86.2</td><td>85.6</td><td>67.5</td><td>80.1</td><td>81.5</td></tr><tr><td>FISHMask</td><td>0.08%</td><td>93.3</td><td>94.0</td><td>85.3</td><td>84.9</td><td>56.4</td><td>86.2</td><td>85.7</td><td>70.2</td><td>79.3</td><td>81.3</td></tr><tr><td>FISHMask</td><td>0.50%</td><td>93.1</td><td>94.7</td><td>86.5</td><td>85.9</td><td>61.6</td><td>87.1</td><td>86.5</td><td>71.2</td><td>80.2</td><td>82.6</td></tr></table>",
+        "bbox": [
+            173,
+            88,
+            821,
+            174
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1: GLUE test server evaluation results with BERTLARGE. MRPC and QQP are reported as an average of F1-score and accuracy, and STS-B is reported as an average of Pearson and Spearman correlation. Accuracy is reported for all other tasks. All results are reproduced experimentally. Training with the FISH surpasses (82.6) other methods and equals dense fine-tuning performance (82.5) whilst updating only $0 . 5 \\%$ of model parameters. ",
+        "bbox": [
+            173,
+            188,
+            825,
+            257
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b9bad8752af76a2f149e5f7491ae5a4d3b8240fba3fc407e81321404b595077f.jpg",
+        "image_caption": [
+            "Figure 2: (Left) GLUE validation performance of a randomly selected mask and the FISH Mask at varying levels of mask sparsity. Compared to the densely fine-tuned baseline score of $85 \\%$ , training with the FISH Mask is competitive at $0 . 5 \\%$ mask sparsity. (Right) GLUE validation performance at varying levels of dataset samples used to compute the FISH Mask. Few samples are needed to effectively compute the FISH Mask and obtain good performance. Results in both (Left) and (Right) are averaged over 5 seeds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            272,
+            805,
+            441
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "the Fisher information in selecting parameters to update. Finally, FISH Mask training is competitive with all other parameter-efficient transfer learning approaches; the next-best score of $8 1 . 5 \\%$ is achieved by Diff Pruning [16]. As mentioned in section 3, we do not include a direct comparison to Adapter-based methods since they add parameters to the model, though we note that our method is able to match BERTLARGE’s performance using a significantly lower mask sparsity level $0 . 5 \\%$ vs. $3 . 6 \\%$ ) than the method proposed by Houlsby et al. [19]. ",
+        "bbox": [
+            173,
+            551,
+            825,
+            636
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 shows the change in performance on the GLUE validation set as we change the mask sparsity level for both a random mask and a FISH Mask. We find that the FISH Mask consistently outperforms the random mask baseline and is still strong even at a lower mask sparsity level of $0 . 1 \\%$ . These results demonstrate that the FISH Mask can be a useful tool in mitigating the storage costs of saving many fine-tuned models since it only requires that the updated parameters and their respective indices are saved. ",
+        "bbox": [
+            173,
+            640,
+            825,
+            724
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Distributed Training ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            741,
+            356,
+            756
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Now, we turn to using FISH Mask to reduce communication costs in distributed training settings. We consider the setting where distributed workers compute many subsequent updates to a local copy of the model before transmitting their changes back to a central server. In our experiments, we assume all workers sample data i.i.d. from the same dataset and that all workers compute the same number of updates between each communication step, though our results could carry over to settings where workers use different datasets and varying amounts of updates (e.g. in Federated Learning [35]). ",
+        "bbox": [
+            173,
+            765,
+            825,
+            849
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Let $\\theta$ denote the parameter vector stored on the central server and $\\delta _ { i }$ represent the update computed by worker $i$ . After each update/communication step, the server must transmit the updated $\\theta$ back to all workers. When standard gradient-based training is used, all parameters are updated, so $| \\delta _ { i } | = | \\theta |$ . If there are $M$ workers, the communication costs for normal training are then $M | \\delta _ { i } | = M | \\ddot { \\theta } |$ for workerto-server communication and $M | \\theta |$ for server-to-worker communication, for a total communication cost of $2 M | \\theta |$ . ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Using a sparse mask will effectively reduce the size of each $\\delta _ { i }$ to $k$ . Without loss of generality, we assume that $| \\delta _ { i } |$ is the same across all workers. Furthermore, assuming updates are aggregated on the central server by summing them together, the server can either communicate the full updated parameter vector back to all workers, or the server can communicate all other workers’ updates to a given worker. These two options amount to server-to-worker communication costs of either $M | \\theta |$ or $M ( M - \\underline { { { 1 } } } ) \\lVert \\delta _ { i } \\rVert \\approx M ^ { 2 } | \\dot { \\delta } _ { i } |$ . In general, we expect $M$ to be small and $| \\theta |$ to be large, so we typically have $M ^ { 2 } | \\delta _ { i } | < M | \\theta |$ . Therefore, we can achieve significant communication savings by using sparse updates. For simplicity, we set $M = 2$ in all of our experiments; this makes the savings in communication equal to the mask sparsity level. To apply FISH in distributed training, the central server computes $\\hat { F } _ { \\theta }$ and a single FISH Mask which is shared across all workers. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            266
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Baselines For distributed training experiments, we compare FISH Mask training to three baselines: First, in standard training, we tune all the parameters in a single machine (i.e. standard, nondistributed training). This provides an upper bound on performance for distributed training techniques. Second, in densely-updated distributed training, workers use standard gradient descent to compute updates over all parameters, and all of the worker’s updates are added together on the centralized server. Third, in random mask distributed training, we randomly select a subset of parameters to update for workers. For a fair comparison, we keep the overall training batches the same for all methods, so the training iterations of a worker are half of that of the single-machine baseline. ",
+        "bbox": [
+            174,
+            282,
+            825,
+            393
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Experimental setting In preliminary experiments on the GLUE benchmark (described in appendix A), we found that densely-updated distributed training saw no real degradation in performance even for long communication delays. This suggests that stale gradients could be less of an issue in transfer learning settings. We therefore instead focused on from-scratch training of a ResNet-34 on CIFAR-10. We train the model for 100 total epochs, with 50 epochs performed by each of the two workers. Notably, we found that the performance of sparse update methods was poor for fromscratch training unless we performed 5 epochs of standard training as “warmup” before beginning distributed training. Beyond this change, all the models and hyper-parameters follow those mentioned in section 4.1. We searched for the best initial learning rate in {0.4, 0.2, 0.08, 0.04, 0.02}. We measure performance using a varying number of parameter updates between each worker-server communication step. We report performance in terms of the accuracy achieved under a certain communication budget, where the communication cost is measured in terms of the equivalent number of full model parameter updates. For example, a method that updates $10 \\%$ of the model’s parameters and performs 5 communication steps over the course of training has the same cost as a method that communicates all of a model’s parameters once (since we must transmit both the updated parameters and their locations; more details are in section 4.3). ",
+        "bbox": [
+            174,
+            410,
+            825,
+            628
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results Results from training a ResNet-34 on CIFAR-10 are shown in fig. 3. As in section 4.1, using a FISH Mask works better than using a random mask for all communication costs. Furthermore, we generally find that using FISH Mask with a sparsity level of $10 \\%$ attains a better commnication/performance trade-off than densely-updated distributed training. For example, FISH Mask training attains comparable performance to standard training when only communicating two copies of the model, whereas densely-updated training performs significantly worse at this communication amount. Notably, performance was relatively poor when only updating $2 \\%$ of the model’s parameters with FISH Mask, suggesting there is a lower bound under which it is difficult to attain reasonable results. As a whole, our results show significant promise for dramatically reducing computational costs in distributed training settings. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            785
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Efficient Checkpointing ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            801,
+            379,
+            818
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Over the course of training a machine learning model, it is common to save intermediate checkpoint files that store the model’s parameter values. These checkpoints can be useful for restarting training from a given iteration rather than starting from scratch in the event that the training job crashes or is otherwise stopped. They are also commonly used for post-hoc analysis, for example for evaluating a model’s performance on new datasets or metrics over the course of training. Since checkpoints store a full copy of the model’s parameters, they can take up a significant amount of space on disk. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/8998565721af8c8071214bca31df7506ed15f4236f119467ad82f4977cc53755.jpg",
+        "image_caption": [
+            "Figure 3: CIFAR-10 validation set accuracy achieved by a ResNet-34 through distributed training at different communication costs. $\\mathrm { X }$ -axis refers to the total number of model communications required for a single worker. Standard (non-distributed) training achieves an accuracy of $9 3 . 9 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            302,
+            87,
+            694,
+            280
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, depending on the checkpointing frequency, hundreds of checkpoints are often written to disk over the course of a training run. The development cycle of a machine learning model can result in hundreds of different model variants being trained. Combining these factors with the on-disk space needed to store the parameters of modern models (around 1 GB for BERTLARGE) results in potentially massive storage costs. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            435
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Training with sparse updates can significantly reduce these storage costs. Specifically, if only a small subset of the parameters are updated between checkpoint saves, then the checkpoint only needs to store the updated parameter values and indices denoting the position of the updated parameters’ values. Assuming that the storage costs for a parameter value and index is the same (e.g. using a 32-bit float for parameter values and a 32-bit integer for indices), using a sparse mask will reduce storage cost when the mask sparsity level is less than $50 \\%$ . Note that this setting allows the “mask” to change over the course of training, and is therefore a relaxation of the setting in section 4.1, where the requirement is that the same subset of parameters is updated over the entire fine-tuning run. It follows from our results in section 4.1 that FISH Mask training could be readily applied to reducing checkpoint size in parameter-efficient transfer learning. However, we found that the strict requirement of fixing the mask over an entire from-scratch training run on CIFAR-10 resulted in a significant degradation in performance. This is in line with past work demonstrating the difficulty of identifying fixed sparse subnetworks to train before training begins [15]. We therefore focus on from-scratch training on CIFAR-10 and allow the mask to change every time a checkpoint is written, which does not increase storage requirements over using the same fixed mask from the start of training. ",
+        "bbox": [
+            174,
+            443,
+            826,
+            650
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 2: CIFAR-10 validation set accuracy when using the FISH Mask and the Random Mask to reduce checkpoint sizes. “Epoch” refers to allowing the mask to change each epoch, and the number is how many epochs we update masks. Standard training achieves an accuracy of 93.9 $( \\pm 0 . 1 ) \\%$ . ",
+        "bbox": [
+            433,
+            660,
+            823,
+            729
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Overall, we use the same experimental setup as in section 4.2. We measure performance when updating the mask every epoch (which is a common choice in practice), every 2 epochs, every 4 epochs, and leaving the mask fixed over the course of training. We performed a new search over learning rates in $\\{ 0 . 4 , 0 . 2 , 0 . 0 8 , 0 . 0 4 , 0 . 0 2 \\}$ We compare to baselines of standard training (which to serve as an upper bound on the performance of using a FISH Mask) and using a random mask. ",
+        "bbox": [
+            174,
+            657,
+            419,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/e6eb383e012f0bec2465dfaf52cad6a91d8a88508cf3b296287e4e6194afb541.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"3\">Mask sparsity level</td></tr><tr><td>0.5%</td><td>2%</td><td>10%</td></tr><tr><td>Random Mask(1 Epoch)</td><td>74.80.6</td><td>84.40.2</td><td>90.00.2</td></tr><tr><td>FISH Mask (1 Epoch)</td><td>90.50.3</td><td>93.00.3</td><td>93.90.1</td></tr><tr><td>FISH Mask (2 Epochs)</td><td>90.30.5</td><td>92.50.1</td><td>93.70.2</td></tr><tr><td>FISH Mask (4 Epochs)</td><td>89.40.6</td><td>92.10.3</td><td>93.40.2</td></tr><tr><td>FISHMask (Fixed)</td><td>78.50.7</td><td>90.60.2</td><td>93.00.2</td></tr></table>",
+        "bbox": [
+            446,
+            744,
+            805,
+            856
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Results In table 2, we show the results of FISH Mask training when keeping the mask fixed over the course of training or updating it at each epoch. We find that updating the FISH Mask every epoch can match the performance of normal training $9 3 . 9 \\%$ accuracy) at a mask sparsity level of $10 \\%$ , which would reduce storage requirements by a factor of 5. At lower mask sparsity levels, we see some degradation in performance. We find that accuracy tends to decrease as we decrease the frequency of updating the mask, but this effect is relatively small. As mentioned earlier, we also found that using a fixed mask significantly degraded performance, though only by a few percent at a mask sparsity level of $10 \\%$ . This suggests that the FISH Mask could also be useful for identifying sparse subnetworks to train before training begins, as conjectured by the Lottery Ticket Hypothesis [15]. We leave the exploration of this possibility for future work. Lastly, the FISH Mask’s performance is unanimously better than the Random Mask across the three mask sparsity levels. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            202
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.4 Ablations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            228,
+            279,
+            242
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Having established the effectiveness of training with a FISH mask, we now ablate a few design choices to help demonstrate the robustness of our approach. We perform all ablation experiments in the parameter-efficient transfer learning setup described in section 4.1. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.4.1 True Fisher vs. Empirical Fisher ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            323,
+            450,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In section 2, we note that past work has approximated the Fisher information matrix (eq. (3)) using either the expectation over $y \\sim p _ { \\theta } ( y | x )$ (“true Fisher”) or ground-truth labels (“empirical Fisher”). While past work has shown that using the empirical Fisher can be detrimental in optimization settings [34, 26], we mainly use the Fisher information as a signal of parameter importance. The empirical Fisher also has the benefit that it avoids marginalizing over or sampling from $p _ { \\theta } ( y | x )$ and only requires computing the gradient for a single value of $y$ . When comparing the performance of using the true or empirical Fisher to compute a $0 . 5 \\%$ -sparse FISH Mask for parameter-efficient transfer learning, we observe that both methods achieve near-identical performance with an average validation-set GLUE score of 82.5 in both cases. Since computing the empirical Fisher can be more computationally efficient, we used the empirical Fisher for all experiments. ",
+        "bbox": [
+            174,
+            351,
+            825,
+            489
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.4.2 Sample Ablation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            513,
+            341,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We also ablate the number of samples, $N$ , used to compute the FISH Mask to study if more samples are beneficial. The results for parameter-efficient transfer learning on GLUE are shown in fig. 2, right. At a sample count of 0, the FISH Mask is equivalent to the Random Mask baseline presented in section 4.1 in which parameters to update are selected at random instead of informed by the Fisher information. We observe that FISH Mask performance on the GLUE validation set is surprisingly stable across many values of samples, with just 32 samples needed to achieve the highest-possible performance. These suggest that using the approximate Fisher information is a data-efficient approach of computing parameter importance, and we therefore ran all experiments with a sample count $N = 1 0 2 4$ , except in distributed training we use $N = 2 5 6$ for efficiency. ",
+        "bbox": [
+            173,
+            540,
+            825,
+            666
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            694,
+            299,
+            712
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we proposed FISH Mask training as a novel method for pre-computing fixed sparse masks of a model’s parameters to update over many subsequent iterations. The FISH Mask estimates the importance of each of a model’s parameters by first approximating the Fisher information of each parameter and then selecting the $k$ parameters with the largest Fisher information to include in the mask. We demonstrate the usefulness of FISH Mask training in several settings, including parameter-efficient transfer learning, distributed training, and reducing storage requirements of model checkpoints. In future work, we hope to explore methods for improving the performance of FISH Mask training at lower mask sparsity levels, possibly by considering other measures of parameter importance. We also hope to further demonstrate the efficacy of FISH Mask in real-world settings where the benefits of sparse parameter updating are even more pronounced, such as in Federated Learning. The integration of FISH Masks across tasks and sharing amongst practitioners could also be a useful line of inquiry, as recent frameworks such as AdapterHub [39] have enabled for Adapter modules [19]. ",
+        "bbox": [
+            173,
+            731,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            553,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We thank Yoon Kim, Michael Matena, and Demi Guo for helpful discussions. ",
+        "bbox": [
+            174,
+            121,
+            681,
+            135
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Alessandro Achille, Giovanni Paolini, and Stefano Soatto. Where is the information in a deep neural network? arXiv preprint arXiv:1905.12213, 2019.   \n[2] Alham Fikri Aji and Kenneth Heafield. Sparse communication for distributed gradient descent. arXiv preprint arXiv:1704.05021, 2017.   \n[3] Zeyuan Allen-Zhu, Yuanzhi Li, and Yingyu Liang. Learning and generalization in overparameterized neural networks, going beyond two layers. CoRR, abs/1811.04918, 2018. URL http://arxiv.org/abs/1811.04918.   \n[4] SI Amari. Neural learning in structured parameter spaces-natural riemannian gradient. Advances in neural information processing systems, pages 127–133, 1997.   \n[5] Ankur Bapna, Naveen Arivazhagan, and Orhan Firat. Simple, scalable adaptation for neural machine translation. arXiv preprint arXiv:1909.08478, 2019.   \n[6] Elad Ben-Zaken, Shauli Ravfogel, and Yoav Goldberg. BitFit: Simple parameter-efficient fine-tuning for transformer-based masked language models. 2021.   \n[7] Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. CoRR, abs/2005.14165, 2020. URL https://arxiv.org/abs/2005.14165.   \n[8] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey E. Hinton. A simple framework for contrastive learning of visual representations. CoRR, abs/2002.05709, 2020. URL https: //arxiv.org/abs/2002.05709.   \n[9] Ting Chen, Simon Kornblith, Kevin Swersky, Mohammad Norouzi, and Geoffrey E. Hinton. Big self-supervised models are strong semi-supervised learners. CoRR, abs/2006.10029, 2020. URL https://arxiv.org/abs/2006.10029.   \n[10] Elliot J. Crowley, Jack Turner, Amos Storkey, and Michael O’Boyle. Pruning neural networks: is it time to nip it in the bud? 2018.   \n[11] J. Dean, G. Corrado, Rajat Monga, Kai Chen, M. Devin, Quoc V. Le, Mark Z. Mao, Marc’Aurelio Ranzato, A. Senior, P. Tucker, K. Yang, and A. Ng. Large scale distributed deep networks. In NIPS, 2012.   \n[12] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171–4186, Minneapolis, Minnesota, June 2019. Association for Computational Linguistics. doi: 10.18653/v1/N19-1423. URL https://www.aclweb.org/anthology/N19-1423.   \n[13] Nikoli Dryden, Tim Moon, Sam Ade Jacobs, and Brian Van Essen. Communication quantization for data-parallel training of deep neural networks. In 2nd Workshop on Machine Learning in HPC Environments (MLHPC), 2016.   \n[14] Ronald A Fisher. On the mathematical foundations of theoretical statistics. Philosophical Transactions of the Royal Society of London. Series A, Containing Papers of a Mathematical or Physical Character, 222(594-604):309–368, 1922.   \n[15] Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. arXiv preprint arXiv:1803.03635, 2018.   \n[16] Demi Guo, Alexander M. Rush, and Yoon Kim. Parameter-efficient transfer learning with diff pruning. CoRR, abs/2012.07463, 2020. URL https://arxiv.org/abs/2012.07463.   \n[17] Moritz Hardt, Ben Recht, and Yoram Singer. Train faster, generalize better: Stability of stochastic gradient descent. In International Conference on Machine Learning, 2016.   \n[18] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CoRR, abs/1512.03385, 2015. URL http://arxiv.org/abs/1512.03385.   \n[19] Neil Houlsby, Andrei Giurgiu, Stanislaw Jastrzebski, Bruna Morrone, Quentin de Laroussilhe, Andrea Gesmundo, Mona Attariyan, and Sylvain Gelly. Parameter-efficient transfer learning for NLP. CoRR, abs/1902.00751, 2019. URL http://arxiv.org/abs/1902.00751.   \n[20] Jeremy Howard and Sebastian Ruder. Universal language model fine-tuning for text classification. CoRR, abs/1801.06146, 2018. URL http://arxiv.org/abs/1801.06146.   \n[21] James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, 114(13), 2017.   \n[22] Jakub Konecnˇ y, H Brendan McMahan, Daniel Ramage, and Peter Richtárik. Federated optimiza- \\` tion: Distributed machine learning for on-device intelligence. arXiv preprint arXiv:1610.02527, 2016.   \n[23] Jakub Konecnˇ y, H Brendan McMahan, Felix X Yu, Peter Richtárik, Ananda Theertha Suresh, \\` and Dave Bacon. Federated learning: Strategies for improving communication efficiency. arXiv preprint arXiv:1610.05492, 2016.   \n[24] Simon Kornblith, Jonathon Shlens, and Quoc V Le. Do better imagenet models transfer better? In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2019.   \n[25] A. Krizhevsky. Learning multiple layers of features from tiny images. 2009.   \n[26] Frederik Kunstner, Lukas Balles, and Philipp Hennig. Limitations of the empirical fisher approximation for natural gradient descent. arXiv preprint arXiv:1905.12558, 2019.   \n[27] Yann A LeCun, Léon Bottou, Genevieve B Orr, and Klaus-Robert Müller. Efficient backprop. In Neural networks: Tricks of the trade, pages 9–48. Springer, 2012.   \n[28] Brian Lester, Rami Al-Rfou, and Noah Constant. The power of scale for parameter-efficient prompt tuning. arXiv preprint arXiv:2104.08691, 2021.   \n[29] Xiang Lisa Li and Percy Liang. Prefix-tuning: Optimizing continuous prompts for generation. arXiv preprint arXiv:2101.00190, 2021.   \n[30] Liyang Liu, Shilong Zhang, Zhanghui Kuang, Aojun Zhou, Jing-Hao Xue, Xinjiang Wang, Yimin Chen, Wenming Yang, Qingmin Liao, and Wayne Zhang. Group fisher pruning for practical network compression. In Marina Meila and Tong Zhang, editors, Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pages 7021–7032. PMLR, 18–24 Jul 2021. URL https://proceedings. mlr.press/v139/liu21ab.html.   \n[31] Christos Louizos, Max Welling, and Diederik P. Kingma. Learning sparse neural networks through l_0 regularization. arXiv preprint arXiv:1712.01312, 2017.   \n[32] Rabeeh Karimi Mahabadi, James Henderson, and Sebastian Ruder. Compacter: Efficient low-rank hypercomplex adapter layers, 2021.   \n[33] Rabeeh Karimi Mahabadi, Sebastian Ruder, Mostafa Dehghani, and James Henderson. Parameter-efficient multi-task fine-tuning for transformers via shared hypernetworks, 2021. ",
+        "bbox": [
+            173,
+            127,
+            828,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            73,
+            830,
+            919
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[34] James Martens. New insights and perspectives on the natural gradient method. arXiv preprint arXiv:1412.1193, 2014. ",
+        "bbox": [
+            171,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[35] H. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Agüera y Arcas. Communication-efficient learning of deep networks from decentralized data, 2017. ",
+        "bbox": [
+            174,
+            128,
+            823,
+            159
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[36] Sinno Jialin Pan and Qiang Yang. A survey on transfer learning. IEEE Transactions on knowledge and data engineering, 22(10):1345–1359, 2009. ",
+        "bbox": [
+            174,
+            166,
+            823,
+            195
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[37] Razvan Pascanu and Yoshua Bengio. Revisiting natural gradient for deep networks. arXiv preprint arXiv:1301.3584, 2013. ",
+        "bbox": [
+            174,
+            204,
+            823,
+            233
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[38] Matthew E. Peters, Sebastian Ruder, and Noah A. Smith. To tune or not to tune? adapting pretrained representations to diverse tasks. arXiv preprint arXiv:1903.05987, 2019. ",
+        "bbox": [
+            173,
+            241,
+            825,
+            271
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[39] Jonas Pfeiffer, Andreas Rücklé, Clifton Poth, Aishwarya Kamath, Ivan Vulic, Sebastian Ruder, Kyunghyun Cho, and Iryna Gurevych. Adapterhub: A framework for adapting transformers. CoRR, abs/2007.07779, 2020. URL https://arxiv.org/abs/2007.07779. ",
+        "bbox": [
+            174,
+            279,
+            825,
+            321
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[40] Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21, 2020. ",
+        "bbox": [
+            174,
+            329,
+            821,
+            373
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[41] Sylvestre-Alvise Rebuffi, Hakan Bilen, and Andrea Vedaldi. Learning multiple visual domains with residual adapters. arXiv preprint arXiv:1705.08045, 2017. ",
+        "bbox": [
+            173,
+            381,
+            820,
+            411
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[42] Benjamin Recht, Christopher Re, Stephen Wright, and Feng Niu. Hogwild!: A lock-free approach to parallelizing stochastic gradient descent. In J. Shawe-Taylor, R. Zemel, P. Bartlett, F. Pereira, and K. Q. Weinberger, editors, Advances in Neural Information Processing Systems, volume 24. Curran Associates, Inc., 2011. URL https://proceedings.neurips.cc/ paper/2011/file/218a0aefd1d1a4be65601cc6ddc1520e-Paper.pdf. ",
+        "bbox": [
+            173,
+            419,
+            826,
+            489
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[43] Sidak Pal Singh and Dan Alistarh. Woodfisher: Efficient second-order approximation for neural network compression. Advances in Neural Information Processing Systems, 2020. ",
+        "bbox": [
+            173,
+            497,
+            821,
+            527
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[44] Nikko Strom. Scalable distributed dnn training using commodity gpu cloud computing. In Sixteenth Annual Conference of the International Speech Communication Association, 2015. ",
+        "bbox": [
+            174,
+            535,
+            823,
+            565
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[45] Zeyi Tao and Qun Li. esgd: Communication efficient distributed deep learning on the edge. In {USENIX} Workshop on Hot Topics in Edge Computing (HotEdge 18), 2018. ",
+        "bbox": [
+            173,
+            573,
+            823,
+            603
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[46] Lucas Theis, Iryna Korshunova, Alykhan Tejani, and Ferenc Huszár. Faster gaze prediction with dense networks and fisher pruning. CoRR, abs/1801.05787, 2018. URL http://arxiv. org/abs/1801.05787. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            654
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[47] Lucas Theis, Iryna Korshunova, Alykhan Tejani, and Ferenc Huszár. Faster gaze prediction with dense networks and fisher pruning. arXiv preprint arXiv:1801.05787, 2018. ",
+        "bbox": [
+            173,
+            661,
+            823,
+            693
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[48] Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. GLUE: A multi-task benchmark and analysis platform for natural language understanding. CoRR, abs/1804.07461, 2018. URL http://arxiv.org/abs/1804.07461. ",
+        "bbox": [
+            173,
+            700,
+            823,
+            743
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[49] Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, Rémi Louf, Morgan Funtowicz, et al. Huggingface’s transformers: State-of-the-art natural language processing. arXiv preprint arXiv:1910.03771, 2019. ",
+        "bbox": [
+            173,
+            751,
+            825,
+            795
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[50] Mengjie Zhao, Tao Lin, Martin Jaggi, and Hinrich Schütze. Masking as an efficient alternative to finetuning for pretrained language models. CoRR, abs/2004.12406, 2020. URL https: //arxiv.org/abs/2004.12406. ",
+        "bbox": [
+            171,
+            803,
+            825,
+            845
+        ],
+        "page_idx": 12
+    }
+]

parse/train/r-oRRT-ElX/r-oRRT-ElX.md

@@ -0,0 +1,247 @@
+# On Provable Benefits of Depth in Training Graph Convolutional Networks
+
+Weilin Cong Penn State wxc272@psu.edu
+
+Morteza Ramezani Penn State morteza@cse.psu.edu
+
+Mehrdad MahdaviPenn Statemzm616@psu.edu
+
+# Abstract
+
+Graph Convolutional Networks (GCNs) are known to suffer from performance degradation as the number of layers increases, which is usually attributed to oversmoothing. Despite the apparent consensus, we observe that there exists a discrepancy between the theoretical understanding of over-smoothing and the practical capabilities of GCNs. Specifically, we argue that over-smoothing does not necessarily happen in practice, a deeper model is provably expressive, can converge to global optimum with linear convergence rate, and achieve very high training accuracy as long as properly trained. Despite being capable of achieving high training accuracy, empirical results show that the deeper models generalize poorly on the testing stage and existing theoretical understanding of such behavior remains elusive. To achieve better understanding, we carefully analyze the generalization capability of GCNs, and show that the training strategies to achieve high training accuracy significantly deteriorate the generalization capability of GCNs. Motivated by these findings, we propose a decoupled structure for GCNs that detaches weight matrices from feature propagation to preserve the expressive power and ensure good generalization performance. We conduct empirical evaluations on various synthetic and real-world datasets to validate the correctness of our theory.
+
+# 1 Introduction
+
+In recent years, Graph Convolutional Networks (GCNs) have achieved state-of-the-art performance in dealing with graph-structured applications, including social networks [28, 21, 51, 12, 44], traffic prediction [10, 45, 34, 31], knowledge graphs [52, 53, 43], drug reaction [14, 16] and recommendation system [2, 60]. Despite the success of GCNs, applying a shallow GCN model that only uses the information of a very limited neighborhood on a large sparse graph has shown to be not effective [23, 6, 20, 9, 46]. As a result, a deeper GCN model would be desirable to reach and aggregate information from farther neighbors. The inefficiency of shallow GCNs is exacerbated even further when the labeled nodes compared to graph size is negligible, as a shallow GCN cannot sufficiently propagate the label information to the entire graph with only a few available labels [35].
+
+Although a deeper GCN is preferred to perceive more graph structure information, unlike traditional deep neural networks, it has been pointed out that deeper GCNs potentially suffer from oversmoothing [35, 41, 26, 4, 58], vanishing/exploding gradients [33], over-squashing [1], and training difficulties [62, 38], which significantly affect the performance of GCNs as the depth increases. Among these, the most widely accepted reason is “over-smoothing”, which is referred to as a phenomenon due to applying multiple graph convolutions such that all node embeddings converge to a single subspace (or vector) and leads to indistinguishable node representations.
+
+The conventional wisdom is that adding to the number of layers causes over-smoothing, which impairs the expressiveness power of GCNs and consequently leads to a poor training accuracy. However, we observe that there exists a discrepancy between theoretical understanding of their inherent capabilities and practical performances. According to the definition of over-smoothing that the node representation becomes indistinguishable as GCNs goes deeper, the classifier has difficulty assigning the correct label for each node if over-smoothing happens. As a result, the training accuracy is expected to be decreasing as the number of layers increases. However, as shown in Figure 1, GCNs are capable of achieving high training accuracy regardless of the number of layers. But, as it can be observed, deeper GCNs require more training iterations to reach a high training accuracy, and its generalization performance on evaluation set decreases as the number of layers increases. This observation suggests that the performance degradation is likely due to inappropriate training rather than the low expressive power caused by over-smoothing. Otherwise, a low expressiveness model cannot achieve almost perfect training accuracy simply by proper training tricks alone.1 Indeed, recent years significant advances have been witnessed on tweaking the model architecture to overcome the training difficulties in deeper GCN models and achieve good generalization performance [38, 6, 33, 62].
+
+![](images/d96dabd61d79d6401e80639fa13156cc6e9e472b4caf09be8035395a98d70400.jpg)  
+Figure 1: Comparison of F1-score for GCN with different depth on Cora dataset, where deeper models can achieve high training accuracy, but complicate the training by requiring more iterations to converge and suffer from poor generalization.
+
+Contributions. Motivated by aforementioned observation, i.e., still achieving high training accuracy when trained properly but poor generalization performance, we aim at answering two fundamental questions in this paper:
+
+Q1: Does increasing depth really impair the expressiveness power of GCNs? In Section 4, we argue that there exists a discrepancy between over-smoothing based theoretical results and the practical capabilities of deep GCN models, demonstrating that over-smoothing is not the key factor that leads to the performance degradation in deeper GCNs. In particular, we mathematically show that over-smoothing [41, 26, 35, 4] is mainly an artifact of theoretical analysis and simplifications made in analysis. Indeed, by characterizing the representational capacity of GCNs via Weisfeiler-Lehman (WL) graph isomorphism test [39, 55], we show that deeper GCN model is at least as expressive as the shallow GCN model, the deeper GCN models can distinguish nodes with a different neighborhood that the shallow GCN cannot distinguish, as long as the GCNs are properly trained. Besides, we theoretically show that more training iterations is sufficient (but not necessary due to the assumptions made in our theoretical analysis) for a deeper model to achieve the same training error as the shallow ones, which further suggests the poor training error in deep GCN training is most likely due to inappropriate training.
+
+Q2: If expressive, why then deep GCNs generalize poorly?
+
+In Section 5, in order to understand the performance degradation phenomenon in deep GCNs during the evaluation phase, we give a novel generalization analysis on GCNs and its variants (e.g., ResGCN, APPNP, and GCNII) under the semi-supervised setting for the node classification task. We show that the generalization gap of GCNs is governed by the number of training iterations, largest node degree, the largest singular value of weight matrices, and the number of layers. In particular, our result suggests that a deeper GCN model requires more iterations of training and optimization tricks to converge (e.g., adding skip-connections), which leads to a poor generalization. More interestingly, our generalization analysis shows that most of the so-called methods to solve oversmoothing [47, 61, 6, 29] can greatly improve the generalization ability of the model, therefore results in a deeper model.
+
+The aforementioned findings naturally lead to the algorithmic contribution of this paper. In Section 6, we present a novel framework, Decoupled GCN (DGCN), that is capable of training deeper GCNs and can significantly improve the generalization performance. The main idea is to isolate the expressive power from generalization ability by decoupling the weight parameters from feature propagation. In Section 7, we conduct experiments on the synthetic and real-world datasets to validate the correctness of the theoretical analysis and the advantages of DGCN over baseline methods.
+
+# 2 Related works
+
+Expressivity of GCNs. Existing results on expressive power of GCNs are mixed, [39, 37, 7, 5] argue that deeper model has higher expressive power but [41, 26, 25] have completely opposite result. On the one hand, [39] shows a deeper GCN is as least as powerful as the shallow one in terms of distinguishing non-isomorphic graphs. [37] shows that deep and wide GCNs is Turing universal, however, GCNs lose power when their depth and width are restricted. [7] and [5] measure the expressive power of GCNs via its subgraph counting capability and attribute walks, and both show the expressive power of GCNs grows exponentially with the GCN depth. On the other hand, [25] studies the infinity wide GCNs and shows that the covariance matrix of its outputs converges to a constant matrix at an exponential rate. [41, 26] characterize the expressive power using the distance between node embeddings to a node feature agnostic subspace and show the distance is decreasing as the number of layers increases. Details are deferred to Section 4 and Appendix B. Such contradictory results motivate us to rethink the role of over-smoothing on expressiveness.
+
+Generalization analysis of GCNs. In recent years, many papers are working on the generalization of GCNs using uniform stability [50, 63], Neural Tangent Kernel [15], VC-dimension [49], Rademacher complexity [18, 42], algorithm alignment [56, 57] and PAC-Bayesian [36]. Existing works only focus on a specific GCN structure, which cannot be used to understand the impact of GCN structures on its generalization ability. The most closely related to ours is [50], where they analyze the stability of the single-layer GCN model, and show that the stability of GCN depends on the largest absolute eigenvalue of its Laplacian matrix. However, their result is under the inductive learning setting and extending the results to the multi-layer GCNs with different structures is non-trivial.
+
+Literature with similar observations. Most recently, several works have similar observations on the over-smoothing issue to ours. [62] argues that the main factors to performance degradation are vanishing gradient, training instability, and over-fitting, rather than over-smoothing, and proposes a node embedding normalization heuristic to alleviate the aforementioned issues. [38] argues that the performance degradation is mainly due to the training difficulty, and proposes a different graph Laplacian formulation, weight parameter initialization, and skip-connections to improve the training difficulty. [59] argues that deep GCNs can learn to overcome the over-smoothing issue during training, and the key factor of performance degradation is over-fitting, and proposes a node embedding normalization method to help deep GCNs overcome the over-smoothing issue. [30] improves the generalization ability of GCNs by using adversarial training and results in a consistent improvement than all GCNs baseline models without adversarial training. All aforementioned literature only gives heuristic explanations based on the empirical results, and do not provide theoretical arguments.
+
+# 3 Preliminaries
+
+Notations and setup. We consider the semi-supervised node classification problem, where a selfconnected graph $\mathcal { G } = ( \nu , \mathcal { E } )$ with $N = | \nu |$ nodes is given in which each node $i \in \nu$ is associated with a feature vector $\mathbf { x } _ { i } \in \mathbb { R } ^ { d _ { 0 } }$ , and only a subset of nodes $\mathcal { V } _ { \mathrm { t r a i n } } \subset \mathcal { V }$ are labeled, i.e., $y _ { i } \in \{ 1 , \ldots , | { \mathcal { C } } | \}$ for each $i \in \mathcal { V } _ { \mathrm { t r a i n } }$ and $\mathcal { C }$ is the set of all candidate classes. Let $\mathbf { A } \in \mathbb { R } ^ { N \times N }$ denote the adjacency matrix and $\mathbf { D } \in \mathbb { R } ^ { N \times N }$ denote the corresponding degree matrix with $D _ { i , i } = \deg ( i )$ and $D _ { i , j } = 0$ if $i \neq j$ . Then, the propagation matrix (using the Laplacian matrix defined in [28]) is computed as $\mathbf { P } = \mathbf { D } ^ { - 1 / 2 } \mathbf { A } \mathbf { D } ^ { - 1 / 2 }$ . Our goal is to learn a GCN model using the node features for all nodes $\{ { \bf x } _ { i } \} _ { i \in \mathcal { V } }$ and node labels for the training set nodes $\{ y _ { i } \} _ { i \in \mathcal { V } _ { \operatorname { t r a i n } } }$ , and expect it generalizes well on the unlabeled node set $\mathcal { V } _ { \mathrm { t e s t } } = \mathcal { V } \setminus \mathcal { V } _ { \mathrm { t r a i n } }$ .
+
+GCN architectures. In this paper, we consider the following architectures for training GCNs:
+
+![](images/1060240432cfbec674f54ca5828faa36688caf668156a8b6d68ff12171d6b3cb.jpg)  
+Figure 2: Comparison of intra- and inter-class normalized node embeddings $\mathbf { H } ^ { ( \ell ) } / \| \mathbf { H } ^ { ( \ell ) } \| _ { \mathrm { F } }$ pairwise distance on Cora dataset. See Appendix A for more evidences.
+
+• Vanilla GCN [28] computes node embeddings by $\mathbf { H } ^ { ( \ell ) } = \sigma ( \mathbf { P H } ^ { ( \ell - 1 ) } \mathbf { W } ^ { ( \ell ) } )$ , where $\mathbf { H } ^ { ( \ell ) } =$ $\{ \mathbf { h } _ { i } ^ { ( \ell ) } \} _ { i = 1 } ^ { N }$ is the \`th layer node embedding matrix, $\mathbf { h } _ { i } ^ { ( \ell ) } \in \mathbb { R } ^ { d _ { \ell } }$ is the embedding of $i$ th node, $\mathbf { W } ^ { ( \ell ) } \in \mathbb { R } ^ { d _ { \ell } \times d _ { \ell - 1 } }$ is the \`th layer weight matrix, and $\sigma ( \cdot )$ is the ReLU activation.
+
+• ResGCN [33] solves the vanishing gradient issue by adding skip-connections between adjacency layers. More specifically, ResGCN computes node embeddings by $\mathbf { H } ^ { ( \ell ) } = \sigma ( \mathbf { P H } ^ { ( \ell - 1 ) } \mathbf { \dot { W } } ^ { ( \ell ) } ) \dot { + }$ $\mathbf { H } ^ { ( \ell - 1 ) }$ No fully connected layer after node feature, where node embeddings of the previous layer is added to the output of the current layer to facilitate the training of deeper GCN models.
+
+• APPNP [29] adds skip-connections from the input layer to each hidden layer to preserve the feature information. APPNP computes node embeddings by $\mathbf { H } ^ { ( \ell ) } = \alpha _ { \ell } \mathbf { P } \mathbf { H } ^ { ( \ell - 1 ) } + ( \mathbf { \bar { l } } - \alpha _ { \ell } ) \mathbf { H } ^ { ( 0 ) } \mathbf { W }$ , where $\alpha _ { \ell } \in [ 0 , 1 ]$ balances the amount of information preserved at each layer. By decoupling feature transformation and propagation, APPNP can aggregate information from multi-hop neighbors without significantly increasing the computation complexity.
+
+• GCNII [6] improves the capacity of APPNP by adding non-linearty and weight matrix at each individual layer. GCNII computes node embeddings by $\mathbf { H } ^ { ( \ell ) } = \bar { \sigma } \big ( ( \alpha _ { \ell } \mathbf { P } \bar { \mathbf { H } ^ { ( \ell - 1 ) } } + ( 1 -$ $\alpha _ { \ell } ) \mathbf { H } ^ { ( 0 ) } ) \bar { \mathbf { W } } ^ { ( \ell ) } )$ , where $\bar { \mathbf { W } } ^ { ( \ell ) } = \beta _ { \ell } \mathbf { W } ^ { ( \ell ) } + ( 1 - \beta _ { \ell } ) \mathbf { I }$ , constant $\alpha _ { \ell }$ same as APPNP, and constant $\beta _ { \ell } \in [ 0 , 1 ]$ restricts the power of \`th layer parameters.
+
+# 4 On true expressiveness and optimization landscape of deep GCNs
+
+Empirical validation of over-smoothing. In this section, we aim at answering the following fundamental question: “Does over-smoothing really cause the performance degradation in deeper $G C N s ? ^ { \prime \prime }$ As first defined in [35], over-smoothing is referred to as a phenomenon where all node embeddings converge to a single vector after applying multiple graph convolution operations to the node features. However, [35] only considers the graph convolution operation without non-linearity and the per-layer weight matrices. To verify whether over-smoothing exists in normal GCNs, we measure the pairwise distance between the normalized node embeddings with varying the model depth.2 As shown in Figure 2, without the weight matrices and non-linear activation functions, the pairwise distance between node embeddings indeed decreases as the number of layers increases. However, by considering the weight matrices and non-linearity, the pairwise distances are actually increasing after a certain depth which contradicts the definition of over-smoothing that node embeddings become indistinguishable when the model becomes deeper. That is, graph convolution makes adjacent node embeddings get closer, then non-linearity and weight matrices help node embeddings preserve distinguishing-ability after convolution.
+
+Most recently, [41, 26] generalize the idea of over-smoothing by taking both the non-linearity and weight matrices into considerations. More specifically, the expressive power of the \`th layer node embeddings $\mathbf { H } ^ { ( \ell ) }$ is measured using $d _ { \mathcal { M } } ( \mathbf { H } ^ { ( \ell ) } )$ , which is defined as the distance of node embeddings to a subspace $\mathcal { M }$ that only has node degree information. Let denote $\lambda _ { L }$ as the second largest eigenvalue of graph Laplacian and $\lambda _ { W }$ as the largest singular value of weight matrices. [41, 26] show that the expressive power $d _ { \mathcal { M } } ( \mathbf { H } ^ { ( \ell ) } )$ is bounded by $d _ { \mathcal { M } } ( \mathbf { H } ^ { ( \ell ) } ) \leq ( \lambda _ { W } \lambda _ { L } ) ^ { \ell } \cdot d _ { \mathcal { M } } ( \mathbf { X } )$ , i.e., the expressive power of node embeddings will be exponentially decreasing or increasing as the number of layers increases, depending on whether $\lambda _ { W } \lambda _ { L } < 1$ or $\lambda _ { W } \lambda _ { L } > 1$ . They conclude that deeper GCN exponentially loss expressive power by assuming $\lambda _ { W } \lambda _ { L } < 1$ . However, we argue that this assumption does not always hold. To see this, let suppose $\mathbf { W } ^ { ( \ell ) } \in \mathbb { R } ^ { d _ { \ell - 1 } \times d _ { \ell } }$ is initialized by uniform distribution $\mathcal { N } ( 0 , \sqrt { 1 / d _ { \ell - 1 } } )$ . By the Gordon’s theorem for Gaussian matrices [11], we know its expected largest singular value is bounded by $\mathbb { E } [ \lambda _ { W } ] \le 1 + \sqrt { d _ { \ell } / d _ { \ell - 1 } }$ , which is strictly greater than 1 and $\lambda _ { W }$ usually increases during training. The above discussion also holds for other commonly used initialization methods [19, 22]. Furthermore, since most real world graphs are sparse with $\lambda _ { L }$ close to 1, e.g., Cora has $\lambda _ { L } = 0 . 9 9 6 4$ , Citeseer has $\lambda _ { L } = 0 . 9 9 8 7$ , and Pubmed has $\lambda _ { L } = 0 . 9 9 0 5$ , making assumption on $\lambda _ { W } \lambda _ { L } < 1$ is not realistic. As shown in Figure 3, when increasing the number of layers, we observe that the distance $d _ { \mathcal { M } } ( \mathbf { H } ^ { ( \ell ) } )$ is decreasing on untrained-GCN models, however, the distance $d _ { \mathcal { M } } ( \mathbf { H } ^ { ( \ell ) } )$ is increasing on trained-GCN models, which contradicts the conclusion in [41]. Due to the space limit, we defer the more empirical evidence to Appendix B. Through these findings, we cast doubt on the power of over-smoothing based analysis to provide a complete picture of why deep GCNs perform badly.
+
+![](images/84e24a192bc5e80db4a4ccfceccfa7007c39202a2f0d6209d2870a24585057cf.jpg)  
+Figure 3: Compare $d _ { \mathcal { M } } ( \mathbf { H } ^ { ( \ell ) } )$ and $\lambda _ { W } ( \mathbf { W } ^ { ( \ell ) } )$ on both trained- (using 500 gradient update) and untrained-GCN models on Cora dataset.
+
+Definition 1. Let $\mathcal { T } _ { i } ^ { L }$ denote the $L$ -layer computation tree of node $i$ , which represents the structured $L$ -hop neighbors of node $i$ , where the children of any node $j$ in the tree are the nodes in $\mathcal { N } ( i )$ .
+
+Exponentially growing expressieness without strong assumptions. Indeed, we argue that deeper GCNs have stronger expressive power than the shallow GCNs. To prove this, we employ the connection between WL test3 [32] and GCNs. Recently, [39] shows that GCNs have the same expressiveness as the WL-test for graph isomorphism if they are appropriately trained, i.e., a properly trained $L$ -layer GCN computes different node representations for two nodes if their $L$ -layer computation tree (Definition 1) have different structure or different features on the corresponding nodes. Since $L$ -GCN can encode any different computation tree into different representations, it is natural to characterize the expressiveness of $L$ -GCN by the number of computation graph it can encode.
+
+Theorem 1. Suppose $\mathcal { T } ^ { L }$ is a computation tree with binary node features and node degree at least d. Then, by assuming the computation tree of two nodes are disjoint, the richness (i.e., the number of computation graphs a model can encode) of the output of $L$ -GCN defined on $\mathcal { T } ^ { L }$ is at least $| \bar { L } \bar { - } G C \bar { N } ( \bar { \cal T } ^ { L } ) | \geq 2 ( \bar { d } - 1 ) ^ { L - 1 }$ .
+
+The proof is deferred to Appendix C. The above theorem implies that the richness of $L$ -GCN grows at least exponentially with respect to the number of layers.
+
+Comparison of expressiveness metrics. Although distance-based expressiveness metric [41, 26] is strong than WL-based metric in the sense that node embeddings can be distinct but close to each other, the distance-based metric requires explicit assumptions on the GCN structures, weight matrices, and graph structures comparing to the WL-based metric, which has been shown that are not likely hold. On the other hand, WL-based metric has been widely used in characterizing the expressive power of GCNs in graph-level task [39, 37, 7, 5]. More details are deferred to related works (Section 2).
+
+Although expressive, it is still unclear why the deeper GCN requires more training iterations to achieve small training error and reach the properly trained status. To understand this, we show in Theorem 2 that under assumptions on the width of the final layer, the deeper GCN can converge to its global optimal with linear convergence rate. More specifically, the theorem claims that if the dimension of the last layer of $\mathrm { G C N } d _ { L }$ is larger than the number of data $N ^ { 4 }$ , then we can guarantee the loss ${ \mathcal { L } } ( \theta _ { T } ) \leq \varepsilon$ after $T = \mathcal { O } ( 1 / \varepsilon )$ iterations of the gradient updates. Besides, more training iterations is sufficient (but not necessary due to the assumptions made in our theoretical analysis) for a deeper model to achieve the same training error as the shallow ones.
+
+Theorem 2. Let $\pmb { \theta } _ { t } = \{ \mathbf { W } _ { t } ^ { ( \ell ) } \in \mathbb { R } ^ { d _ { \ell - 1 } \times d _ { \ell } } \} _ { \ell = 1 } ^ { L + 1 }$ be the model parameter at the $t$ -th iteration and using square loss $\begin{array} { r } { \mathcal { L } ( \pmb { \theta } ) = \frac { 1 } { 2 } \| \mathbf { H } ^ { ( L ) } \mathbf { W } ^ { ( L + 1 ) } - \mathbf { Y } \| _ { \mathrm { F } } ^ { 2 } } \end{array}$ , $\mathbf { H } ^ { ( \ell ) } = \sigma ( \mathbf { P H } ^ { ( \ell - 1 ) } \mathbf { W } ^ { ( \ell ) } )$ as objective function. Then, under the condition that $d _ { L } \geq N$ we can obtain $\mathcal { L } ( \pmb { \theta } _ { T } ) \leq \epsilon i f T \geq C ( L ) \log ( \mathcal { L } ( \pmb { \theta } _ { 0 } ) / \epsilon )$ , where $\epsilon$ is the desired error and $C ( L )$ is a function of GCN depth $L$ that grows as GCN becomes deeper.
+
+A formal statement of Theorem 2 and its proof are deferred to Appendix D. Besides, gradient stability also provides an alternative way of empirically understanding why deeper GCN requires more iterations: deeper neural networks are prone to exploding/vanishing gradient, which results in a very noisy gradient and requires small learning rate to stabilize the training. This issue can be significantly alleviated by adding skip-connections (Appendix E.5). When training with adaptive learning rate mechanisms, such as Adam $[ 2 7 ]$ , noisy gradient will result in a much smaller update on current model compared to a stabilized gradient, therefore more training iterations are required.
+
+# 5 A different view from generalization
+
+In the previous section, we provided evidence that a well-trained deep GCN is at least as powerful as a shallow one. However, it is still unclear why a deeper GCN has worse performance than a shallow GCN during the evaluation phase. To answer this question, we provide a different view by analyzing the impact of GCN structures on the generalization.
+
+Transductive uniform stability. In the following, we study the generalization ability of GCNs via transductive uniform stability [17], where the generalization gap is defined as the difference between the training and testing errors for the random partition of a full dataset into training and testing sets. Transductive uniform stability is defined under the notation that the output of a classifier does not change much if the input is perturbed a bit, which is an extension of uniform stability [3] from the inductive to the transductive setting. The previous analysis on the uniform stability of GCNs [50] only shows the result of GCN with one graph convolutional layer under inductive learning setting, which cannot explain the effect of depth, model structure, and training data size on the generalization, and its extension to multi-layer GCNs and other GCN structures are non-trivial.
+
+Problem setup. Let $m = | \mathcal { V } _ { \mathrm { t r a i n } } |$ and $u = | \nu _ { \mathrm { t e s t } } |$ denote the training and test dataset sizes, respectively. Under the transductive learning setting, we start with a fixed set of points $X _ { m + u } = \{ x _ { 1 } , \ldots , x _ { m + u } \}$ For notational convenience, we assume $X _ { m }$ are the first $m$ data points and $X _ { u }$ are the last $u$ data points of $X _ { m + u }$ . We randomly select a subset $X _ { m } ~ \subset ~ X _ { m + u }$ uniformly at random and reveal the labels $Y _ { m }$ for the selected subset for training, but the labels for the remaining $u$ data points $Y _ { u } = Y _ { m + u } \setminus Y _ { m }$ are not available during the training phase. Let $S _ { m } = ( ( x _ { 1 } , y _ { 1 } ) , \bar { \bf \Phi } \cdot \cdot \cdot , ( x _ { m } , \bar { y } _ { m } ) )$ denotes the labeled set and $X _ { u } = ( x _ { m + 1 } , \dots , x _ { m + u } )$ denotes the unlabeled set. Our goal is to learn a model to label the remaining unlabeled set as accurately as possible.
+
+For the analysis purpose, we assume a binary classifier is applied to the final layer node representation $f ( \mathbf { h } _ { i } ^ { ( L ) } ) = \tilde { \sigma } ( \mathbf { v } ^ { \top } \mathbf { h } _ { i } ^ { ( L ) } )$ with $\tilde { \sigma } ( \cdot )$ denotes the sigmoid function. We predict $\hat { y } _ { i } = 1$ if $f ( \mathbf { h } _ { i } ^ { ( L ) } ) > 1 / 2$ and $\hat { y } _ { i } = 0$ otherwise, with ground truth label $y _ { i } \in \{ 0 , 1 \}$ . Let denote the perturbed dataset as $S _ { m } ^ { i j } \triangleq ( S _ { m } \setminus \{ ( x _ { i } , y _ { i } ) \} ) \cup \{ ( x _ { j } , y _ { j } ) \}$ and $X _ { u } ^ { i j } \triangleq ( X _ { u } \setminus \{ x _ { j } \} ) \cup \{ x _ { i } \}$ , which is obtained by replacing the ith example in training set $S _ { m }$ with the $j$ th example from the testing set $X _ { u }$ . Let $\pmb { \theta }$ and $\pmb { \theta } ^ { i j }$ denote the weight parameters trained on the original dataset $( S _ { m } , X _ { u } )$ and the perturbed dataset $( S _ { m } ^ { i j } , X _ { u } ^ { i j } )$ , respectively. Then, we say transductive learner $f$ is $\epsilon$ -uniformly stable if the outputs change less than $\epsilon$ when we exchange two examples from the training set and testing set, i.e., for any $S _ { m } \subset S _ { m + u }$ and any $i , j \in [ m + u ]$ it holds that $\begin{array} { r } { \operatorname* { s u p } _ { i \in [ m + u ] } | f ( \mathbf { h } _ { i } ^ { ( L ) } ) - \tilde { f } ( \tilde { \mathbf { h } } _ { i } ^ { ( L ) } ) ) | \leq \epsilon } \end{array}$ , where $f ( \mathbf { h } _ { i } ^ { ( L ) } )$ and $\tilde { f } ( \tilde { \mathbf { h } } _ { i } ^ { ( L ) } )$ denote the prediction of node $i$ using parameters $\pmb { \theta }$ and $\pmb { \theta } ^ { i j }$ respectively.
+
+To define testing error and training error in our setting, let us introduce the difference in probability between the correct and the incorrect label as $p ( z , y ) \triangleq y ( 2 z - 1 ) + ( 1 - y ) ( 1 - 2 z )$ with $p ( z , y ) \leq 0$ if there exists a classification error. Let denote the Then, the testing error is defined as $\begin{array} { r } { \mathcal { R } _ { u } ( f ) = \frac { 1 } { u } \sum _ { i = m + 1 } ^ { m + u } \mathbf { 1 } \{ p ( f ( \mathbf { h } _ { i } ^ { ( L ) } ) , y _ { i } ) \leq 0 \} } \end{array}$ $\gamma$ -margin loss as $\Phi _ { \gamma } ( x ) = \operatorname* { m i n } ( 1 , \operatorname* { m a x } ( 0 , 1 - x / \gamma ) )$ and the training . loss is defined as $\begin{array} { r } { \mathcal { R } _ { m } ^ { \gamma } ( f ) = \frac { 1 } { m } \sum _ { i = 1 } ^ { m } \Phi _ { \gamma } ( - p ( f ( \mathbf { h } _ { i } ^ { ( L ) } ) , y _ { i } ) ) } \end{array}$ . 6
+
+Theorem 3 (Transductive uniform stability bound [17]). Let $f$ be a $\epsilon$ -uniformly stable transductive learner and $\gamma , \delta > 0$ , and define $Q = m u / ( m + u )$ . Then, with probability at least $1 - \delta$ over all training and testing partitions, we have $\begin{array} { r } { \mathcal { R } _ { u } ( f ) \leq \mathcal { R } _ { m } ^ { \gamma } ( f ) + \frac { 2 } { \gamma } \mathcal { O } \left( \epsilon \sqrt { Q \ln ( \delta ^ { - 1 } ) } \right) + \mathcal { O } \left( \frac { \ln ( \delta ^ { - 1 } ) } { \sqrt { Q } } \right) } \end{array}$ .
+
+Recall that as we discussed in Section 4, deeper GCN is provable more expressive and can achieve very low training error $\mathcal { R } _ { m } ^ { \gamma } ( f )$ if properly training. Then, if the dataset size is sufficiently large, the testing error $\mathcal { R } _ { u } ( f )$ will be dominated by the generalization gap, which is mainly controlled by uniformly stable constant . In the following, we explore the impact of GCN structures on $\epsilon$ . Our key idea is to decompose the $\epsilon$ into three terms: the Lipschitz continuous constant $\rho _ { f }$ , upper bound on gradient $G _ { f }$ , and the smoothness constant $L _ { f }$ of GCNs. Please refer to Lemma 1 for details.
+
+Lemma 1. Suppose function $f ( \mathbf { h } ^ { ( L ) } )$ is $\rho _ { f }$ -Lipschitz continuous, $L _ { f }$ -smooth, and the gradient of loss w.r.t. the parameter is bounded by $G _ { f }$ . After $T$ steps of full-batch gradient descent, we have $\begin{array} { r } { \epsilon = \frac { 2 \eta \rho _ { f } G _ { f } } { m } \sum _ { t = 1 } ^ { T } ( 1 + \eta L _ { f } ) ^ { t - 1 } } \end{array}$
+
+The proof is deferred to Appendix K. By using Lemma 1, we can derive constant $\epsilon$ of different model structures by comparing the Lipschitz continuity, smoothness, and gradient scale.
+
+Before proceeding to our result, we make the following standard assumption on the node feature vectors and weight matrices, which are previously used in generalization analysis of GCNs [18, 36].
+
+Assumption 1. We assume the norm of node feature vectors, weight parameters are bounded, i.e., $\| \mathbf { x } _ { i } \| _ { 2 } \leq B _ { x }$ , $\| \mathbf { W } ^ { ( \ell ) } \| _ { 2 } \le B _ { w }$ , and $\| \mathbf { v } \| _ { 2 } \leq 1$ .
+
+In Theorem 4, we show that the generalization bounds of GCN and its variants are dominated by the following terms: maximum node degree $d$ , model depth $L$ , training/validation set size $( m , u )$ , training iterations $T$ , and spectral norm of the weight matrices $B _ { w }$ . The larger the aforementioned variables are, the larger the generalization gap is. We defer the formal statements and proofs to Appendices F, G, H, and I.
+
+Theorem 4 (Informal). We say model is -uniformly stable with  = 2ηρf Gfm PTt= $\begin{array} { r } { \epsilon = \frac { 2 \eta \rho _ { f } G _ { f } } { m } \sum _ { t = 1 } ^ { T } ( 1 + \eta L _ { f } ) ^ { t - 1 } } \end{array}$ where the result of $\rho _ { f } , G _ { f } , L _ { f }$ 1are summarized in Table 1, and other related constants as
+
+$$
+\begin{array} { r l } & { \quad B _ { d } ^ { \alpha } = ( 1 - \alpha ) \sum _ { \ell = 1 } ^ { L } ( \alpha \sqrt { d } ) ^ { \ell - 1 } + ( \alpha \sqrt { d } ) ^ { L } , \ B _ { w } ^ { \beta } = \beta B _ { w } + ( 1 - \beta ) , } \\ & { B _ { \ell , d } ^ { \alpha , \beta } = \operatorname* { m a x } \big \{ \beta \big ( ( 1 - \alpha ) L + \alpha \sqrt { d } \big ) , ( 1 - \alpha ) L B _ { w } ^ { \beta } + 1 \big \} . } \end{array}
+$$
+
+In the following, we provide intuitions and discussions on the generalization bound of each algorithm:
+
+• Deep GCN requires iterations $T$ to achieve small training error. Since the generalization bound increases with $T$ , more iterations significantly hurt its generalization power. Note that our results considers both $B _ { w } \le 1$ and $B _ { w } > 1$ , where increasing model depth will not hurt the generalization if $B _ { w } \le 1$ , and the generalization gap becomes sensitive to the model depth if $B _ { w } > 1$ . Notice that $B _ { w } > 1$ is more likely to happen during training as we discussed in Section 4.
+
+• ResGCN resolves the training difficulties by adding skip-connections between hidden layers. Although it requires less training iterations $T$ , adding skip-connections enlarges the dependency on the number of layers $L$ and the spectral norm of weight matrices $B _ { w }$ , therefore results in a larger generalization gap and a poor generalization performance..
+
+Table 1: Comparison of uniform stability constant $\epsilon$ of GCN variants, where $\mathcal { O } ( \cdot )$ is used to hide constants that shared between all bounds.   
+
+<table><tr><td></td><td>Pf and Gf</td><td>Lf</td><td>C1 and C2</td></tr><tr><td>EGCN</td><td>O(CHC2)</td><td>O(CIC(L + 2)CIC + 2))</td><td>C1 = max{1,√dBw},C= √d(1+Bx)</td></tr><tr><td>EResGCN</td><td>O(CC2)</td><td>O(CIC2((L + 2)CIC2 + 2))</td><td>C1 =1+ √dBω,C = √d(1+Bx)</td></tr><tr><td>EAPPNP</td><td>0(C1)</td><td>O(Ci(CiC2) +1)</td><td>C1=BqBx,C2=max{1,Bω}</td></tr><tr><td>EGCNII</td><td>O(βCIC2)</td><td>O(aβCIC(αβL +2)CIC+ 2β))</td><td></td></tr><tr><td>EDGCN</td><td>0(C1)</td><td>O(Ci(CiC2) + 1)</td><td>C1 =(√d)LBx,C2 = max{1,Bω}</td></tr></table>
+
+• APPNP alleviates the aforementioned dependency by decoupling the weight parameters and feature propagation. As a result, its generalization gap does not significantly change as $L$ and $B _ { w }$ increase. The optimal $\alpha$ that minimizes the generalization gap can be obtained by finding the $\alpha$ that minimize the term $B _ { d } ^ { \alpha }$ . Although APPNP can significantly reduce the generalization gap, because a single weight matrix is shared between all layers, its expressive power is not enough for large-scale challenging graph datasets [24].
+
+• To gain expressiveness, GCNII proposes to add the weight matrices back and add another hyper-parameter that explicitly controls the dependency on $B _ { w }$ . Although GCNII achieves the state-of-the-art performances on several graph datasets, the selection of hyper-parameters is non-trivial compared to APPNP because $\alpha , \beta$ are coupled with $L , B _ { w }$ , and $d$ . In practice, [6] builds a very deep GCNII by choosing $\beta$ dynamically decreases as the number of layers and different $\alpha$ values for different datasets.
+
+• By property chosen hyper-parameters, we have the following order on the generalization gap given the same training iteration $T$ : $\mathrm { A P P N P } \leq \mathrm { G C N I I } \leq \mathrm { G C N } \leq \mathrm { R e s G C N }$ , which exactly match our empirical evaluation on the generalization gap in Section 7 and Appendix E.
+
+Remark 1. It is worthy to provide an alternative view of DropEdge [47] and PairNorm [61] algorithms from a generalization perspective. To improve the generalization power of standard GCNs, DropEdge randomly drops edges in the training phase, which leads to a smaller maximum node degree $d _ { s } < d$ . PairNorm applies normalization on intermediate node embeddings to ensure that the total pairwise feature distances remain constant across layers, which leads to less dependency on $d$ and $B _ { w }$ . However, since deep GCN requires significantly more iterations to achieve low training error than shallow one, the performance of applying DropEdge and PairNorm on GCNs is still degrading as the number of layers increases. Most importantly, our empirical results in Appendix E.3 and $E . 4$ suggest that applying Dropout and PairNorm is hurting the training accuracy (i.e., not alleviating over-smoothing) but reducing the generalization gap.
+
+# 6 Decoupled GCN
+
+We propose to decouple the expressive power from generalization a(DGCN). The DGCN model can be mathematically formulated as $\begin{array} { r } { \mathbf { Z } \ = \ \sum _ { \ell = 1 } ^ { L } \alpha _ { \ell } f ^ { ( \ell ) } ( \mathbf { X } ) } \end{array}$ GCN and $f ^ { ( \ell ) } ( \mathbf { X } ) = \mathbf { P } ^ { \ell } \mathbf { X } \big ( \beta _ { \ell } \mathbf { W } ^ { ( \ell ) } + ( 1 - \beta _ { \ell } ) \mathbf { I } \big )$ , where $\mathbf { W } ^ { ( \ell ) }$ , $\alpha _ { \ell }$ and $\beta _ { \ell }$ are the learnable weights for \`th layer function $f ^ { ( \ell ) } ( { \mathbf { X } } )$ .7 The design of DGCN has the following key ingredients:
+
+• (Decoupling) The generalization gap in GCN grows exponentially with the number of layers. To overcome this issue, we propose to decouple the weight matrices from propagation by assigning weight $\mathbf { W } ^ { ( \ell ) }$ to each individual layerwise function ${ \bf \nabla } _ { f } ( \ell ) _ { \left( \mathbf { X } \right) }$ . DGCN can be thought of as an ensemble of multiple SGCs [54] with depth from 1 to $L$ . By doing so, the generalization gap has less dependency on the number of weight matrices, and deep models with large receptive fields can incorporate information of the global graph structure. Please refer to Theorem 5 for the details. • (Learnable $\alpha _ { \ell }$ ) After decoupling the weight matrices from feature propagation, the layerwise function $f ^ { ( \ell ) } ( { \mathbf { X } } )$ with more propagation steps can suffer from less expressive power. Therefore, we propose to assign a learnable weight $\alpha _ { \ell }$ for each step of feature propagation. Intuitively, DGCN assigns smaller weight $\alpha _ { \ell }$ to each layerwise function $f ^ { ( \ell ) } ( { \mathbf { X } } )$ with more propagation steps at the beginning of training. Throughout the training, DGCN gradually adjusts the weight to leverage more useful large receptive field information. • (Learnable $\beta _ { \ell }$ ) A learnable weight $\beta _ { \ell } \in [ 0 , 1 ]$ is assigned to each weight matrix to balance the expressiveness with model complexity, which guarantees a better generalization ability.
+
+![](images/88a04fb0f7daceea30a7cea13af4ec513523ab772c3c5f05f55f2616f96d75ea.jpg)  
+Figure 4: Comparison of generalization error on synthetic dataset. The curve early stopped at the largest training accuracy iteration.
+
+Theorem 5. Let suppose DGCN-uniformly stable with $\begin{array} { r } { \epsilon _ { D G C N } = \frac { 2 \eta \rho _ { f } \bar { G } _ { f } } { m } \sum _ { t = 1 } ^ { T } ( 1 + \eta L _ { f } ) ^ { t - 1 } } \end{array}$ $\beta _ { \ell }$ during training. We say DGCN iswhere
+
+$$
+\begin{array} { r } { \rho _ { f } = G _ { f } = \mathcal { O } \Big ( ( \sqrt { d } ) ^ { L } B _ { x } \Big ) , L _ { f } = \mathcal { O } \Big ( ( \sqrt { d } ) ^ { L } B _ { x } \big ( ( \sqrt { d } ) ^ { L } B _ { x } \operatorname* { m a x } \{ 1 , B _ { w } \} + 1 ) \big ) \Big ) . } \end{array}
+$$
+
+The details are deferred to Appendix J, and comparison of bound to other GCN variants are summarized in Table 1. Depending on the automatic selection of $\alpha _ { \ell } , \beta _ { \ell }$ , the generalization bound of DGCN is between APPNP and GCN. In the following, we make connection to many GCN structures:
+
+• Connections to APPNP: APPNP can be thought of as a variant of DGCN. More specifically, the layerwise weight in APPNP is computed as $\alpha _ { \ell } = \alpha ( 1 - \alpha ) ^ { \ell }$ for $\ell < L$ and $\alpha _ { \ell } \stackrel { \cdot } { = } ( 1 - \alpha ) ^ { \cdot }$ for $\ell = L$ given some constant $\alpha \in ( 0 , 1 )$ , and the weight matrix is shared between all layers. Although DGCN has $L$ weight matrices, its generalization is independent of the number of weight matrices, and thus enjoys a low generalization error with high expressiveness.
+
+• Connections to GCNII: GCNII can be regarded as a variant of DGCN. Compared to GCNII, the decoupled propagation of DGCN significantly reduces the dependency of generalization error to the weight matrices. Besides, the learnable weights $\alpha _ { \ell }$ and $\beta _ { \ell }$ allow DGCN to automatically adapt to challenging large-scale datasets without time-consuming hyper-parameter selection.
+
+• Connections to ResGCN: By expanding the forward computation of ResGCN, we know that ResGCN can be think of as training an ensemble of GCNs from 1 to $L$ layer, i.e., $\begin{array} { r } { \mathbf { H } ^ { ( L ) } = \sum _ { \ell = 1 } ^ { L } \alpha _ { \ell } \sigma \big ( \mathbf { P H } ^ { ( \ell - 1 ) } \mathbf { W } ^ { ( \ell ) } \big ) } \end{array}$ with $\alpha _ { \ell } = 1$ . In other word, ResNet can be regarded asL the “summation of the model complexity” of $L$ -layer. However, DGCN is using $\begin{array} { r } { \sum _ { \ell = 1 } ^ { L ^ { - } } \alpha _ { \ell } = 1 } \end{array}$ which can be thought of as a “weighted average of model complexity”. Therefore, ResGCN is a special case of DGCN with equal weights $\alpha _ { \ell }$ on each layerwise function. With just a simple change on the ResNet structure, our model DGCN is both easy to train and good to generalize.
+
+# 7 Experiments
+
+Synthetic dataset. We empirically compare the generalization error of different GCN structures on the synthetic dataset. In particular, we create the synthetic dataset by contextual stochastic block model (CSBM) [13] with two equal-size classes. CSBM is a graph generation algorithm that adds Gaussian random vectors as node features on top of classical SBM. CSBM allows for smooth control over the information ratio between node features and graph topology by a pair of hyper-parameter $( \mu , \lambda )$ , where $\mu$ controls the diversity of the Gaussian distribution and $\lambda$ controls the number of edges between intra- and inter-class nodes. We generate random graphs with 1000 nodes, average node degree as 5, and each node has a Gaussian random vector of dimension 1000 as node features. We chose $7 5 \%$ nodes as training set, $1 5 \%$ of nodes as validation set for hyper-parameter tuning, and the remaining nodes as testing set. We conduct an experiment 20 times by randomly selecting $( \mu , \lambda )$ such that both node feature and graph topology are equally informative.
+
+As shown in Figure 4, we have the following order on the generalization gap given the same training iteration $T$ : $\mathrm { A P P N P } \leq \mathrm { G C N I I } \leq \mathrm { G C N } \leq \mathrm { R e s G C N }$ , which exactly match the theoretical result in Theorem 4. More specifically, ResGCN has the largest generalization gap due to the skip-connections, APPNP has the smallest generalization gap by removing the weight matrices in each individual layer. GCNII achieves a good balance between GCN and APPNP by balancing the expressive and generalization power. Finally, DGCN enjoys a small generalization error by using the decoupled GCN structure.
+
+Open graph benchmark dataset. As pointed out by Hu et al. [24], the traditional commonly-used graph datasets are unable to provide a reliable evaluation due to various factors including dataset size, leakage of node features and no consensus on data splitting. To truly evaluate the expressive and the generalization power of existing methods, we evaluate on the open graph benchmark (OGB) dataset. Experiment setups are based on the default setting for GCN implementation on the leaderboard. We choose the hidden dimension as 128, learning rate as 0.01, dropout ratio as 0.5 for Arxiv dataset, and no dropout for Products and Protein datasets. We train $3 0 0 / 1 0 \mathrm { \bar { 0 } 0 / 5 0 0 }$ epochs for Products, Proteins, and Arxiv dataset respectively. Due to limited GPU memory, the number of layers is selected as the one with the best performance between 2 to 16 layers for Arxiv dataset, 2 to 8 layers for Protein dataset, and 2 to 4 for Products dataset. We choose $\alpha _ { \ell }$ from $\{ 0 . 9 , 0 . 8 , 0 . 5 \}$ for APPNP and GCNII, and use $\beta _ { \ell } = 0 . 5 / \ell$ for GCNII, and select the setup with the best validation result for comparison.
+
+As shown in Table 2, DGCN achieves a compatible performance to $\mathrm { G C N I I ^ { 8 } }$ without the need of manually tuning the hyper-parameters for all settings, and it significantly outperform APPNP and ResGCN. Due to the space limit, the detailed setups and more results can be found in Appendix E. Notice that generalization bounds are more valuable when comparing two models with same training accuracy (therefore we first show in Section 4 that deeper model can also achieve low training error before our discussion on generalization in Section 5).
+
+In Table 2, because ResGCN has no restriction on the weight matrices, it can achieve lower training error and its test performance is mainly restricted by its generalization error. However, because GCNII and APPNP have restrictions on the weight matrices, their performance is mainly restricted by their training error. A model with small generalization error and no restriction on the weight (e.g., DGCN)
+
+Table 2: Comparison of F1-score on OGB dataset.   
+
+<table><tr><td>%</td><td>Products</td><td>Proteins</td><td>Arvix</td></tr><tr><td>GCN</td><td>75.39 ± 0.21</td><td>71.66 ± 0.48</td><td>71.56 ± 0.19</td></tr><tr><td>ResGCN</td><td>75.53 ± 0.12</td><td>74.50 ± 0.41</td><td>72.56 ± 0.31</td></tr><tr><td>APPNP</td><td>66.35±0.10</td><td>71.78±0.29</td><td>68.02 ±0.55</td></tr><tr><td>GCNII</td><td>71.93 ± 0.35t</td><td>75.60±0.47</td><td>72.57 ± 0.23‡</td></tr><tr><td>DGCN</td><td>76.09 ± 0.29</td><td>75.45 ± 0.24</td><td>72.63± 0.12</td></tr></table>
+
+is preferred as it has higher potential to reach a better test accuracy by reducing its training error.
+
+# 8 Conclusion
+
+In this work, we show that there exists a discrepancy between over-smoothing based theoretical results and the practical behavior of deep GCNs. Our theoretical result shows that a deeper GCN can be as expressive as a shallow GCN, if it is properly trained. To truly understand the performance decay issue of deep GCNs, we provide the first transductive uniform stability-based generalization analysis of GCNs and other GCN structures. To improve the optimization issue and benefit from depth, we propose DGCN that enjoys a provable high expressive power and generalization power. We conduct empirical evaluations on various synthetic and real-world datasets to validate the correctness of our theory and advantages over the baselines.
+
+# Acknowledgements
+
+This work was supported in part by NSF grant 2008398.
+
+# References
+
+[1] Uri Alon and Eran Yahav. On the bottleneck of graph neural networks and its practical implications. In International Conference on Learning Representations, 2020.   
+[2] Rianne van den Berg, Thomas N Kipf, and Max Welling. Graph convolutional matrix completion. arXiv preprint arXiv:1706.02263, 2017.   
+[3] Olivier Bousquet and André Elisseeff. Stability and generalization. Journal of machine learning research, 2(Mar):499–526, 2002.   
+[4] Chen Cai and Yusu Wang. A note on over-smoothing for graph neural networks. arXiv preprint arXiv:2006.13318, 2020.   
+[5] Lei Chen, Zhengdao Chen, and Joan Bruna. On graph neural networks versus graph-augmented mlps. In International Conference on Learning Representations, 2020.   
+[6] Ming Chen, Zhewei Wei, Zengfeng Huang, Bolin Ding, and Yaliang Li. Simple and deep graph convolutional networks. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 1725–1735. PMLR, 2020.   
+[7] Zhengdao Chen, Lei Chen, Soledad Villar, and Joan Bruna. Can graph neural networks count substructures? In Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020.   
+[8] Eli Chien, Jianhao Peng, Pan Li, and Olgica Milenkovic. Adaptive universal generalized pagerank graph neural network. 2021.   
+[9] Weilin Cong, Rana Forsati, Mahmut T. Kandemir, and Mehrdad Mahdavi. Minimal variance sampling with provable guarantees for fast training of graph neural networks. In KDD ’20: The 26th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, Virtual Event, CA, USA, August 23-27, 2020, pages 1393–1403. ACM, 2020.   
+[10] Zhiyong Cui, Kristian Henrickson, Ruimin Ke, and Yinhai Wang. Traffic graph convolutional recurrent neural network: A deep learning framework for network-scale traffic learning and forecasting. IEEE Transactions on Intelligent Transportation Systems, 2019.   
+[11] Kenneth R Davidson and Stanislaw J Szarek. Local operator theory, random matrices and banach spaces. Handbook of the geometry of Banach spaces, 1(317-366):131, 2001.   
+[12] Songgaojun Deng, Huzefa Rangwala, and Yue Ning. Learning dynamic context graphs for predicting social events. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 1007–1016. ACM, 2019.   
+[13] Yash Deshpande, Subhabrata Sen, Andrea Montanari, and Elchanan Mossel. Contextual stochastic block models. In Advances in Neural Information Processing Systems 31: Annual Conference on Neural Information Processing Systems 2018, NeurIPS 2018, December 3-8, 2018, Montréal, Canada, pages 8590–8602, 2018.   
+[14] Kien Do, Truyen Tran, and Svetha Venkatesh. Graph transformation policy network for chemical reaction prediction. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 750–760. ACM, 2019.   
+[15] Simon S. Du, Kangcheng Hou, Ruslan Salakhutdinov, Barnabás Póczos, Ruosong Wang, and Keyulu Xu. Graph neural tangent kernel: Fusing graph neural networks with graph kernels. In Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, pages 5724–5734, 2019.   
+[16] David Duvenaud, Dougal Maclaurin, Jorge Aguilera-Iparraguirre, Rafael Gómez-Bombarelli, Timothy Hirzel, Alán Aspuru-Guzik, and Ryan P. Adams. Convolutional networks on graphs for learning molecular fingerprints. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pages 2224–2232, 2015.   
+[17] Ran El-Yaniv and Dmitry Pechyony. Stable transductive learning. In Learning Theory, 19th Annual Conference on Learning Theory, COLT 2006, Pittsburgh, PA, USA, June 22-25, 2006, Proceedings, volume 4005 of Lecture Notes in Computer Science, pages 35–49. Springer, 2006.   
+[18] Vikas K. Garg, Stefanie Jegelka, and Tommi S. Jaakkola. Generalization and representational limits of graph neural networks. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 3419–3430. PMLR, 2020.   
+[19] Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pages 249–256. JMLR Workshop and Conference Proceedings, 2010.   
+[20] Shunwang Gong, Mehdi Bahri, Michael M. Bronstein, and Stefanos Zafeiriou. Geometrically principled connections in graph neural networks. In 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR 2020, Seattle, WA, USA, June 13-19, 2020, pages 11412–11421. IEEE, 2020.   
+[21] William L. Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 1024–1034, 2017.   
+[22] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In 2015 IEEE International Conference on Computer Vision, ICCV 2015, Santiago, Chile, December 7-13, 2015, pages 1026–1034. IEEE Computer Society, 2015.   
+[23] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2016, Las Vegas, NV, USA, June 27-30, 2016, pages 770–778. IEEE Computer Society, 2016.   
+[24] Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. In Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020.   
+[25] Wei Huang, Yayong Li, Weitao Du, Richard Yi Da Xu, Jie Yin, and Ling Chen. Wide graph neural networks: Aggregation provably leads to exponentially trainability loss. arXiv preprint arXiv:2103.03113, 2021.   
+[26] Wenbing Huang, Yu Rong, Tingyang Xu, Fuchun Sun, and Junzhou Huang. Tackling oversmoothing for general graph convolutional networks. arXiv e-prints, pages arXiv–2008, 2020.   
+[27] Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015.   
+[28] Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017.   
+[29] Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.   
+[30] Kezhi Kong, Guohao Li, Mucong Ding, Zuxuan Wu, Chen Zhu, Bernard Ghanem, Gavin Taylor, and Tom Goldstein. Flag: Adversarial data augmentation for graph neural networks. arXiv preprint arXiv:2010.09891, 2020.   
+[31] Srijan Kumar, Xikun Zhang, and Jure Leskovec. Predicting dynamic embedding trajectory in temporal interaction networks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 1269–1278. ACM, 2019.   
+[32] AA Leman and B Weisfeiler. A reduction of a graph to a canonical form and an algebra arising during this reduction. Nauchno-Technicheskaya Informatsiya, 2(9):12–16, 1968.   
+[33] Guohao Li, Matthias Müller, Ali K. Thabet, and Bernard Ghanem. Deepgcns: Can gcns go as deep as cnns? In 2019 IEEE/CVF International Conference on Computer Vision, ICCV 2019, Seoul, Korea (South), October 27 - November 2, 2019, pages 9266–9275. IEEE, 2019.   
+[34] Jia Li, Zhichao Han, Hong Cheng, Jiao Su, Pengyun Wang, Jianfeng Zhang, and Lujia Pan. Predicting path failure in time-evolving graphs. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 1279–1289. ACM, 2019.   
+[35] Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi-supervised learning. In Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence, (AAAI-18), the 30th innovative Applications of Artificial Intelligence (IAAI-18), and the 8th AAAI Symposium on Educational Advances in Artificial Intelligence (EAAI-18), New Orleans, Louisiana, USA, February 2-7, 2018, pages 3538–3545. AAAI Press, 2018.   
+[36] Renjie Liao, Raquel Urtasun, and Richard Zemel. A pac-bayesian approach to generalization bounds for graph neural networks. arXiv preprint arXiv:2012.07690, 2020.   
+[37] Andreas Loukas. What graph neural networks cannot learn: depth vs width. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   
+[38] Sitao Luan, Mingde Zhao, Xiao-Wen Chang, and Doina Precup. Training matters: Unlocking potentials of deeper graph convolutional neural networks. arXiv preprint arXiv:2008.08838, 2020.   
+[39] Christopher Morris, Martin Ritzert, Matthias Fey, William L. Hamilton, Jan Eric Lenssen, Gaurav Rattan, and Martin Grohe. Weisfeiler and leman go neural: Higher-order graph neural networks. In The Thirty-Third AAAI Conference on Artificial Intelligence, AAAI 2019, The Thirty-First Innovative Applications of Artificial Intelligence Conference, IAAI 2019, The Ninth AAAI Symposium on Educational Advances in Artificial Intelligence, EAAI 2019, Honolulu, Hawaii, USA, January 27 - February 1, 2019, pages 4602–4609. AAAI Press, 2019.   
+[40] Quynh Nguyen. On the proof of global convergence of gradient descent for deep relu networks with linear widths. arXiv preprint arXiv:2101.09612, 2021.   
+[41] Kenta Oono and Taiji Suzuki. Graph neural networks exponentially lose expressive power for node classification. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   
+[42] Kenta Oono and Taiji Suzuki. Optimization and generalization analysis of transduction through gradient boosting and application to multi-scale graph neural networks. Advances in Neural Information Processing Systems, 33, 2020.   
+[43] Namyong Park, Andrey Kan, Xin Luna Dong, Tong Zhao, and Christos Faloutsos. Estimating node importance in knowledge graphs using graph neural networks. In Proceedings of the $2 5 t h$ ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 596–606. ACM, 2019.   
+[44] Jiezhong Qiu, Jian Tang, Hao Ma, Yuxiao Dong, Kuansan Wang, and Jie Tang. Deepinf: Modeling influence locality in large social networks. In KDD, 2018.   
+[45] Afshin Rahimi, Trevor Cohn, and Timothy Baldwin. Semi-supervised user geolocation via graph convolutional networks. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 2009–2019. Association for Computational Linguistics, 2018.   
+[46] Morteza Ramezani, Weilin Cong, Mehrdad Mahdavi, Anand Sivasubramaniam, and Mahmut Kandemir. Gcn meets gpu: Decoupling “when to sample” from “how to sample”. Advances in Neural Information Processing Systems, 33, 2020.   
+[47] Yu Rong, Wenbing Huang, Tingyang Xu, and Junzhou Huang. Dropedge: Towards deep graph convolutional networks on node classification. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   
+[48] Ruslan Salakhutdinov. Deep learning. In The 20th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’14, New York, NY, USA - August 24 - 27, 2014, page 1973. ACM, 2014.   
+[49] Franco Scarselli, Ah Chung Tsoi, and Markus Hagenbuchner. The vapnik–chervonenkis dimension of graph and recursive neural networks. Neural Networks, 108:248–259, 2018.   
+[50] Saurabh Verma and Zhi-Li Zhang. Stability and generalization of graph convolutional neural networks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 1539– 1548. ACM, 2019.   
+[51] Hao Wang, Tong Xu, Qi Liu, Defu Lian, Enhong Chen, Dongfang Du, Han Wu, and Wen Su. MCNE: an end-to-end framework for learning multiple conditional network representations of social network. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 1064–1072. ACM, 2019.   
+[52] Hongwei Wang, Fuzheng Zhang, Mengdi Zhang, Jure Leskovec, Miao Zhao, Wenjie Li, and Zhongyuan Wang. Knowledge-aware graph neural networks with label smoothness regularization for recommender systems. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 968–977. ACM, 2019.   
+[53] Xiang Wang, Xiangnan He, Yixin Cao, Meng Liu, and Tat-Seng Chua. KGAT: knowledge graph attention network for recommendation. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 950–958. ACM, 2019.   
+[54] Felix Wu, Amauri H. Souza Jr., Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Q. Weinberger. Simplifying graph convolutional networks. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pages 6861–6871. PMLR, 2019.   
+[55] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.   
+[56] Keyulu Xu, Jingling Li, Mozhi Zhang, Simon S. Du, Ken-ichi Kawarabayashi, and Stefanie Jegelka. What can neural networks reason about? In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   
+[57] Keyulu Xu, Mozhi Zhang, Jingling Li, Simon Shaolei Du, Ken-Ichi Kawarabayashi, and Stefanie Jegelka. How neural networks extrapolate: From feedforward to graph neural networks. In International Conference on Learning Representations, 2021.   
+[58] Yujun Yan, Milad Hashemi, Kevin Swersky, Yaoqing Yang, and Danai Koutra. Two sides of the same coin: Heterophily and oversmoothing in graph convolutional neural networks. arXiv preprint arXiv:2102.06462, 2021.   
+[59] Chaoqi Yang, Ruijie Wang, Shuochao Yao, Shengzhong Liu, and Tarek Abdelzaher. Revisiting" over-smoothing" in deep gcns. arXiv preprint arXiv:2003.13663, 2020.   
+[60] Rex Ying, Ruining He, Kaifeng Chen, Pong Eksombatchai, William L. Hamilton, and Jure Leskovec. Graph convolutional neural networks for web-scale recommender systems. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2018, London, UK, August 19-23, 2018, pages 974–983. ACM, 2018.   
+[61] Lingxiao Zhao and Leman Akoglu. Pairnorm: Tackling oversmoothing in gnns. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   
+[62] Kuangqi Zhou, Yanfei Dong, Wee Sun Lee, Bryan Hooi, Huan Xu, and Jiashi Feng. Effective training strategies for deep graph neural networks. arXiv preprint arXiv:2006.07107, 2020.   
+[63] Xianchen Zhou and Hongxia Wang. The generalization error of graph convolutional networks may enlarge with more layers. Neurocomputing, 424:97–106, 2021.

parse/train/r-oRRT-ElX/r-oRRT-ElX_content_list.json

@@ -0,0 +1,1091 @@
+[
+    {
+        "type": "text",
+        "text": "On Provable Benefits of Depth in Training Graph Convolutional Networks ",
+        "text_level": 1,
+        "bbox": [
+            243,
+            122,
+            753,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Weilin Cong Penn State wxc272@psu.edu ",
+        "bbox": [
+            228,
+            226,
+            349,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Morteza Ramezani Penn State morteza@cse.psu.edu ",
+        "bbox": [
+            410,
+            226,
+            575,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mehrdad MahdaviPenn Statemzm616@psu.edu",
+        "bbox": [
+            637,
+            226,
+            769,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            304,
+            535,
+            320
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph Convolutional Networks (GCNs) are known to suffer from performance degradation as the number of layers increases, which is usually attributed to oversmoothing. Despite the apparent consensus, we observe that there exists a discrepancy between the theoretical understanding of over-smoothing and the practical capabilities of GCNs. Specifically, we argue that over-smoothing does not necessarily happen in practice, a deeper model is provably expressive, can converge to global optimum with linear convergence rate, and achieve very high training accuracy as long as properly trained. Despite being capable of achieving high training accuracy, empirical results show that the deeper models generalize poorly on the testing stage and existing theoretical understanding of such behavior remains elusive. To achieve better understanding, we carefully analyze the generalization capability of GCNs, and show that the training strategies to achieve high training accuracy significantly deteriorate the generalization capability of GCNs. Motivated by these findings, we propose a decoupled structure for GCNs that detaches weight matrices from feature propagation to preserve the expressive power and ensure good generalization performance. We conduct empirical evaluations on various synthetic and real-world datasets to validate the correctness of our theory. ",
+        "bbox": [
+            233,
+            334,
+            766,
+            569
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            593,
+            310,
+            611
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In recent years, Graph Convolutional Networks (GCNs) have achieved state-of-the-art performance in dealing with graph-structured applications, including social networks [28, 21, 51, 12, 44], traffic prediction [10, 45, 34, 31], knowledge graphs [52, 53, 43], drug reaction [14, 16] and recommendation system [2, 60]. Despite the success of GCNs, applying a shallow GCN model that only uses the information of a very limited neighborhood on a large sparse graph has shown to be not effective [23, 6, 20, 9, 46]. As a result, a deeper GCN model would be desirable to reach and aggregate information from farther neighbors. The inefficiency of shallow GCNs is exacerbated even further when the labeled nodes compared to graph size is negligible, as a shallow GCN cannot sufficiently propagate the label information to the entire graph with only a few available labels [35]. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            751
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Although a deeper GCN is preferred to perceive more graph structure information, unlike traditional deep neural networks, it has been pointed out that deeper GCNs potentially suffer from oversmoothing [35, 41, 26, 4, 58], vanishing/exploding gradients [33], over-squashing [1], and training difficulties [62, 38], which significantly affect the performance of GCNs as the depth increases. Among these, the most widely accepted reason is “over-smoothing”, which is referred to as a phenomenon due to applying multiple graph convolutions such that all node embeddings converge to a single subspace (or vector) and leads to indistinguishable node representations. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            853
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The conventional wisdom is that adding to the number of layers causes over-smoothing, which impairs the expressiveness power of GCNs and consequently leads to a poor training accuracy. However, we observe that there exists a discrepancy between theoretical understanding of their inherent capabilities and practical performances. According to the definition of over-smoothing that the node representation becomes indistinguishable as GCNs goes deeper, the classifier has difficulty assigning the correct label for each node if over-smoothing happens. As a result, the training accuracy is expected to be decreasing as the number of layers increases. However, as shown in Figure 1, GCNs are capable of achieving high training accuracy regardless of the number of layers. But, as it can be observed, deeper GCNs require more training iterations to reach a high training accuracy, and its generalization performance on evaluation set decreases as the number of layers increases. This observation suggests that the performance degradation is likely due to inappropriate training rather than the low expressive power caused by over-smoothing. Otherwise, a low expressiveness model cannot achieve almost perfect training accuracy simply by proper training tricks alone.1 Indeed, recent years significant advances have been witnessed on tweaking the model architecture to overcome the training difficulties in deeper GCN models and achieve good generalization performance [38, 6, 33, 62]. ",
+        "bbox": [
+            176,
+            859,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/d96dabd61d79d6401e80639fa13156cc6e9e472b4caf09be8035395a98d70400.jpg",
+        "image_caption": [
+            "Figure 1: Comparison of F1-score for GCN with different depth on Cora dataset, where deeper models can achieve high training accuracy, but complicate the training by requiring more iterations to converge and suffer from poor generalization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            89,
+            740,
+            210
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            286,
+            825,
+            452
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions. Motivated by aforementioned observation, i.e., still achieving high training accuracy when trained properly but poor generalization performance, we aim at answering two fundamental questions in this paper: ",
+        "bbox": [
+            174,
+            458,
+            825,
+            500
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Q1: Does increasing depth really impair the expressiveness power of GCNs? In Section 4, we argue that there exists a discrepancy between over-smoothing based theoretical results and the practical capabilities of deep GCN models, demonstrating that over-smoothing is not the key factor that leads to the performance degradation in deeper GCNs. In particular, we mathematically show that over-smoothing [41, 26, 35, 4] is mainly an artifact of theoretical analysis and simplifications made in analysis. Indeed, by characterizing the representational capacity of GCNs via Weisfeiler-Lehman (WL) graph isomorphism test [39, 55], we show that deeper GCN model is at least as expressive as the shallow GCN model, the deeper GCN models can distinguish nodes with a different neighborhood that the shallow GCN cannot distinguish, as long as the GCNs are properly trained. Besides, we theoretically show that more training iterations is sufficient (but not necessary due to the assumptions made in our theoretical analysis) for a deeper model to achieve the same training error as the shallow ones, which further suggests the poor training error in deep GCN training is most likely due to inappropriate training. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            686
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Q2: If expressive, why then deep GCNs generalize poorly? ",
+        "bbox": [
+            176,
+            693,
+            558,
+            707
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In Section 5, in order to understand the performance degradation phenomenon in deep GCNs during the evaluation phase, we give a novel generalization analysis on GCNs and its variants (e.g., ResGCN, APPNP, and GCNII) under the semi-supervised setting for the node classification task. We show that the generalization gap of GCNs is governed by the number of training iterations, largest node degree, the largest singular value of weight matrices, and the number of layers. In particular, our result suggests that a deeper GCN model requires more iterations of training and optimization tricks to converge (e.g., adding skip-connections), which leads to a poor generalization. More interestingly, our generalization analysis shows that most of the so-called methods to solve oversmoothing [47, 61, 6, 29] can greatly improve the generalization ability of the model, therefore results in a deeper model. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            844
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The aforementioned findings naturally lead to the algorithmic contribution of this paper. In Section 6, we present a novel framework, Decoupled GCN (DGCN), that is capable of training deeper GCNs and can significantly improve the generalization performance. The main idea is to isolate the expressive power from generalization ability by decoupling the weight parameters from feature propagation. In Section 7, we conduct experiments on the synthetic and real-world datasets to validate the correctness of the theoretical analysis and the advantages of DGCN over baseline methods. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related works ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            204,
+            325,
+            220
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Expressivity of GCNs. Existing results on expressive power of GCNs are mixed, [39, 37, 7, 5] argue that deeper model has higher expressive power but [41, 26, 25] have completely opposite result. On the one hand, [39] shows a deeper GCN is as least as powerful as the shallow one in terms of distinguishing non-isomorphic graphs. [37] shows that deep and wide GCNs is Turing universal, however, GCNs lose power when their depth and width are restricted. [7] and [5] measure the expressive power of GCNs via its subgraph counting capability and attribute walks, and both show the expressive power of GCNs grows exponentially with the GCN depth. On the other hand, [25] studies the infinity wide GCNs and shows that the covariance matrix of its outputs converges to a constant matrix at an exponential rate. [41, 26] characterize the expressive power using the distance between node embeddings to a node feature agnostic subspace and show the distance is decreasing as the number of layers increases. Details are deferred to Section 4 and Appendix B. Such contradictory results motivate us to rethink the role of over-smoothing on expressiveness. ",
+        "bbox": [
+            174,
+            241,
+            825,
+            406
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Generalization analysis of GCNs. In recent years, many papers are working on the generalization of GCNs using uniform stability [50, 63], Neural Tangent Kernel [15], VC-dimension [49], Rademacher complexity [18, 42], algorithm alignment [56, 57] and PAC-Bayesian [36]. Existing works only focus on a specific GCN structure, which cannot be used to understand the impact of GCN structures on its generalization ability. The most closely related to ours is [50], where they analyze the stability of the single-layer GCN model, and show that the stability of GCN depends on the largest absolute eigenvalue of its Laplacian matrix. However, their result is under the inductive learning setting and extending the results to the multi-layer GCNs with different structures is non-trivial. ",
+        "bbox": [
+            174,
+            414,
+            825,
+            525
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Literature with similar observations. Most recently, several works have similar observations on the over-smoothing issue to ours. [62] argues that the main factors to performance degradation are vanishing gradient, training instability, and over-fitting, rather than over-smoothing, and proposes a node embedding normalization heuristic to alleviate the aforementioned issues. [38] argues that the performance degradation is mainly due to the training difficulty, and proposes a different graph Laplacian formulation, weight parameter initialization, and skip-connections to improve the training difficulty. [59] argues that deep GCNs can learn to overcome the over-smoothing issue during training, and the key factor of performance degradation is over-fitting, and proposes a node embedding normalization method to help deep GCNs overcome the over-smoothing issue. [30] improves the generalization ability of GCNs by using adversarial training and results in a consistent improvement than all GCNs baseline models without adversarial training. All aforementioned literature only gives heuristic explanations based on the empirical results, and do not provide theoretical arguments. ",
+        "bbox": [
+            174,
+            530,
+            825,
+            696
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            726,
+            318,
+            743
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Notations and setup. We consider the semi-supervised node classification problem, where a selfconnected graph $\\mathcal { G } = ( \\nu , \\mathcal { E } )$ with $N = | \\nu |$ nodes is given in which each node $i \\in \\nu$ is associated with a feature vector $\\mathbf { x } _ { i } \\in \\mathbb { R } ^ { d _ { 0 } }$ , and only a subset of nodes $\\mathcal { V } _ { \\mathrm { t r a i n } } \\subset \\mathcal { V }$ are labeled, i.e., $y _ { i } \\in \\{ 1 , \\ldots , | { \\mathcal { C } } | \\}$ for each $i \\in \\mathcal { V } _ { \\mathrm { t r a i n } }$ and $\\mathcal { C }$ is the set of all candidate classes. Let $\\mathbf { A } \\in \\mathbb { R } ^ { N \\times N }$ denote the adjacency matrix and $\\mathbf { D } \\in \\mathbb { R } ^ { N \\times N }$ denote the corresponding degree matrix with $D _ { i , i } = \\deg ( i )$ and $D _ { i , j } = 0$ if $i \\neq j$ . Then, the propagation matrix (using the Laplacian matrix defined in [28]) is computed as $\\mathbf { P } = \\mathbf { D } ^ { - 1 / 2 } \\mathbf { A } \\mathbf { D } ^ { - 1 / 2 }$ . Our goal is to learn a GCN model using the node features for all nodes $\\{ { \\bf x } _ { i } \\} _ { i \\in \\mathcal { V } }$ and node labels for the training set nodes $\\{ y _ { i } \\} _ { i \\in \\mathcal { V } _ { \\operatorname { t r a i n } } }$ , and expect it generalizes well on the unlabeled node set $\\mathcal { V } _ { \\mathrm { t e s t } } = \\mathcal { V } \\setminus \\mathcal { V } _ { \\mathrm { t r a i n } }$ . ",
+        "bbox": [
+            174,
+            762,
+            825,
+            892
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "GCN architectures. In this paper, we consider the following architectures for training GCNs: ",
+        "bbox": [
+            169,
+            897,
+            792,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/1060240432cfbec674f54ca5828faa36688caf668156a8b6d68ff12171d6b3cb.jpg",
+        "image_caption": [
+            "Figure 2: Comparison of intra- and inter-class normalized node embeddings $\\mathbf { H } ^ { ( \\ell ) } / \\| \\mathbf { H } ^ { ( \\ell ) } \\| _ { \\mathrm { F } }$ pairwise distance on Cora dataset. See Appendix A for more evidences. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            88,
+            748,
+            223
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Vanilla GCN [28] computes node embeddings by $\\mathbf { H } ^ { ( \\ell ) } = \\sigma ( \\mathbf { P H } ^ { ( \\ell - 1 ) } \\mathbf { W } ^ { ( \\ell ) } )$ , where $\\mathbf { H } ^ { ( \\ell ) } =$ $\\{ \\mathbf { h } _ { i } ^ { ( \\ell ) } \\} _ { i = 1 } ^ { N }$ is the \\`th layer node embedding matrix, $\\mathbf { h } _ { i } ^ { ( \\ell ) } \\in \\mathbb { R } ^ { d _ { \\ell } }$ is the embedding of $i$ th node, $\\mathbf { W } ^ { ( \\ell ) } \\in \\mathbb { R } ^ { d _ { \\ell } \\times d _ { \\ell - 1 } }$ is the \\`th layer weight matrix, and $\\sigma ( \\cdot )$ is the ReLU activation. ",
+        "bbox": [
+            183,
+            282,
+            825,
+            332
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• ResGCN [33] solves the vanishing gradient issue by adding skip-connections between adjacency layers. More specifically, ResGCN computes node embeddings by $\\mathbf { H } ^ { ( \\ell ) } = \\sigma ( \\mathbf { P H } ^ { ( \\ell - 1 ) } \\mathbf { \\dot { W } } ^ { ( \\ell ) } ) \\dot { + }$ $\\mathbf { H } ^ { ( \\ell - 1 ) }$ No fully connected layer after node feature, where node embeddings of the previous layer is added to the output of the current layer to facilitate the training of deeper GCN models. ",
+        "bbox": [
+            184,
+            332,
+            825,
+            388
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• APPNP [29] adds skip-connections from the input layer to each hidden layer to preserve the feature information. APPNP computes node embeddings by $\\mathbf { H } ^ { ( \\ell ) } = \\alpha _ { \\ell } \\mathbf { P } \\mathbf { H } ^ { ( \\ell - 1 ) } + ( \\mathbf { \\bar { l } } - \\alpha _ { \\ell } ) \\mathbf { H } ^ { ( 0 ) } \\mathbf { W }$ , where $\\alpha _ { \\ell } \\in [ 0 , 1 ]$ balances the amount of information preserved at each layer. By decoupling feature transformation and propagation, APPNP can aggregate information from multi-hop neighbors without significantly increasing the computation complexity. ",
+        "bbox": [
+            183,
+            390,
+            825,
+            459
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• GCNII [6] improves the capacity of APPNP by adding non-linearty and weight matrix at each individual layer. GCNII computes node embeddings by $\\mathbf { H } ^ { ( \\ell ) } = \\bar { \\sigma } \\big ( ( \\alpha _ { \\ell } \\mathbf { P } \\bar { \\mathbf { H } ^ { ( \\ell - 1 ) } } + ( 1 -$ $\\alpha _ { \\ell } ) \\mathbf { H } ^ { ( 0 ) } ) \\bar { \\mathbf { W } } ^ { ( \\ell ) } )$ , where $\\bar { \\mathbf { W } } ^ { ( \\ell ) } = \\beta _ { \\ell } \\mathbf { W } ^ { ( \\ell ) } + ( 1 - \\beta _ { \\ell } ) \\mathbf { I }$ , constant $\\alpha _ { \\ell }$ same as APPNP, and constant $\\beta _ { \\ell } \\in [ 0 , 1 ]$ restricts the power of \\`th layer parameters. ",
+        "bbox": [
+            183,
+            460,
+            825,
+            521
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 On true expressiveness and optimization landscape of deep GCNs ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            541,
+            751,
+            559
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Empirical validation of over-smoothing. In this section, we aim at answering the following fundamental question: “Does over-smoothing really cause the performance degradation in deeper $G C N s ? ^ { \\prime \\prime }$ As first defined in [35], over-smoothing is referred to as a phenomenon where all node embeddings converge to a single vector after applying multiple graph convolution operations to the node features. However, [35] only considers the graph convolution operation without non-linearity and the per-layer weight matrices. To verify whether over-smoothing exists in normal GCNs, we measure the pairwise distance between the normalized node embeddings with varying the model depth.2 As shown in Figure 2, without the weight matrices and non-linear activation functions, the pairwise distance between node embeddings indeed decreases as the number of layers increases. However, by considering the weight matrices and non-linearity, the pairwise distances are actually increasing after a certain depth which contradicts the definition of over-smoothing that node embeddings become indistinguishable when the model becomes deeper. That is, graph convolution makes adjacent node embeddings get closer, then non-linearity and weight matrices help node embeddings preserve distinguishing-ability after convolution. ",
+        "bbox": [
+            173,
+            573,
+            825,
+            766
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Most recently, [41, 26] generalize the idea of over-smoothing by taking both the non-linearity and weight matrices into considerations. More specifically, the expressive power of the \\`th layer node embeddings $\\mathbf { H } ^ { ( \\ell ) }$ is measured using $d _ { \\mathcal { M } } ( \\mathbf { H } ^ { ( \\ell ) } )$ , which is defined as the distance of node embeddings to a subspace $\\mathcal { M }$ that only has node degree information. Let denote $\\lambda _ { L }$ as the second largest eigenvalue of graph Laplacian and $\\lambda _ { W }$ as the largest singular value of weight matrices. [41, 26] show that the expressive power $d _ { \\mathcal { M } } ( \\mathbf { H } ^ { ( \\ell ) } )$ is bounded by $d _ { \\mathcal { M } } ( \\mathbf { H } ^ { ( \\ell ) } ) \\leq ( \\lambda _ { W } \\lambda _ { L } ) ^ { \\ell } \\cdot d _ { \\mathcal { M } } ( \\mathbf { X } )$ , i.e., the expressive power of node embeddings will be exponentially decreasing or increasing as the number of layers increases, depending on whether $\\lambda _ { W } \\lambda _ { L } < 1$ or $\\lambda _ { W } \\lambda _ { L } > 1$ . They conclude that deeper GCN exponentially loss expressive power by assuming $\\lambda _ { W } \\lambda _ { L } < 1$ . However, we argue that this assumption does not always hold. To see this, let suppose $\\mathbf { W } ^ { ( \\ell ) } \\in \\mathbb { R } ^ { d _ { \\ell - 1 } \\times d _ { \\ell } }$ is initialized by uniform distribution $\\mathcal { N } ( 0 , \\sqrt { 1 / d _ { \\ell - 1 } } )$ . By the Gordon’s theorem for Gaussian matrices [11], we know its expected largest singular value is bounded by $\\mathbb { E } [ \\lambda _ { W } ] \\le 1 + \\sqrt { d _ { \\ell } / d _ { \\ell - 1 } }$ , which is strictly greater than 1 and $\\lambda _ { W }$ usually increases during training. The above discussion also holds for other commonly used initialization methods [19, 22]. Furthermore, since most real world graphs are sparse with $\\lambda _ { L }$ close to 1, e.g., Cora has $\\lambda _ { L } = 0 . 9 9 6 4$ , Citeseer has $\\lambda _ { L } = 0 . 9 9 8 7$ , and Pubmed has $\\lambda _ { L } = 0 . 9 9 0 5$ , making assumption on $\\lambda _ { W } \\lambda _ { L } < 1$ is not realistic. As shown in Figure 3, when increasing the number of layers, we observe that the distance $d _ { \\mathcal { M } } ( \\mathbf { H } ^ { ( \\ell ) } )$ is decreasing on untrained-GCN models, however, the distance $d _ { \\mathcal { M } } ( \\mathbf { H } ^ { ( \\ell ) } )$ is increasing on trained-GCN models, which contradicts the conclusion in [41]. Due to the space limit, we defer the more empirical evidence to Appendix B. Through these findings, we cast doubt on the power of over-smoothing based analysis to provide a complete picture of why deep GCNs perform badly. ",
+        "bbox": [
+            173,
+            772,
+            825,
+            873
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/84e24a192bc5e80db4a4ccfceccfa7007c39202a2f0d6209d2870a24585057cf.jpg",
+        "image_caption": [
+            "Figure 3: Compare $d _ { \\mathcal { M } } ( \\mathbf { H } ^ { ( \\ell ) } )$ and $\\lambda _ { W } ( \\mathbf { W } ^ { ( \\ell ) } )$ on both trained- (using 500 gradient update) and untrained-GCN models on Cora dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            87,
+            758,
+            223
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            290,
+            825,
+            493
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Definition 1. Let $\\mathcal { T } _ { i } ^ { L }$ denote the $L$ -layer computation tree of node $i$ , which represents the structured $L$ -hop neighbors of node $i$ , where the children of any node $j$ in the tree are the nodes in $\\mathcal { N } ( i )$ . ",
+        "bbox": [
+            174,
+            498,
+            823,
+            527
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Exponentially growing expressieness without strong assumptions. Indeed, we argue that deeper GCNs have stronger expressive power than the shallow GCNs. To prove this, we employ the connection between WL test3 [32] and GCNs. Recently, [39] shows that GCNs have the same expressiveness as the WL-test for graph isomorphism if they are appropriately trained, i.e., a properly trained $L$ -layer GCN computes different node representations for two nodes if their $L$ -layer computation tree (Definition 1) have different structure or different features on the corresponding nodes. Since $L$ -GCN can encode any different computation tree into different representations, it is natural to characterize the expressiveness of $L$ -GCN by the number of computation graph it can encode. ",
+        "bbox": [
+            173,
+            540,
+            825,
+            650
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. Suppose $\\mathcal { T } ^ { L }$ is a computation tree with binary node features and node degree at least d. Then, by assuming the computation tree of two nodes are disjoint, the richness (i.e., the number of computation graphs a model can encode) of the output of $L$ -GCN defined on $\\mathcal { T } ^ { L }$ is at least $| \\bar { L } \\bar { - } G C \\bar { N } ( \\bar { \\cal T } ^ { L } ) | \\geq 2 ( \\bar { d } - 1 ) ^ { L - 1 }$ . ",
+        "bbox": [
+            174,
+            655,
+            825,
+            712
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The proof is deferred to Appendix C. The above theorem implies that the richness of $L$ -GCN grows at least exponentially with respect to the number of layers. ",
+        "bbox": [
+            173,
+            724,
+            821,
+            752
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Comparison of expressiveness metrics. Although distance-based expressiveness metric [41, 26] is strong than WL-based metric in the sense that node embeddings can be distinct but close to each other, the distance-based metric requires explicit assumptions on the GCN structures, weight matrices, and graph structures comparing to the WL-based metric, which has been shown that are not likely hold. On the other hand, WL-based metric has been widely used in characterizing the expressive power of GCNs in graph-level task [39, 37, 7, 5]. More details are deferred to related works (Section 2). ",
+        "bbox": [
+            174,
+            758,
+            826,
+            842
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Although expressive, it is still unclear why the deeper GCN requires more training iterations to achieve small training error and reach the properly trained status. To understand this, we show in Theorem 2 that under assumptions on the width of the final layer, the deeper GCN can converge to its global optimal with linear convergence rate. More specifically, the theorem claims that if the dimension of the last layer of $\\mathrm { G C N } d _ { L }$ is larger than the number of data $N ^ { 4 }$ , then we can guarantee the loss ${ \\mathcal { L } } ( \\theta _ { T } ) \\leq \\varepsilon$ after $T = \\mathcal { O } ( 1 / \\varepsilon )$ iterations of the gradient updates. Besides, more training iterations is sufficient (but not necessary due to the assumptions made in our theoretical analysis) for a deeper model to achieve the same training error as the shallow ones. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            202
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2. Let $\\pmb { \\theta } _ { t } = \\{ \\mathbf { W } _ { t } ^ { ( \\ell ) } \\in \\mathbb { R } ^ { d _ { \\ell - 1 } \\times d _ { \\ell } } \\} _ { \\ell = 1 } ^ { L + 1 }$ be the model parameter at the $t$ -th iteration and using square loss $\\begin{array} { r } { \\mathcal { L } ( \\pmb { \\theta } ) = \\frac { 1 } { 2 } \\| \\mathbf { H } ^ { ( L ) } \\mathbf { W } ^ { ( L + 1 ) } - \\mathbf { Y } \\| _ { \\mathrm { F } } ^ { 2 } } \\end{array}$ , $\\mathbf { H } ^ { ( \\ell ) } = \\sigma ( \\mathbf { P H } ^ { ( \\ell - 1 ) } \\mathbf { W } ^ { ( \\ell ) } )$ as objective function. Then, under the condition that $d _ { L } \\geq N$ we can obtain $\\mathcal { L } ( \\pmb { \\theta } _ { T } ) \\leq \\epsilon i f T \\geq C ( L ) \\log ( \\mathcal { L } ( \\pmb { \\theta } _ { 0 } ) / \\epsilon )$ , where $\\epsilon$ is the desired error and $C ( L )$ is a function of GCN depth $L$ that grows as GCN becomes deeper. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            268
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A formal statement of Theorem 2 and its proof are deferred to Appendix D. Besides, gradient stability also provides an alternative way of empirically understanding why deeper GCN requires more iterations: deeper neural networks are prone to exploding/vanishing gradient, which results in a very noisy gradient and requires small learning rate to stabilize the training. This issue can be significantly alleviated by adding skip-connections (Appendix E.5). When training with adaptive learning rate mechanisms, such as Adam $[ 2 7 ]$ , noisy gradient will result in a much smaller update on current model compared to a stabilized gradient, therefore more training iterations are required. ",
+        "bbox": [
+            173,
+            280,
+            825,
+            378
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 A different view from generalization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            398,
+            508,
+            416
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the previous section, we provided evidence that a well-trained deep GCN is at least as powerful as a shallow one. However, it is still unclear why a deeper GCN has worse performance than a shallow GCN during the evaluation phase. To answer this question, we provide a different view by analyzing the impact of GCN structures on the generalization. ",
+        "bbox": [
+            174,
+            430,
+            825,
+            486
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Transductive uniform stability. In the following, we study the generalization ability of GCNs via transductive uniform stability [17], where the generalization gap is defined as the difference between the training and testing errors for the random partition of a full dataset into training and testing sets. Transductive uniform stability is defined under the notation that the output of a classifier does not change much if the input is perturbed a bit, which is an extension of uniform stability [3] from the inductive to the transductive setting. The previous analysis on the uniform stability of GCNs [50] only shows the result of GCN with one graph convolutional layer under inductive learning setting, which cannot explain the effect of depth, model structure, and training data size on the generalization, and its extension to multi-layer GCNs and other GCN structures are non-trivial. ",
+        "bbox": [
+            173,
+            492,
+            825,
+            617
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Problem setup. Let $m = | \\mathcal { V } _ { \\mathrm { t r a i n } } |$ and $u = | \\nu _ { \\mathrm { t e s t } } |$ denote the training and test dataset sizes, respectively. Under the transductive learning setting, we start with a fixed set of points $X _ { m + u } = \\{ x _ { 1 } , \\ldots , x _ { m + u } \\}$ For notational convenience, we assume $X _ { m }$ are the first $m$ data points and $X _ { u }$ are the last $u$ data points of $X _ { m + u }$ . We randomly select a subset $X _ { m } ~ \\subset ~ X _ { m + u }$ uniformly at random and reveal the labels $Y _ { m }$ for the selected subset for training, but the labels for the remaining $u$ data points $Y _ { u } = Y _ { m + u } \\setminus Y _ { m }$ are not available during the training phase. Let $S _ { m } = ( ( x _ { 1 } , y _ { 1 } ) , \\bar { \\bf \\Phi } \\cdot \\cdot \\cdot , ( x _ { m } , \\bar { y } _ { m } ) )$ denotes the labeled set and $X _ { u } = ( x _ { m + 1 } , \\dots , x _ { m + u } )$ denotes the unlabeled set. Our goal is to learn a model to label the remaining unlabeled set as accurately as possible. ",
+        "bbox": [
+            173,
+            623,
+            825,
+            736
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the analysis purpose, we assume a binary classifier is applied to the final layer node representation $f ( \\mathbf { h } _ { i } ^ { ( L ) } ) = \\tilde { \\sigma } ( \\mathbf { v } ^ { \\top } \\mathbf { h } _ { i } ^ { ( L ) } )$ with $\\tilde { \\sigma } ( \\cdot )$ denotes the sigmoid function. We predict $\\hat { y } _ { i } = 1$ if $f ( \\mathbf { h } _ { i } ^ { ( L ) } ) > 1 / 2$ and $\\hat { y } _ { i } = 0$ otherwise, with ground truth label $y _ { i } \\in \\{ 0 , 1 \\}$ . Let denote the perturbed dataset as $S _ { m } ^ { i j } \\triangleq ( S _ { m } \\setminus \\{ ( x _ { i } , y _ { i } ) \\} ) \\cup \\{ ( x _ { j } , y _ { j } ) \\}$ and $X _ { u } ^ { i j } \\triangleq ( X _ { u } \\setminus \\{ x _ { j } \\} ) \\cup \\{ x _ { i } \\}$ , which is obtained by replacing the ith example in training set $S _ { m }$ with the $j$ th example from the testing set $X _ { u }$ . Let $\\pmb { \\theta }$ and $\\pmb { \\theta } ^ { i j }$ denote the weight parameters trained on the original dataset $( S _ { m } , X _ { u } )$ and the perturbed dataset $( S _ { m } ^ { i j } , X _ { u } ^ { i j } )$ , respectively. Then, we say transductive learner $f$ is $\\epsilon$ -uniformly stable if the outputs change less than $\\epsilon$ when we exchange two examples from the training set and testing set, i.e., for any $S _ { m } \\subset S _ { m + u }$ and any $i , j \\in [ m + u ]$ it holds that $\\begin{array} { r } { \\operatorname* { s u p } _ { i \\in [ m + u ] } | f ( \\mathbf { h } _ { i } ^ { ( L ) } ) - \\tilde { f } ( \\tilde { \\mathbf { h } } _ { i } ^ { ( L ) } ) ) | \\leq \\epsilon } \\end{array}$ , where $f ( \\mathbf { h } _ { i } ^ { ( L ) } )$ and $\\tilde { f } ( \\tilde { \\mathbf { h } } _ { i } ^ { ( L ) } )$ denote the prediction of node $i$ using parameters $\\pmb { \\theta }$ and $\\pmb { \\theta } ^ { i j }$ respectively. ",
+        "bbox": [
+            173,
+            741,
+            825,
+            833
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            154
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To define testing error and training error in our setting, let us introduce the difference in probability between the correct and the incorrect label as $p ( z , y ) \\triangleq y ( 2 z - 1 ) + ( 1 - y ) ( 1 - 2 z )$ with $p ( z , y ) \\leq 0$ if there exists a classification error. Let denote the Then, the testing error is defined as $\\begin{array} { r } { \\mathcal { R } _ { u } ( f ) = \\frac { 1 } { u } \\sum _ { i = m + 1 } ^ { m + u } \\mathbf { 1 } \\{ p ( f ( \\mathbf { h } _ { i } ^ { ( L ) } ) , y _ { i } ) \\leq 0 \\} } \\end{array}$ $\\gamma$ -margin loss as $\\Phi _ { \\gamma } ( x ) = \\operatorname* { m i n } ( 1 , \\operatorname* { m a x } ( 0 , 1 - x / \\gamma ) )$ and the training . loss is defined as $\\begin{array} { r } { \\mathcal { R } _ { m } ^ { \\gamma } ( f ) = \\frac { 1 } { m } \\sum _ { i = 1 } ^ { m } \\Phi _ { \\gamma } ( - p ( f ( \\mathbf { h } _ { i } ^ { ( L ) } ) , y _ { i } ) ) } \\end{array}$ . 6 ",
+        "bbox": [
+            173,
+            160,
+            826,
+            243
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3 (Transductive uniform stability bound [17]). Let $f$ be a $\\epsilon$ -uniformly stable transductive learner and $\\gamma , \\delta > 0$ , and define $Q = m u / ( m + u )$ . Then, with probability at least $1 - \\delta$ over all training and testing partitions, we have $\\begin{array} { r } { \\mathcal { R } _ { u } ( f ) \\leq \\mathcal { R } _ { m } ^ { \\gamma } ( f ) + \\frac { 2 } { \\gamma } \\mathcal { O } \\left( \\epsilon \\sqrt { Q \\ln ( \\delta ^ { - 1 } ) } \\right) + \\mathcal { O } \\left( \\frac { \\ln ( \\delta ^ { - 1 } ) } { \\sqrt { Q } } \\right) } \\end{array}$ . ",
+        "bbox": [
+            174,
+            246,
+            825,
+            297
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Recall that as we discussed in Section 4, deeper GCN is provable more expressive and can achieve very low training error $\\mathcal { R } _ { m } ^ { \\gamma } ( f )$ if properly training. Then, if the dataset size is sufficiently large, the testing error $\\mathcal { R } _ { u } ( f )$ will be dominated by the generalization gap, which is mainly controlled by uniformly stable constant \u000f. In the following, we explore the impact of GCN structures on $\\epsilon$ . Our key idea is to decompose the $\\epsilon$ into three terms: the Lipschitz continuous constant $\\rho _ { f }$ , upper bound on gradient $G _ { f }$ , and the smoothness constant $L _ { f }$ of GCNs. Please refer to Lemma 1 for details. ",
+        "bbox": [
+            173,
+            308,
+            825,
+            392
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1. Suppose function $f ( \\mathbf { h } ^ { ( L ) } )$ is $\\rho _ { f }$ -Lipschitz continuous, $L _ { f }$ -smooth, and the gradient of loss w.r.t. the parameter is bounded by $G _ { f }$ . After $T$ steps of full-batch gradient descent, we have $\\begin{array} { r } { \\epsilon = \\frac { 2 \\eta \\rho _ { f } G _ { f } } { m } \\sum _ { t = 1 } ^ { T } ( 1 + \\eta L _ { f } ) ^ { t - 1 } } \\end{array}$ ",
+        "bbox": [
+            173,
+            396,
+            825,
+            445
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The proof is deferred to Appendix K. By using Lemma 1, we can derive constant $\\epsilon$ of different model structures by comparing the Lipschitz continuity, smoothness, and gradient scale. ",
+        "bbox": [
+            171,
+            454,
+            823,
+            483
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Before proceeding to our result, we make the following standard assumption on the node feature vectors and weight matrices, which are previously used in generalization analysis of GCNs [18, 36]. ",
+        "bbox": [
+            171,
+            489,
+            823,
+            518
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Assumption 1. We assume the norm of node feature vectors, weight parameters are bounded, i.e., $\\| \\mathbf { x } _ { i } \\| _ { 2 } \\leq B _ { x }$ , $\\| \\mathbf { W } ^ { ( \\ell ) } \\| _ { 2 } \\le B _ { w }$ , and $\\| \\mathbf { v } \\| _ { 2 } \\leq 1$ . ",
+        "bbox": [
+            174,
+            522,
+            825,
+            551
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Theorem 4, we show that the generalization bounds of GCN and its variants are dominated by the following terms: maximum node degree $d$ , model depth $L$ , training/validation set size $( m , u )$ , training iterations $T$ , and spectral norm of the weight matrices $B _ { w }$ . The larger the aforementioned variables are, the larger the generalization gap is. We defer the formal statements and proofs to Appendices F, G, H, and I. ",
+        "bbox": [
+            173,
+            561,
+            826,
+            631
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 4 (Informal). We say model is \u000f-uniformly stable with \u000f = 2ηρf Gfm PTt= $\\begin{array} { r } { \\epsilon = \\frac { 2 \\eta \\rho _ { f } G _ { f } } { m } \\sum _ { t = 1 } ^ { T } ( 1 + \\eta L _ { f } ) ^ { t - 1 } } \\end{array}$ where the result of $\\rho _ { f } , G _ { f } , L _ { f }$ 1are summarized in Table 1, and other related constants as ",
+        "bbox": [
+            173,
+            635,
+            825,
+            667
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d06acb6f3048917a30614325a03bfb2694498d74d3b517477ce7fb35b36d14d2.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad B _ { d } ^ { \\alpha } = ( 1 - \\alpha ) \\sum _ { \\ell = 1 } ^ { L } ( \\alpha \\sqrt { d } ) ^ { \\ell - 1 } + ( \\alpha \\sqrt { d } ) ^ { L } , \\ B _ { w } ^ { \\beta } = \\beta B _ { w } + ( 1 - \\beta ) , } \\\\ & { B _ { \\ell , d } ^ { \\alpha , \\beta } = \\operatorname* { m a x } \\big \\{ \\beta \\big ( ( 1 - \\alpha ) L + \\alpha \\sqrt { d } \\big ) , ( 1 - \\alpha ) L B _ { w } ^ { \\beta } + 1 \\big \\} . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            674,
+            730,
+            719
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the following, we provide intuitions and discussions on the generalization bound of each algorithm: ",
+        "bbox": [
+            171,
+            731,
+            825,
+            746
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• Deep GCN requires iterations $T$ to achieve small training error. Since the generalization bound increases with $T$ , more iterations significantly hurt its generalization power. Note that our results considers both $B _ { w } \\le 1$ and $B _ { w } > 1$ , where increasing model depth will not hurt the generalization if $B _ { w } \\le 1$ , and the generalization gap becomes sensitive to the model depth if $B _ { w } > 1$ . Notice that $B _ { w } > 1$ is more likely to happen during training as we discussed in Section 4. ",
+        "bbox": [
+            181,
+            751,
+            825,
+            821
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• ResGCN resolves the training difficulties by adding skip-connections between hidden layers. Although it requires less training iterations $T$ , adding skip-connections enlarges the dependency on the number of layers $L$ and the spectral norm of weight matrices $B _ { w }$ , therefore results in a larger generalization gap and a poor generalization performance.. ",
+        "bbox": [
+            184,
+            821,
+            823,
+            849
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/92f5f070fa4028c630b33fb6dc832094abd2633a30e613342e710cfe80bc2104.jpg",
+        "table_caption": [
+            "Table 1: Comparison of uniform stability constant $\\epsilon$ of GCN variants, where $\\mathcal { O } ( \\cdot )$ is used to hide constants that shared between all bounds. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Pf and Gf</td><td>Lf</td><td>C1 and C2</td></tr><tr><td>EGCN</td><td>O(CHC2)</td><td>O(CIC(L + 2)CIC + 2))</td><td>C1 = max{1,√dBw},C= √d(1+Bx)</td></tr><tr><td>EResGCN</td><td>O(CC2)</td><td>O(CIC2((L + 2)CIC2 + 2))</td><td>C1 =1+ √dBω,C = √d(1+Bx)</td></tr><tr><td>EAPPNP</td><td>0(C1)</td><td>O(Ci(CiC2) +1)</td><td>C1=BqBx,C2=max{1,Bω}</td></tr><tr><td>EGCNII</td><td>O(βCIC2)</td><td>O(aβCIC(αβL +2)CIC+ 2β))</td><td></td></tr><tr><td>EDGCN</td><td>0(C1)</td><td>O(Ci(CiC2) + 1)</td><td>C1 =(√d)LBx,C2 = max{1,Bω}</td></tr></table>",
+        "bbox": [
+            187,
+            127,
+            810,
+            227
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            194,
+            250,
+            823,
+            279
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• APPNP alleviates the aforementioned dependency by decoupling the weight parameters and feature propagation. As a result, its generalization gap does not significantly change as $L$ and $B _ { w }$ increase. The optimal $\\alpha$ that minimizes the generalization gap can be obtained by finding the $\\alpha$ that minimize the term $B _ { d } ^ { \\alpha }$ . Although APPNP can significantly reduce the generalization gap, because a single weight matrix is shared between all layers, its expressive power is not enough for large-scale challenging graph datasets [24]. ",
+        "bbox": [
+            183,
+            279,
+            825,
+            361
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• To gain expressiveness, GCNII proposes to add the weight matrices back and add another hyper-parameter that explicitly controls the dependency on $B _ { w }$ . Although GCNII achieves the state-of-the-art performances on several graph datasets, the selection of hyper-parameters is non-trivial compared to APPNP because $\\alpha , \\beta$ are coupled with $L , B _ { w }$ , and $d$ . In practice, [6] builds a very deep GCNII by choosing $\\beta$ dynamically decreases as the number of layers and different $\\alpha$ values for different datasets. ",
+        "bbox": [
+            186,
+            361,
+            821,
+            443
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• By property chosen hyper-parameters, we have the following order on the generalization gap given the same training iteration $T$ : $\\mathrm { A P P N P } \\leq \\mathrm { G C N I I } \\leq \\mathrm { G C N } \\leq \\mathrm { R e s G C N }$ , which exactly match our empirical evaluation on the generalization gap in Section 7 and Appendix E. ",
+        "bbox": [
+            183,
+            444,
+            821,
+            486
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Remark 1. It is worthy to provide an alternative view of DropEdge [47] and PairNorm [61] algorithms from a generalization perspective. To improve the generalization power of standard GCNs, DropEdge randomly drops edges in the training phase, which leads to a smaller maximum node degree $d _ { s } < d$ . PairNorm applies normalization on intermediate node embeddings to ensure that the total pairwise feature distances remain constant across layers, which leads to less dependency on $d$ and $B _ { w }$ . However, since deep GCN requires significantly more iterations to achieve low training error than shallow one, the performance of applying DropEdge and PairNorm on GCNs is still degrading as the number of layers increases. Most importantly, our empirical results in Appendix E.3 and $E . 4$ suggest that applying Dropout and PairNorm is hurting the training accuracy (i.e., not alleviating over-smoothing) but reducing the generalization gap. ",
+        "bbox": [
+            173,
+            489,
+            825,
+            627
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 Decoupled GCN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            646,
+            346,
+            664
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We propose to decouple the expressive power from generalization a(DGCN). The DGCN model can be mathematically formulated as $\\begin{array} { r } { \\mathbf { Z } \\ = \\ \\sum _ { \\ell = 1 } ^ { L } \\alpha _ { \\ell } f ^ { ( \\ell ) } ( \\mathbf { X } ) } \\end{array}$ GCN and $f ^ { ( \\ell ) } ( \\mathbf { X } ) = \\mathbf { P } ^ { \\ell } \\mathbf { X } \\big ( \\beta _ { \\ell } \\mathbf { W } ^ { ( \\ell ) } + ( 1 - \\beta _ { \\ell } ) \\mathbf { I } \\big )$ , where $\\mathbf { W } ^ { ( \\ell ) }$ , $\\alpha _ { \\ell }$ and $\\beta _ { \\ell }$ are the learnable weights for \\`th layer function $f ^ { ( \\ell ) } ( { \\mathbf { X } } )$ .7 The design of DGCN has the following key ingredients: ",
+        "bbox": [
+            173,
+            676,
+            825,
+            742
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• (Decoupling) The generalization gap in GCN grows exponentially with the number of layers. To overcome this issue, we propose to decouple the weight matrices from propagation by assigning weight $\\mathbf { W } ^ { ( \\ell ) }$ to each individual layerwise function ${ \\bf \\nabla } _ { f } ( \\ell ) _ { \\left( \\mathbf { X } \\right) }$ . DGCN can be thought of as an ensemble of multiple SGCs [54] with depth from 1 to $L$ . By doing so, the generalization gap has less dependency on the number of weight matrices, and deep models with large receptive fields can incorporate information of the global graph structure. Please refer to Theorem 5 for the details. • (Learnable $\\alpha _ { \\ell }$ ) After decoupling the weight matrices from feature propagation, the layerwise function $f ^ { ( \\ell ) } ( { \\mathbf { X } } )$ with more propagation steps can suffer from less expressive power. Therefore, we propose to assign a learnable weight $\\alpha _ { \\ell }$ for each step of feature propagation. Intuitively, DGCN assigns smaller weight $\\alpha _ { \\ell }$ to each layerwise function $f ^ { ( \\ell ) } ( { \\mathbf { X } } )$ with more propagation steps at the beginning of training. Throughout the training, DGCN gradually adjusts the weight to leverage more useful large receptive field information. • (Learnable $\\beta _ { \\ell }$ ) A learnable weight $\\beta _ { \\ell } \\in [ 0 , 1 ]$ is assigned to each weight matrix to balance the expressiveness with model complexity, which guarantees a better generalization ability. ",
+        "bbox": [
+            181,
+            747,
+            825,
+            876
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/88a04fb0f7daceea30a7cea13af4ec513523ab772c3c5f05f55f2616f96d75ea.jpg",
+        "image_caption": [
+            "Figure 4: Comparison of generalization error on synthetic dataset. The curve early stopped at the largest training accuracy iteration. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            87,
+            818,
+            304
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            181,
+            357,
+            825,
+            443
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Theorem 5. Let suppose \u000fDGCN-uniformly stable with $\\begin{array} { r } { \\epsilon _ { D G C N } = \\frac { 2 \\eta \\rho _ { f } \\bar { G } _ { f } } { m } \\sum _ { t = 1 } ^ { T } ( 1 + \\eta L _ { f } ) ^ { t - 1 } } \\end{array}$ $\\beta _ { \\ell }$ during training. We say DGCN iswhere ",
+        "bbox": [
+            173,
+            446,
+            823,
+            479
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/716f853cfbc2d82e84c232f08536d9987c76182b483349c9fed2affad75a9566.jpg",
+        "text": "$$\n\\begin{array} { r } { \\rho _ { f } = G _ { f } = \\mathcal { O } \\Big ( ( \\sqrt { d } ) ^ { L } B _ { x } \\Big ) , L _ { f } = \\mathcal { O } \\Big ( ( \\sqrt { d } ) ^ { L } B _ { x } \\big ( ( \\sqrt { d } ) ^ { L } B _ { x } \\operatorname* { m a x } \\{ 1 , B _ { w } \\} + 1 ) \\big ) \\Big ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            484,
+            766,
+            511
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The details are deferred to Appendix J, and comparison of bound to other GCN variants are summarized in Table 1. Depending on the automatic selection of $\\alpha _ { \\ell } , \\beta _ { \\ell }$ , the generalization bound of DGCN is between APPNP and GCN. In the following, we make connection to many GCN structures: ",
+        "bbox": [
+            174,
+            522,
+            825,
+            564
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "• Connections to APPNP: APPNP can be thought of as a variant of DGCN. More specifically, the layerwise weight in APPNP is computed as $\\alpha _ { \\ell } = \\alpha ( 1 - \\alpha ) ^ { \\ell }$ for $\\ell < L$ and $\\alpha _ { \\ell } \\stackrel { \\cdot } { = } ( 1 - \\alpha ) ^ { \\cdot }$ for $\\ell = L$ given some constant $\\alpha \\in ( 0 , 1 )$ , and the weight matrix is shared between all layers. Although DGCN has $L$ weight matrices, its generalization is independent of the number of weight matrices, and thus enjoys a low generalization error with high expressiveness. ",
+        "bbox": [
+            183,
+            570,
+            825,
+            640
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "• Connections to GCNII: GCNII can be regarded as a variant of DGCN. Compared to GCNII, the decoupled propagation of DGCN significantly reduces the dependency of generalization error to the weight matrices. Besides, the learnable weights $\\alpha _ { \\ell }$ and $\\beta _ { \\ell }$ allow DGCN to automatically adapt to challenging large-scale datasets without time-consuming hyper-parameter selection. ",
+        "bbox": [
+            183,
+            640,
+            825,
+            695
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "• Connections to ResGCN: By expanding the forward computation of ResGCN, we know that ResGCN can be think of as training an ensemble of GCNs from 1 to $L$ layer, i.e., $\\begin{array} { r } { \\mathbf { H } ^ { ( L ) } = \\sum _ { \\ell = 1 } ^ { L } \\alpha _ { \\ell } \\sigma \\big ( \\mathbf { P H } ^ { ( \\ell - 1 ) } \\mathbf { W } ^ { ( \\ell ) } \\big ) } \\end{array}$ with $\\alpha _ { \\ell } = 1$ . In other word, ResNet can be regarded asL the “summation of the model complexity” of $L$ -layer. However, DGCN is using $\\begin{array} { r } { \\sum _ { \\ell = 1 } ^ { L ^ { - } } \\alpha _ { \\ell } = 1 } \\end{array}$ which can be thought of as a “weighted average of model complexity”. Therefore, ResGCN is a special case of DGCN with equal weights $\\alpha _ { \\ell }$ on each layerwise function. With just a simple change on the ResNet structure, our model DGCN is both easy to train and good to generalize. ",
+        "bbox": [
+            183,
+            695,
+            825,
+            792
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            810,
+            312,
+            828
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Synthetic dataset. We empirically compare the generalization error of different GCN structures on the synthetic dataset. In particular, we create the synthetic dataset by contextual stochastic block model (CSBM) [13] with two equal-size classes. CSBM is a graph generation algorithm that adds Gaussian random vectors as node features on top of classical SBM. CSBM allows for smooth control over the information ratio between node features and graph topology by a pair of hyper-parameter $( \\mu , \\lambda )$ , where $\\mu$ controls the diversity of the Gaussian distribution and $\\lambda$ controls the number of edges between intra- and inter-class nodes. We generate random graphs with 1000 nodes, average node degree as 5, and each node has a Gaussian random vector of dimension 1000 as node features. We chose $7 5 \\%$ nodes as training set, $1 5 \\%$ of nodes as validation set for hyper-parameter tuning, and the remaining nodes as testing set. We conduct an experiment 20 times by randomly selecting $( \\mu , \\lambda )$ such that both node feature and graph topology are equally informative. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 4, we have the following order on the generalization gap given the same training iteration $T$ : $\\mathrm { A P P N P } \\leq \\mathrm { G C N I I } \\leq \\mathrm { G C N } \\leq \\mathrm { R e s G C N }$ , which exactly match the theoretical result in Theorem 4. More specifically, ResGCN has the largest generalization gap due to the skip-connections, APPNP has the smallest generalization gap by removing the weight matrices in each individual layer. GCNII achieves a good balance between GCN and APPNP by balancing the expressive and generalization power. Finally, DGCN enjoys a small generalization error by using the decoupled GCN structure. ",
+        "bbox": [
+            173,
+            181,
+            825,
+            277
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Open graph benchmark dataset. As pointed out by Hu et al. [24], the traditional commonly-used graph datasets are unable to provide a reliable evaluation due to various factors including dataset size, leakage of node features and no consensus on data splitting. To truly evaluate the expressive and the generalization power of existing methods, we evaluate on the open graph benchmark (OGB) dataset. Experiment setups are based on the default setting for GCN implementation on the leaderboard. We choose the hidden dimension as 128, learning rate as 0.01, dropout ratio as 0.5 for Arxiv dataset, and no dropout for Products and Protein datasets. We train $3 0 0 / 1 0 \\mathrm { \\bar { 0 } 0 / 5 0 0 }$ epochs for Products, Proteins, and Arxiv dataset respectively. Due to limited GPU memory, the number of layers is selected as the one with the best performance between 2 to 16 layers for Arxiv dataset, 2 to 8 layers for Protein dataset, and 2 to 4 for Products dataset. We choose $\\alpha _ { \\ell }$ from $\\{ 0 . 9 , 0 . 8 , 0 . 5 \\}$ for APPNP and GCNII, and use $\\beta _ { \\ell } = 0 . 5 / \\ell$ for GCNII, and select the setup with the best validation result for comparison. ",
+        "bbox": [
+            174,
+            284,
+            825,
+            436
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 2, DGCN achieves a compatible performance to $\\mathrm { G C N I I ^ { 8 } }$ without the need of manually tuning the hyper-parameters for all settings, and it significantly outperform APPNP and ResGCN. Due to the space limit, the detailed setups and more results can be found in Appendix E. Notice that generalization bounds are more valuable when comparing two models with same training accuracy (therefore we first show in Section 4 that deeper model can also achieve low training error before our discussion on generalization in Section 5). ",
+        "bbox": [
+            174,
+            443,
+            825,
+            526
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In Table 2, because ResGCN has no restriction on the weight matrices, it can achieve lower training error and its test performance is mainly restricted by its generalization error. However, because GCNII and APPNP have restrictions on the weight matrices, their performance is mainly restricted by their training error. A model with small generalization error and no restriction on the weight (e.g., DGCN) ",
+        "bbox": [
+            174,
+            526,
+            446,
+            662
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/322783d37de7981207dc65cfe933bc9584f22afa7692b9b722f87c2e7865de6c.jpg",
+        "table_caption": [
+            "Table 2: Comparison of F1-score on OGB dataset. "
+        ],
+        "table_footnote": [
+            "is preferred as it has higher potential to reach a better test accuracy by reducing its training error. "
+        ],
+        "table_body": "<table><tr><td>%</td><td>Products</td><td>Proteins</td><td>Arvix</td></tr><tr><td>GCN</td><td>75.39 ± 0.21</td><td>71.66 ± 0.48</td><td>71.56 ± 0.19</td></tr><tr><td>ResGCN</td><td>75.53 ± 0.12</td><td>74.50 ± 0.41</td><td>72.56 ± 0.31</td></tr><tr><td>APPNP</td><td>66.35±0.10</td><td>71.78±0.29</td><td>68.02 ±0.55</td></tr><tr><td>GCNII</td><td>71.93 ± 0.35t</td><td>75.60±0.47</td><td>72.57 ± 0.23‡</td></tr><tr><td>DGCN</td><td>76.09 ± 0.29</td><td>75.45 ± 0.24</td><td>72.63± 0.12</td></tr></table>",
+        "bbox": [
+            460,
+            549,
+            813,
+            657
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "8 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            707,
+            297,
+            724
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we show that there exists a discrepancy between over-smoothing based theoretical results and the practical behavior of deep GCNs. Our theoretical result shows that a deeper GCN can be as expressive as a shallow GCN, if it is properly trained. To truly understand the performance decay issue of deep GCNs, we provide the first transductive uniform stability-based generalization analysis of GCNs and other GCN structures. To improve the optimization issue and benefit from depth, we propose DGCN that enjoys a provable high expressive power and generalization power. We conduct empirical evaluations on various synthetic and real-world datasets to validate the correctness of our theory and advantages over the baselines. ",
+        "bbox": [
+            173,
+            744,
+            825,
+            856
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            89,
+            338,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work was supported in part by NSF grant 2008398. ",
+        "bbox": [
+            174,
+            121,
+            542,
+            136
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            157,
+            266,
+            172
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Uri Alon and Eran Yahav. On the bottleneck of graph neural networks and its practical implications. In International Conference on Learning Representations, 2020.   \n[2] Rianne van den Berg, Thomas N Kipf, and Max Welling. Graph convolutional matrix completion. arXiv preprint arXiv:1706.02263, 2017.   \n[3] Olivier Bousquet and André Elisseeff. Stability and generalization. Journal of machine learning research, 2(Mar):499–526, 2002.   \n[4] Chen Cai and Yusu Wang. A note on over-smoothing for graph neural networks. arXiv preprint arXiv:2006.13318, 2020.   \n[5] Lei Chen, Zhengdao Chen, and Joan Bruna. On graph neural networks versus graph-augmented mlps. In International Conference on Learning Representations, 2020.   \n[6] Ming Chen, Zhewei Wei, Zengfeng Huang, Bolin Ding, and Yaliang Li. Simple and deep graph convolutional networks. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 1725–1735. PMLR, 2020.   \n[7] Zhengdao Chen, Lei Chen, Soledad Villar, and Joan Bruna. Can graph neural networks count substructures? In Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020.   \n[8] Eli Chien, Jianhao Peng, Pan Li, and Olgica Milenkovic. Adaptive universal generalized pagerank graph neural network. 2021.   \n[9] Weilin Cong, Rana Forsati, Mahmut T. Kandemir, and Mehrdad Mahdavi. Minimal variance sampling with provable guarantees for fast training of graph neural networks. In KDD ’20: The 26th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, Virtual Event, CA, USA, August 23-27, 2020, pages 1393–1403. ACM, 2020.   \n[10] Zhiyong Cui, Kristian Henrickson, Ruimin Ke, and Yinhai Wang. Traffic graph convolutional recurrent neural network: A deep learning framework for network-scale traffic learning and forecasting. IEEE Transactions on Intelligent Transportation Systems, 2019.   \n[11] Kenneth R Davidson and Stanislaw J Szarek. Local operator theory, random matrices and banach spaces. Handbook of the geometry of Banach spaces, 1(317-366):131, 2001.   \n[12] Songgaojun Deng, Huzefa Rangwala, and Yue Ning. Learning dynamic context graphs for predicting social events. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 1007–1016. ACM, 2019.   \n[13] Yash Deshpande, Subhabrata Sen, Andrea Montanari, and Elchanan Mossel. Contextual stochastic block models. In Advances in Neural Information Processing Systems 31: Annual Conference on Neural Information Processing Systems 2018, NeurIPS 2018, December 3-8, 2018, Montréal, Canada, pages 8590–8602, 2018.   \n[14] Kien Do, Truyen Tran, and Svetha Venkatesh. Graph transformation policy network for chemical reaction prediction. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 750–760. ACM, 2019.   \n[15] Simon S. Du, Kangcheng Hou, Ruslan Salakhutdinov, Barnabás Póczos, Ruosong Wang, and Keyulu Xu. Graph neural tangent kernel: Fusing graph neural networks with graph kernels. In Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, pages 5724–5734, 2019.   \n[16] David Duvenaud, Dougal Maclaurin, Jorge Aguilera-Iparraguirre, Rafael Gómez-Bombarelli, Timothy Hirzel, Alán Aspuru-Guzik, and Ryan P. Adams. Convolutional networks on graphs for learning molecular fingerprints. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pages 2224–2232, 2015.   \n[17] Ran El-Yaniv and Dmitry Pechyony. Stable transductive learning. In Learning Theory, 19th Annual Conference on Learning Theory, COLT 2006, Pittsburgh, PA, USA, June 22-25, 2006, Proceedings, volume 4005 of Lecture Notes in Computer Science, pages 35–49. Springer, 2006.   \n[18] Vikas K. Garg, Stefanie Jegelka, and Tommi S. Jaakkola. Generalization and representational limits of graph neural networks. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 3419–3430. PMLR, 2020.   \n[19] Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pages 249–256. JMLR Workshop and Conference Proceedings, 2010.   \n[20] Shunwang Gong, Mehdi Bahri, Michael M. Bronstein, and Stefanos Zafeiriou. Geometrically principled connections in graph neural networks. In 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR 2020, Seattle, WA, USA, June 13-19, 2020, pages 11412–11421. IEEE, 2020.   \n[21] William L. Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 1024–1034, 2017.   \n[22] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In 2015 IEEE International Conference on Computer Vision, ICCV 2015, Santiago, Chile, December 7-13, 2015, pages 1026–1034. IEEE Computer Society, 2015.   \n[23] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2016, Las Vegas, NV, USA, June 27-30, 2016, pages 770–778. IEEE Computer Society, 2016.   \n[24] Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. In Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020.   \n[25] Wei Huang, Yayong Li, Weitao Du, Richard Yi Da Xu, Jie Yin, and Ling Chen. Wide graph neural networks: Aggregation provably leads to exponentially trainability loss. arXiv preprint arXiv:2103.03113, 2021.   \n[26] Wenbing Huang, Yu Rong, Tingyang Xu, Fuchun Sun, and Junzhou Huang. Tackling oversmoothing for general graph convolutional networks. arXiv e-prints, pages arXiv–2008, 2020.   \n[27] Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015.   \n[28] Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017.   \n[29] Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.   \n[30] Kezhi Kong, Guohao Li, Mucong Ding, Zuxuan Wu, Chen Zhu, Bernard Ghanem, Gavin Taylor, and Tom Goldstein. Flag: Adversarial data augmentation for graph neural networks. arXiv preprint arXiv:2010.09891, 2020.   \n[31] Srijan Kumar, Xikun Zhang, and Jure Leskovec. Predicting dynamic embedding trajectory in temporal interaction networks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 1269–1278. ACM, 2019.   \n[32] AA Leman and B Weisfeiler. A reduction of a graph to a canonical form and an algebra arising during this reduction. Nauchno-Technicheskaya Informatsiya, 2(9):12–16, 1968.   \n[33] Guohao Li, Matthias Müller, Ali K. Thabet, and Bernard Ghanem. Deepgcns: Can gcns go as deep as cnns? In 2019 IEEE/CVF International Conference on Computer Vision, ICCV 2019, Seoul, Korea (South), October 27 - November 2, 2019, pages 9266–9275. IEEE, 2019.   \n[34] Jia Li, Zhichao Han, Hong Cheng, Jiao Su, Pengyun Wang, Jianfeng Zhang, and Lujia Pan. Predicting path failure in time-evolving graphs. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 1279–1289. ACM, 2019.   \n[35] Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi-supervised learning. In Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence, (AAAI-18), the 30th innovative Applications of Artificial Intelligence (IAAI-18), and the 8th AAAI Symposium on Educational Advances in Artificial Intelligence (EAAI-18), New Orleans, Louisiana, USA, February 2-7, 2018, pages 3538–3545. AAAI Press, 2018.   \n[36] Renjie Liao, Raquel Urtasun, and Richard Zemel. A pac-bayesian approach to generalization bounds for graph neural networks. arXiv preprint arXiv:2012.07690, 2020.   \n[37] Andreas Loukas. What graph neural networks cannot learn: depth vs width. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   \n[38] Sitao Luan, Mingde Zhao, Xiao-Wen Chang, and Doina Precup. Training matters: Unlocking potentials of deeper graph convolutional neural networks. arXiv preprint arXiv:2008.08838, 2020.   \n[39] Christopher Morris, Martin Ritzert, Matthias Fey, William L. Hamilton, Jan Eric Lenssen, Gaurav Rattan, and Martin Grohe. Weisfeiler and leman go neural: Higher-order graph neural networks. In The Thirty-Third AAAI Conference on Artificial Intelligence, AAAI 2019, The Thirty-First Innovative Applications of Artificial Intelligence Conference, IAAI 2019, The Ninth AAAI Symposium on Educational Advances in Artificial Intelligence, EAAI 2019, Honolulu, Hawaii, USA, January 27 - February 1, 2019, pages 4602–4609. AAAI Press, 2019.   \n[40] Quynh Nguyen. On the proof of global convergence of gradient descent for deep relu networks with linear widths. arXiv preprint arXiv:2101.09612, 2021.   \n[41] Kenta Oono and Taiji Suzuki. Graph neural networks exponentially lose expressive power for node classification. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   \n[42] Kenta Oono and Taiji Suzuki. Optimization and generalization analysis of transduction through gradient boosting and application to multi-scale graph neural networks. Advances in Neural Information Processing Systems, 33, 2020.   \n[43] Namyong Park, Andrey Kan, Xin Luna Dong, Tong Zhao, and Christos Faloutsos. Estimating node importance in knowledge graphs using graph neural networks. In Proceedings of the $2 5 t h$ ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 596–606. ACM, 2019.   \n[44] Jiezhong Qiu, Jian Tang, Hao Ma, Yuxiao Dong, Kuansan Wang, and Jie Tang. Deepinf: Modeling influence locality in large social networks. In KDD, 2018.   \n[45] Afshin Rahimi, Trevor Cohn, and Timothy Baldwin. Semi-supervised user geolocation via graph convolutional networks. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 2009–2019. Association for Computational Linguistics, 2018.   \n[46] Morteza Ramezani, Weilin Cong, Mehrdad Mahdavi, Anand Sivasubramaniam, and Mahmut Kandemir. Gcn meets gpu: Decoupling “when to sample” from “how to sample”. Advances in Neural Information Processing Systems, 33, 2020.   \n[47] Yu Rong, Wenbing Huang, Tingyang Xu, and Junzhou Huang. Dropedge: Towards deep graph convolutional networks on node classification. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   \n[48] Ruslan Salakhutdinov. Deep learning. In The 20th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’14, New York, NY, USA - August 24 - 27, 2014, page 1973. ACM, 2014.   \n[49] Franco Scarselli, Ah Chung Tsoi, and Markus Hagenbuchner. The vapnik–chervonenkis dimension of graph and recursive neural networks. Neural Networks, 108:248–259, 2018.   \n[50] Saurabh Verma and Zhi-Li Zhang. Stability and generalization of graph convolutional neural networks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 1539– 1548. ACM, 2019.   \n[51] Hao Wang, Tong Xu, Qi Liu, Defu Lian, Enhong Chen, Dongfang Du, Han Wu, and Wen Su. MCNE: an end-to-end framework for learning multiple conditional network representations of social network. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 1064–1072. ACM, 2019.   \n[52] Hongwei Wang, Fuzheng Zhang, Mengdi Zhang, Jure Leskovec, Miao Zhao, Wenjie Li, and Zhongyuan Wang. Knowledge-aware graph neural networks with label smoothness regularization for recommender systems. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 968–977. ACM, 2019.   \n[53] Xiang Wang, Xiangnan He, Yixin Cao, Meng Liu, and Tat-Seng Chua. KGAT: knowledge graph attention network for recommendation. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 950–958. ACM, 2019.   \n[54] Felix Wu, Amauri H. Souza Jr., Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Q. Weinberger. Simplifying graph convolutional networks. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pages 6861–6871. PMLR, 2019.   \n[55] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.   \n[56] Keyulu Xu, Jingling Li, Mozhi Zhang, Simon S. Du, Ken-ichi Kawarabayashi, and Stefanie Jegelka. What can neural networks reason about? In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   \n[57] Keyulu Xu, Mozhi Zhang, Jingling Li, Simon Shaolei Du, Ken-Ichi Kawarabayashi, and Stefanie Jegelka. How neural networks extrapolate: From feedforward to graph neural networks. In International Conference on Learning Representations, 2021.   \n[58] Yujun Yan, Milad Hashemi, Kevin Swersky, Yaoqing Yang, and Danai Koutra. Two sides of the same coin: Heterophily and oversmoothing in graph convolutional neural networks. arXiv preprint arXiv:2102.06462, 2021.   \n[59] Chaoqi Yang, Ruijie Wang, Shuochao Yao, Shengzhong Liu, and Tarek Abdelzaher. Revisiting\" over-smoothing\" in deep gcns. arXiv preprint arXiv:2003.13663, 2020.   \n[60] Rex Ying, Ruining He, Kaifeng Chen, Pong Eksombatchai, William L. Hamilton, and Jure Leskovec. Graph convolutional neural networks for web-scale recommender systems. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2018, London, UK, August 19-23, 2018, pages 974–983. ACM, 2018.   \n[61] Lingxiao Zhao and Leman Akoglu. Pairnorm: Tackling oversmoothing in gnns. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   \n[62] Kuangqi Zhou, Yanfei Dong, Wee Sun Lee, Bryan Hooi, Huan Xu, and Jiashi Feng. Effective training strategies for deep graph neural networks. arXiv preprint arXiv:2006.07107, 2020.   \n[63] Xianchen Zhou and Hongxia Wang. The generalization error of graph convolutional networks may enlarge with more layers. Neurocomputing, 424:97–106, 2021. ",
+        "bbox": [
+            174,
+            178,
+            828,
+            921
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            64,
+            828,
+            915
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            166,
+            68,
+            828,
+            915
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            25,
+            828,
+            897
+        ],
+        "page_idx": 13
+    }
+]

parse/train/r1YqWz-R-/r1YqWz-R-.md

@@ -0,0 +1,256 @@
+# IMPROVING CONDITIONAL SEQUENCE GENERATIVE ADVERSARIAL NETWORKS BY STEPWISE EVALUATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Conditional sequence generation is a widely researched topic. One of the most important tasks is dialogue generation, which is composed of input-output pairs with the one-to-many property. Given the recent success of generative adversarial networks (GANs), GANs have been used for sequence generation. However, there is still limited work of its application on conditional sequence generation. We investigate the influence of GAN on conditional sequence generation with three artificial grammars and dialogue generation. Moreover, we propose stepwise GAN (StepGAN) for conditional sequence generation, which predicts the reward at each time-step. StepGAN can be seen as the general version of SeqGAN. It estimates the expected returns predicted by Monte-Carlo Search in SeqGAN, but it has a lower computational cost than Monte-Carlo Search. Experimental results show that stepwise GAN can outperform other state-of-the-art algorithms in most tasks.
+
+# 1 INTRODUCTION
+
+Conditional sequence generation is the task of generating the correspondent response given an input sequence. One of the most important applications is dialogue generation. Dialogue generation is one-to-many; that is, there can be many acceptable responses for a specific input. In previous work, the sequence-to-sequence based dialogue generation model is trained using maximum likelihood estimation, and achieves promising results in terms of both meaning and coherence (Vinyals & Le, 2015). Despite this success, the generated responses given the inputs are still sometimes broken and are often general (for example, I don’t know). Reinforcement learning was therefore proposed to preserve sequence-level quality as opposed to predicting each word given the sequence history (Ranzato et al., 2015; Kandasamy et al., 2017; Bahdanau et al., 2016).
+
+More recently, generative adversarial networks have been applied to sequence generation, especially for natural language. The discrete nature of random variables for natural language precludes the use of back-propagation. To solve this problem, several approaches have been proposed, such as policy gradient (Yu et al., 2017; Li et al., 2017), Gumbel-Softmax (Kusner & Hernandez-Lobato, 2016), ´ MaliGAN (Che et al., 2017), and directly connected WGAN-GP (Gulrajani et al., 2017; Rajeswar et al., 2017; Press et al., 2017). In most previous work, multiple assistant methods are used to stabilize training and often introduce improvements, for example, Monte-Carlo search (Yu et al., 2017; Li et al., 2017; Che et al., 2017) and curriculum learning (Rajeswar et al., 2017; Press et al., 2017). Furthermore, modifications of the GAN objective function have been proposed to improve quality in text generation (Zhang et al., 2017; Lin et al., 2017).
+
+SeqGAN has been successfully applied on dialogue generation (Li et al., 2017). Due to the high variance of SeqGAN with 1-sample estimate REINFORCE algorithm, researchers use Marte-Carlo search for variation reduction. This method costs extremely high computational resources, therefore Reward for Every Generation Step (REGS) is proposed to replace Monte-Carlo search (Li et al., 2017). Nonetheless, REGS results in a less accurate discriminator because it takes non-terminal sequences into consideration.
+
+To address the weaknesses of Monte-Carlo Search and REGS, we propose stepwise GAN (StepGAN). In this approach, the discriminator evaluates the generated sequences at every generation step, and gives a score for every step. A final score for the whole sequence is the summation of the scores for every time step. This training scheme makes StepGAN a general version of SeqGAN, and can simulate the process of Monte-Carlo search with low extra computational cost. In the proposed approach, both generator and discriminator include weighted factors that change the relative importance of each time step. We find step-time-decreasing weight factors can facilitate the training. This is because the set of hyper-parameters simulate curriculum learning by focusing on generating the head of a sequence. After the first subsequence is fit, further improvement are found in later subsequences.
+
+We construct artificial grammars to assist our realization of GANs in conditional sequence generation. In these tasks, we calculate the accuracy and the coverage of the generated conditioned sequence to evaluate the quality of the model. The coverage is the percentage of the conditioned sequences sampled from the model distribution over all the probable responses. While accuracy reflects coherence and meaningfulness, coverage measures the diversity of the responses. We further compare the proposed approach with several conditional sequence generation approaches on dialogue generation, and evaluate the results by humans. The proposed models are comparable with or even outperform state-of-the-art algorithms.
+
+# 2 RELATED WORK
+
+Conditional sequence generation using the seq2seq model (Sutskever et al., 2014; Vinyals & Le, 2015) has been widely studied, and also for dialogue generation. The model can be learned by maximum-likelihood estimation (MLE), which minimizes the word-level cross-entropy between the true data distribution and the generated approximation. Although this method yields reasonable responses, it suffers from exposure bias and does not take into account sequence-level structure (Ranzato et al., 2015). Exposure bias is introduced because of inconsistent conditions between the training and testing stages: while the ground-truth words are fed to the seq2seq model in the training stage, generated words are used in the testing stage.
+
+To solve these problems with MLE, besides beam search and scheduled sampling (Bengio et al., 2015), (Ranzato et al., 2015) propose the REINFORCE and MIXER algorithms for sequence generation. By providing a task-specific score for the generated sequence, the REINFORCE algorithm (Williams, 1992) guides the seq2seq model to reach higher scores. Because the score is evaluated based on the whole generated sequence, both MLE problems are solved. However, as the REINFORCE algorithm cannot easily train the model from scratch, the MIXER algorithm is proposed to integrate MLE and REINFORCE. In this process, they first train the whole sequence using MLE, after which they accumulate the number of last words trained by REINFORCE. For further improvements, (Bahdanau et al., 2016) adopt another reinforcement learning (Sutton & Barto, 1998) based approach – the actor-critic architecture. They train a critic to predict the expected value of each time step to guide the actor. These algorithms outperform the original MLE algorithm on the task-specific score (BLEU) for text generation. Nonetheless, there is no evidence that these taskspecific scores are correlated with human prior knowledge. In particular, the relationship between the scores and human evaluation has been proven weak for dialogue generation (Liu et al., 2016).
+
+Recently, the significant success of generative adversarial networks (GAN) for image processing has led researchers to use GANs for natural language. However, this has seen limited success because of the difficulty of backpropagation through discrete random variables. To address this problem, (Yu et al., 2017) use policy gradients on text generation. The reward is provided by a discriminator with Monte-Carlo search. In addition, (Li et al., 2017) adopt the same idea for dialogue generation. They also propose Reward for Every Generation Step (REGS), which is more time-efficient but is weaker than Monte-Carlo search. Another way to use GAN for natural-language tasks is by using GumbelSoftmax (Kusner & Hernandez-Lobato, 2016), which can simulate the discrete argmax outputs, ´ and be directly backpropagated from the discriminator. Also, MaliGAN (Che et al., 2017) directly derives the gradient estimator for discrete data. More recently, the improved Wasserstein GAN (WGAN-GP) (Gulrajani et al., 2017) has shown success for text generation by directly feeding the softmax layer to the discriminator, even without pre-training. This breakthrough then inspired (Press et al., 2017) and (Rajeswar et al., 2017) to further investigate WGAN-GP for better performance on text generation.
+
+We focus on the influence of different objective function in GANs on conditional sequence generation throughout this paper. We compare the state-of-the-art algorithms without additional assistance such as teacher forcing, curriculum learning, etc. By this setting, we only consider the improvement attributed by the intrinsic of different algorithms rather than other additional assistances.
+
+# 3 CONDITIONAL SEQUENCE GENERATION
+
+In conditional sequence generation, we generate an output sequence $x \in X$ given an input condition $y \in Y$ . When the output sequence is generated from a model, it is denoted $x ^ { G }$ ; when the output sequence is from real data (training examples), it is instead denoted $x ^ { R }$ . In dialogue generation, both $x$ and $y$ are sequences of words. They can be written as
+
+$$
+\begin{array} { r } { x = \{ x _ { t } \} _ { t = 1 } ^ { T } , x _ { t } \in V } \\ { y = \{ y _ { t } \} _ { t = 1 } ^ { T } , y _ { t } \in V . } \end{array}
+$$
+
+Words $x _ { t }$ and $y _ { t }$ represent the word at time step $t$ in the interval $T$ of the specific sequences $x$ and $y$ . Set $V$ is the vocabulary set from which the words are selected. In this paper, we generate $x ^ { G }$ given $y$ using the seq2seq model as the generator $G$ (Sutskever et al., 2014; Vinyals & Le, 2015). From Sections 3.1 to 3.3, we introduce maximum likelihood estimation, REINFORCE algorithm, and GAN for sequence generation. In Section 4, we introduce the proposed approaches.
+
+# 3.1 MAXIMUM LIKELIHOOD ESTIMATION
+
+The basic idea of maximum likelihood estimation (MLE) for conditional sequence generation is to find the parameters for model $G$ that maximize the likelihood of generating the training data. When using MLE to train the generator model $G$ , the objective function is
+
+$$
+G ^ { * } = \arg \operatorname* { m a x } _ { G } E _ { ( x ^ { R } , y ) \sim P ^ { R } ( X , Y ) } [ \sum _ { t = 1 } ^ { T } \log ( P ^ { G } ( x _ { t } ^ { R } | y , x _ { 1 \dots t - 1 } ^ { R } ) ) ] ,
+$$
+
+whof . $P ^ { R } ( X , Y )$ is the joint distribution of the ning stage, in Eq. (2), the pre $( x , y )$ pairs in the training n is learned based on $T$ e length, but the $x ^ { R }$ $< y , x _ { 1 \ldots t - 1 } ^ { R } >$ condition in the testing stage is $< y , x _ { 1 \ldots t - 1 } ^ { G } >$ . This is known as exposure bias, which can result in accumulating error when testing. This is also due to the likelihood is estimated at the word level (Ranzato et al., 2015) only as opposed to the whole sequence.
+
+# 3.2 REINFORCE
+
+Conditional sequence generation can be formulated as reinforcement learning. Similar to (Ranzato et al., 2015), we describe it as a Markov decision process (MDP), where state $s$ consists of the condition and previous word sequence – in our case, $s = < y , x _ { 1 . . . t - 1 } ^ { G } > -$ and an action $a$ is the generated word conditioned on the current state – in our case, $a = x _ { t } ^ { G }$ is a word in the vocabulary. Each action is generated according to the policy, which is determined by the parameters of generator model $G$ . In typical reinforcement learning, the agent obtains a reward $r _ { t }$ at each time step $t$ . In sequence generation, $r _ { t }$ is zero except for $r _ { T }$ , which evaluates the goodness of the whole generating $x _ { 1 \ldots T } ^ { G ^ { \star } }$ given $y$ . The generator $G$ learns to maximize the expected reward
+
+$$
+G ^ { * } = \arg \operatorname* { m a x } _ { G } E _ { y \sim P ^ { R } \left( Y \right) , x ^ { G } \sim P ^ { G } \left( X \mid y \right) } [ r _ { T } ] ,
+$$
+
+where $P ^ { R } ( Y )$ is the probability distribution of condition $y$ in the training data, $P ^ { G } ( X | y )$ is the probability of generating the sequence $x ^ { G }$ given the generator $G$ and condition . Note that the main difference between Equations (2) and (3) is that the condition sequence here is $x _ { 1 \ldots t - 1 } ^ { G }$ rather than $x _ { 1 \ldots t - 1 } ^ { R }$ . Moreover, each $x _ { t } ^ { G }$ here is sampled using softmax rather than argmax over vocabulary set $V$ . The parameters of the generator $\theta _ { G }$ are updated as
+
+$$
+\theta _ { G }  \theta _ { G } + \eta ( r _ { T } - b _ { t } ) \nabla \log ( p _ { G } ( x _ { t } ^ { G } | y , x _ { 1 \dots t - 1 } ^ { G } ) ) ,
+$$
+
+where $b _ { t }$ is the baseline to reduce training variance (Sutton & Barto, 1998; Ranzato et al., 2015), and $\eta$ is the learning rate.
+
+# 3.3 GENERATIVE ADVERSARIAL NETWORK
+
+A generative adversarial network (GAN) is composed of a generator and a discriminator (Goodfellow et al., 2014). The discriminator differentiates between real data and data from the generator, and the generator attempts to generate plausible data that will deceive the discriminator. Here we use GAN for conditional sequence generation by considering our model $G$ as the generator and constructing a discriminator $D$ sequentially fed with input-output pairs $y$ and $x$ (Mirza & Osindero, 2014; Li et al., 2017).
+
+# 3.3.1 SEQGAN
+
+Since the vocabulary $V$ in the generated sequence is a discrete variable, we cannot backpropagate through the generator. In SeqGAN ( $\mathrm { Y u }$ et al., 2017; Li et al., 2017), the generation task is formulated as a reinforcement learning scenario, similar to that described in Section 3.2, and the reward function is replaced with the discriminator in regular GAN. The discriminator $D$ is then updated through backpropagation, while the generator $G$ is updated using policy gradient with a reward evaluated over $x$ given $y$ by $D$ . The optimization functions for $D$ and $G$ are
+
+$$
+\begin{array} { r l } { } & { \mathcal { D } ^ { * } = \underset { D } { \arg \operatorname* { m a x } } E _ { y \sim P ^ { R } \left( Y \right) , x ^ { R } \sim \mathit { P } ^ { R } \left( X \mid y \right) } [ \log ( D ( x ^ { R } | y ) ) ] + E _ { y \sim \mathit { P } ^ { R } \left( Y \right) , x ^ { G } \sim \mathit { P } ^ { G } \left( X \mid y \right) } [ \log ( 1 - \mathit { D } ( x ^ { G } | y ) ) ] } \\ { } & { \mathcal { X } ^ { * } = \underset { G } { \arg \operatorname* { m a x } } E _ { y \sim \mathit { P } ^ { R } \left( Y \right) , x ^ { G } \sim \mathit { P } ^ { G } \left( X \mid y \right) } [ \mathit { D } ( x ^ { G } | y ) ] . } \end{array}
+$$
+
+In the basic SeqGAN, $G$ in Equation (5) is optimized using the REINFORCE algorithm. The formulation for optimizing $G$ in Equation (5) is the same as Equation (3), except that $r _ { T }$ is replaced with $D ( x ^ { G } | y )$ .
+
+Due to the sparse reward that only given at the terminal state, this basic setting will cause high training variance. For example, when questioning ”What ’s your name ?”, ”I ’m sorry.” is a wrong answer, while ”I ’m John.” is a correct answer. Although they share the same prefix $\because \mathrm { m } ^ { \prime }$ , the basic SeqGAN will give the prefix different reward in different sentences. The solution in (Yu et al., 2017; Che et al., 2017) is Monte Carlo search. For each prefix $x _ { 1 \ldots t }$ , $N$ possible sequences $x _ { t + 1 \ldots T }$ are samples according to the current policy, and the $N$ final rewards are averaged as the reward for current time step. In practice, we have to complete every prefixes for each training data in a batch, and evaluate all of the $m T N$ episodes, where $m$ is the batch size. This method costs extremely high computational resource. For time efficiency, (Li et al., 2017) proposes Reward for Every Generation Step (REGS) to replace Monte Carlo search. Because they train the discriminator in REGS with prefixes without considering whether the episode is terminated, REGS causes a less accurate discriminator.
+
+# 3.3.2 WASSERSTEIN GAN WITH GRADIENT PENALTY (WGAN-GP)
+
+In recent work, WGAP-GP has been successfully used for sequence generation (Gulrajani et al., 2017; Rajeswar et al., 2017; Press et al., 2017). Instead of using more complicate methods such as policy gradient, they directly feed the softmax layer into the discriminator. The generator can therefore be updated through backpropagation. We then formulate the conditional version of WGAN-GP as
+
+$$
+\begin{array} { r l } & { D ^ { * } = \underset { D } { \arg \operatorname* { m a x } } E _ { y \sim P ^ { R } ( y ) , x ^ { R } \sim P ^ { R } ( X | y ) } [ D ( x ^ { R } | y ) ] - E _ { y \sim P ^ { R } ( y ) , x ^ { G } \sim P ^ { G } ( X | y ) } [ D ( x ^ { G } | y ) ] } \\ & { G ^ { * } = \underset { G } { \arg \operatorname* { m a x } } E _ { y \sim P ^ { R } ( Y ) , x ^ { G } \sim P ^ { G } ( X | y ) } [ D ( x ^ { G } | y ) ] . } \end{array}
+$$
+
+# 4 PROPOSED APPROACH: STEPWISE GAN
+
+The basic idea of stepwise GAN (see Fig. 1), or StepGAN, is to construct a sequence-to-sequence model as discriminator $D$ . At each time step of $D$ ’s decoder, the hidden vector is passed to a fully-connected layer. The discriminator $D$ then outputs the evaluation score for each subsequence $\langle y , x _ { 1 \ldots t } \rangle$ , denoted as $D ( x _ { 1 . . . t } | y )$ . With discriminator $D$ , we seek to minimize the summation of $D ( x _ { 1 \ldots t } ^ { G } | y )$ over the time steps when input the generated sequences $x ^ { G }$ . Simultaneously, $D$ maximizes the summation of $D ( x _ { 1 \ldots t } ^ { \mathrm { { R } } } | y )$ when the input is real data $x ^ { R }$ . The optimization of $D$ and $G$ is
+
+![](images/15cf72773c0dc3be0e77149c6fc0495b5b4749ccc9002f79e1d792498ede3668.jpg)  
+Figure 1: Illustration of stepwise GAN
+
+thus
+
+$$
+\begin{array} { l } { { \displaystyle D ^ { \prime } ( x | y ) = \sum _ { t = 1 } ^ { T } \alpha _ { t } ^ { D } D \big ( x _ { 1 \dots t } | y \big ) } } \\ { { \displaystyle D ^ { * } = \arg \operatorname* { m a x } _ { D } E _ { y \sim P ^ { R } ( y ) , x ^ { R } \sim P ^ { R } ( X | y ) } [ \log ( D ^ { \prime } ( x ^ { R } | y ) ) ] } } \\ { { \displaystyle \qquad + E _ { y \sim P ^ { R } ( y ) , x ^ { G } \sim P ^ { G } ( X | y ) } [ \log \big ( 1 - D ^ { \prime } ( x ^ { G } | y ) \big ) ] , } } \\ { { \displaystyle G ^ { * } = \arg \operatorname* { m a x } _ { G } E _ { y \sim P ^ { R } ( Y ) , x ^ { G } \sim P ^ { G } ( X | y ) } [ D ( x ^ { G } | y ) ] , } } \end{array}
+$$
+
+where $\alpha _ { t } ^ { D }$ is a weighted factor with $\textstyle \sum _ { t = 1 } ^ { T } \alpha _ { t } ^ { D } = 1$ . In practice, we set $\begin{array} { r } { \alpha _ { t } ^ { D } = \frac { 1 } { T } } \end{array}$ , but it is possible assign scores for each prefix. Although we only use one way to train $D$ , we think there are two ways to interpret the $D$ ’s scores, and different view points lead to different update formulations for $G$ :
+
+• $D ( x _ { 1 . . . t } | y )$ evaluates the extra benefit of adding the word $x _ { t }$ into the sequence. The formulation for $G$ ’s parameter update is
+
+$$
+\theta _ { G }  \theta _ { G } + \eta \alpha _ { t } ^ { G } ( \sum _ { t ^ { \prime } = t } ^ { T } D ( x _ { 1 \dots t ^ { \prime } } | y ) ) \nabla \log ( p _ { G } ( x _ { t } ^ { G } | y , x _ { 1 \dots t - 1 } ^ { G } ) ) .
+$$
+
+$G$ has to increase the summation $\scriptstyle \sum _ { t ^ { \prime } = t } ^ { T } D ( x _ { 1 \dots t ^ { \prime } } | y )$ . We call this stepGAN-Seq.
+
+• $D ( x _ { 1 . . . t } | y )$ evaluates the average goodness of all the sequences beginning with $x _ { 1 \ldots t }$ . The update formulation for $\theta _ { G }$ is
+
+$$
+\theta _ { G } \gets \theta _ { G } + \eta \alpha _ { t } ^ { G } D ( x _ { 1 \dots t } | y ) \nabla \log ( p _ { G } ( x _ { t } ^ { G } | y , x _ { 1 \dots t - 1 } ^ { G } ) ) .
+$$
+
+The $G$ only needs to learn to increase $D ( x _ { 1 \ldots t } | y )$ . We call this stepGAN in following.
+
+Using factor $\alpha _ { t } ^ { G }$ , we diversify training by arbitrarily weighting the importance of each time step1. We explore the influence of different values of $\alpha _ { t } ^ { \check { G } }$ and compare the two update formulations in section 5 and appendix B.
+
+StepGAN-Seq is a generalized version of SeqGAN. If we set $\alpha _ { T } ^ { D } = 1$ , $\alpha _ { t } ^ { D } = 0$ for $t < T$ , and $\alpha _ { t } ^ { G } = 1$ for all $t$ , then stepGAN-Seq is equivalent to SeqGAN without Monte Carlo search. Also, REGS (Li et al., 2017) can be induced by set $\alpha _ { t } ^ { D } = 1$ at a randomly chosen time step.
+
+StepGAN is similar to the actor-critic architecture in (Bahdanau et al., 2016). Instead of the assigned task-specific score, we learn the score by adversarial learning. Because $D$ ’s scores are the expected return in this setting, we would like StepGAN to approximate the expected return obtained by SeqGAN or MaliGAN with Monte Carlo search. This approach only need to add a set of weight factors, and therefore much time efficient than Monte Carlo search. For more details of the algorithm, please refer to appendix A for pseudo-code.
+
+# 5 EXPERIMENTS
+
+We use a recurrent neural network for both the discriminator and generator due to its strong sequential correlation (Press et al., 2017; Rajeswar et al., 2017). Specifically, we use gated recurrent units (GRUs) (Chung et al., 2014) in our experiments. We view the noise feature in GAN as the random process of sampling from the softmax layer distribution.
+
+# 5.1 ARTIFICIAL GRAMMARS
+
+To better evaluate GANs for conditional sequence generation, we define three artificial grammars: sequence, counting, and addition. The three grammars are described in Table 1. For the sequence grammar, the aim is to generate a continued consecutive number sequence behind the input $Y$ . For example, for input $\langle 1 , 2 , 3 \rangle$ , the answer would be a consecutive number sequence of any length starting with 4, such as $\langle 4 , 5 , 6 , 7 , 8 \rangle$ . The counting grammar is more complicated. The generated sequence should contain exactly 3 words, where the median is a randomly selected word from the input sequence. The first generated word should be the number of words on the left-hand side of the selected median, while the last generated word should be the number of words on the right-hand side. For example, when the input is $\langle 5 , 9 , 2 , 8 , 3 , 2 , 9 , 1 \rangle$ , one permissible generated sequence is $\langle 0 , 5 , 7 \rangle$ . Last, for the addition grammar we generate the addition of two numbers randomly segmented from the input sequence. That is, for input $\langle 8 , 1 , 3 , 4 \rangle$ , then one permissible output is the addition of 8 and 134 – thus $\langle 1 , 4 , 2 \rangle$ . Note that both the input and output numbers for this grammar are represented in terms of their corresponding digits.
+
+The purpose of these design is to imitate major properties in dialogue generation, such as variablelength, repeated prefixes, the same sequence space, one-to-many, and many-to-one. The variablelength property means there is no fixed length for the input and output sequences. The repeated prefixes property means the beginning subsequences are usually shared by many data, for instance What and I am in natural language. The same sequence space here means that the input and output have the same structure and as such are sampled from the same space. Finally, one-to-many and many-to-one are quite common in dialogue generation. For example, when asking How are you?, responses vary from I’m fine to Great! How are you?. Also, the same response can be paired with multiple questions, such as for My name is Paul in response to What’s your name? and Who are you?.
+
+We then randomly generate 100,000 samples as training data, 10,000 as development data, and 10,000 samples as testing data. The architectures are set to one layer with 128 hidden units. We evaluate our results using the three measures in Table 2. The first is the accuracy of samples generated from the argmax policy (Acc), the second is that generated from the softmax probability (AccS), and the last is the coverage of softmax samples over all the permissible answers of the specific grammar (Cov). We report them to ensure whether the one-to-many property is being learned. AccS and Cov are important because they can indicate if the model can learn the underlying distribution of answers. When mode collapse happens, which means the model only know a specific type of answers, it will obtain high AccS and low Cov scores. To ensure a fair comparison, all the algorithms are based on the same pre-trained model: the MLE model listed in Table 2.
+
+Table 1: Grammar definitions and examples   
+
+<table><tr><td>Grammar</td><td>Definition</td><td>Examples</td></tr><tr><td>Sequence</td><td>Continue the sequence for a random length</td><td>123: 4, 45,...</td></tr><tr><td>Counting</td><td>Randomly choose a digit, and then calculate the left-and right-hand lengths</td><td>123: 012,121, 230</td></tr><tr><td>Addition</td><td>Randomly partition,and then add the two numbers</td><td>123: 15,24</td></tr></table>
+
+Table 2: Results of artificial grammars with different algorithms. Evaluation label Acc $( \% )$ is the accuracy of argmax samples, AccS $( \% )$ is the accuracy of softmax samples, and Cov $( \% )$ is the coverage of softmax samples over permissible answers. The dash (-) here indicates that the algorithm introduced no improvements based on the pre-trained model.   
+
+<table><tr><td colspan="4"> Sequence</td><td colspan="3">Counting</td><td colspan="3">Addition</td></tr><tr><td></td><td>Acc</td><td>AccS</td><td>Cov</td><td>Acc</td><td>AccS</td><td>Cov</td><td>Acc</td><td>AccS</td><td>Cov</td></tr><tr><td>MLE</td><td>97.43</td><td>81.32</td><td>53.77</td><td>73.48</td><td>68.89</td><td>70.63</td><td>44.57</td><td>32.28</td><td>31.79</td></tr><tr><td>REINFORCE</td><td>99.81</td><td>97.30</td><td>4.54</td><td>99.97</td><td>99.36</td><td>16.99</td><td>79.98</td><td>75.60</td><td>18.32</td></tr><tr><td>WGAN-GP</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>basic-MaliGAN</td><td>97.34</td><td>81.66</td><td>54.19</td><td>74.12</td><td>70.35</td><td>70.15</td><td>44.27</td><td>32.05</td><td>31.92</td></tr><tr><td>basic-SeqGAN</td><td>97.20</td><td>80.28</td><td>57.61</td><td>74.59</td><td>70.56</td><td>70.39</td><td>44.87</td><td>32.30</td><td>31.90</td></tr><tr><td>MC-SeqGAN</td><td>97.20</td><td>80.98</td><td>55.49</td><td>72.96</td><td>68.10</td><td>70.54</td><td>44.72</td><td>32.28</td><td>31.83</td></tr><tr><td>REGS</td><td>97.42</td><td>81.36</td><td>53.82</td><td>75.99</td><td>70.93</td><td>69.40</td><td>44.64</td><td>32.32</td><td>32.01</td></tr><tr><td>StepGAN-Seq</td><td>97.11</td><td>74.85</td><td>67.49</td><td>75.47</td><td>70.64</td><td>69.82</td><td>45.55</td><td>32.49</td><td>32.01</td></tr><tr><td>StepGAN</td><td>97.19</td><td>75.92</td><td>66.08</td><td>81.98</td><td>72.24</td><td>69.02</td><td>44.94</td><td>32.19</td><td>31.67</td></tr></table>
+
+We discuss the results of MLE, REINFORCE, and state-of-the-art GAN algorithms on Sequence, Counting, and Addition in Table 2. REINFORCE has higher Acc and AccS than ${ \mathrm { M L E } } ^ { 2 }$ , but it results in strong mode-collapse (very low Cov). We have a very strong MLE baseline for Sequence. Therefore we cannot pretrain discriminator well based on this baseline MLE model. Every GAN algorithms cannot outperform MLE by this setting. StepGAN improves Acc on both Counting and Addition without heavily trade-off with Cov. That is, training model using StepGAN enhances and maintains the knowledge of underlying distribution rather than resulting in strong mode-collapse as REINFORCE.
+
+To investigate the trade-off between AccS and Cov, we plot the accuracy-coverage curve in Fig. 2. The trade-off between accuracy and coverage is controlled by sharpening the softmax layer. Besides Fig. 2a, of which the GANs do not obtain good results, StepGAN improves the accuracy-coverage curves in Fig. 2b and Fig. 2c. This is consistent with our realization of Table 2 that StepGAN fits model to the underlying distribution better.
+
+# 5.2 DIALOGUE GENERATION
+
+We split OpenSubtitles (Tiedemann, 2009) into training set, development set, and testing set with a vocabulary of the top 4,000 most frequently occurring words. Both the generator and discriminator are 1-layer GRUs with a hidden dimension set to $5 1 2 ^ { 3 }$ . To compare the improvements introduced by all the algorithms, we first pre-trained the generator using MLE, after which we further trained the model for 1-epoch by different GANs. SeqGAN, MaliGAN, REGS, and StepGAN were compared. We do not compare Monte Carlo search with other approaches because its time complexity is much larger. All discriminators of SeqGAN, MaliGAN, REGS, and StepGAN were pre-trained on real
+
+![](images/51918436916ce27a7936dcb270ad55e741a33a77f82a6d8e511af766a2b1dde4.jpg)  
+Figure 2: Sampled accuracy and coverage curves
+
+Table 3: Human evaluation and BLEU score for dialogue generation. CoHS $( \% )$ is coherence human score. SHS $( \% )$ is sentence structure human score.
+
+<table><tr><td></td><td colspan="3">CoHS (%)</td><td colspan="3">SHS (%)</td><td colspan="3">BLEU</td></tr><tr><td></td><td>Argmax</td><td>BS</td><td>MMI</td><td>Argmax</td><td>BS</td><td>MMI</td><td>Argmax</td><td>BS</td><td>MMI</td></tr><tr><td>MLE</td><td>44.89</td><td>54.22</td><td>60.44</td><td>15.11</td><td>1.33</td><td>7.56</td><td>0.222</td><td>0.281</td><td>0.272</td></tr><tr><td>SeqGAN</td><td>41.33</td><td>53.33</td><td>63.55</td><td>30.67</td><td>6.22</td><td>10.22</td><td>0.202</td><td>0.267</td><td>0.251</td></tr><tr><td>MaliGAN</td><td>35.56</td><td>51.11</td><td>45.33</td><td>20.89</td><td>5.78</td><td>8.00</td><td>0.180</td><td>0.271</td><td>0.263</td></tr><tr><td>REGS</td><td>36.44</td><td>54.67</td><td>53.78</td><td>36.44</td><td>9.33</td><td>9.78</td><td>0.180</td><td>0.256</td><td>0.246</td></tr><tr><td>StepGAN</td><td>47.56</td><td>63.56</td><td>61.33</td><td>40.89</td><td>3.56</td><td>8.89</td><td>0.171</td><td>0.254</td><td>0.248</td></tr></table>
+
+data and generated data from the pre-trained generator. Note that these models were all trained without MIXER, curriculum learning, or teacher forcing, etc. Both the generator and discriminator are optimized by SGD. We used grid search in the experiments with learning rate={1e-1,1e-2,1e-3}, discriminator iteration step={1,5}, and used batchsize $_ { = 6 4 }$ .
+
+For human evaluation, we randomly selected 25 inputs from the testing set, and decoded using argmax policy, beam search, and MMI (Li et al., 2015)4. We presented both an input and the generated outputs to 8 and 4 judges respectively, and we asked them to do Turing test (correct or not) of the coherence and sentence structure. Coherence is the rationality of the generated responses given inputs. Sentence structure is the correctness and complexity of grammar. The sentences provide specific information would be considered as having better sentence structure rather than the general ones (egs. I don’t know.) due to more complex grammar. In Table 3, the two measures are labeled as CoHS (Coherence Human Score) and SHS (Sentence structure Human Score). We also show the BLEU score of each algorithm. It was already found that BLEU score is inconsistent with human evaluation (Liu et al., 2016), we also observe the same phenomenon it in our experiments.
+
+We show the CoHS and SHS of 15 different results (5 different algorithms and 3 different decoding methods) in Table 3. First, we can see decoding using beam search or MMI improve CoHS. StepGAN obtains the best performance in terms of CoHS when using argmax policy or beam search, but StepGAN cannot further increase the performance using MMI. When using MMI, the CoHS of MLE, SeqGAN and StepGAN are comparable. Second, argmax policy has higher SHS than beam search and MMI in all cases. In the meantime, GANs have higher SHS than MLE, and StepGAN has the highest score with argmax. The inconsistency of improvement between argmax policy, beam search and MMI is very likely because that the GANs are learned with the softmax policy and do not consider beam search and MMI during training. Additionally, we know beam search and MMI maximize the probability of response given an input without maintaining the probability of the response itself. This makes them prefer a coherence response rather than a good sentence structure. These statistics show that SeqGAN, MaliGAN, and REGS cannot consistently improve both coherence and sentence structure, whereas StepGAN outperforms MLE in terms both CoHS and SHS with all decoding methods.5
+
+![](images/2f5e0ffc3242f4a5aab01b71dbbb5daaaca0aa7de2df387887037e42946a04f8.jpg)  
+Figure 3: The variation of discriminators’ scores using different GAN algorithms during training iterations. The printed color is normalized throughout the generation steps $\mathbf { \bar { x } }$ -axis) for each algorithm. (a)(b) are given “how are you ?” as input, and (c)(d) are given “what ’s your name ?” as input.
+
+To understand what the discriminators learn, we measure the variance throughout the training iterations at each generation step. In adversarial learning, discriminator’s scores oscillate during training according to the current performance of generator. We argue that discriminator’s score for the most crucial generation step is the most easy to oscillate. This is because the generation step is the most important one for discriminator to identify whether it’s real or fake. In Fig. (3), we show four examples. Fig. (3a) and Fig. (3b) are respectively true response and wrong response given input question ”how are you ?”, and Fig. (3c) and Fig. (3d) are given input question ”what ’s your name ?. The darker color indicates the higher variance on the generation step.
+
+In Fig. (3), the colors for SeqGAN is always the same. Because the disriminator of SeqGAN only evaluate the whole sequence, the generation steps means no difference to discriminator. Second, REGS and StepGAN both aim to approximate Monte-Carlo search on SeqGAN, but in practice, we can clearly see that the variance of REGS is very different from Monte Carlo search. This is because REGS considers non-terminated episodes, which makes REGS has to spend extra effort on the generation maximum length to check whether there’s a terminal state $( < E O S > )$ . The results of StepGAN and Monte Carlo search (MC-SeqGAN) are quite similar. Based on MC-SeqGAN and StepGAN, the important parts (with darker colors) in the sentences for discriminating the true ones from fake correspond to human knowledge. For example, ”fine , thank you ” are the most important region in Fig. (3a), ”sorry , i ’m sorry” are the most important region in Fig. (3b) when answering ”how are you ?”. When given ”what ’s your name ?”, MC-SeqGAN and StepGAN focus on ”’m john” in Fig. (3c) and ”sorry” in Fig. (3d). We believe the success of StepGAN comes from estimating the goodness of a sequence at every generation step as Monte Carlo search, but with little extra computation.
+
+# 6 CONCLUSION
+
+In this paper we propose StepGAN to approximate Monte Carlo search with a much lower computational cost.We show that the proposed StepGAN performs equally to or outperforms the state-ofthe-art GAN algorithms on artificial grammars. On a representative real-world conditional sequence generation task–dialogue generation, StepGAN also outperforms other approaches on both coherence and sentence structure.
+
+Our proposed artificial grammars not only accurately reflect model coverage and accuracy but also boast clearly distinguishable styles. For example, the sequence style can be the length, the counting style can be the selected digit position, and the addition style can be the selected partition position. This property lends itself to investigating style transfering for sequences generation, which is one of our aims for future work.
+
+REFERENCES   
+Dzmitry Bahdanau, Philemon Brakel, Kelvin Xu, Anirudh Goyal, Ryan Lowe, Joelle Pineau, Aaron Courville, and Yoshua Bengio. An actor-critic algorithm for sequence prediction. arXiv preprint arXiv:1607.07086, 2016.   
+Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 1171–1179, 2015.   
+Tong Che, Yanran Li, Ruixiang Zhang, R Devon Hjelm, Wenjie Li, Yangqiu Song, and Yoshua Bengio. Maximum-likelihood augmented discrete generative adversarial networks. arXiv preprint arXiv:1702.07983, 2017.   
+Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.   
+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.   
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of wasserstein gans. arXiv preprint arXiv:1704.00028, 2017.   
+Kirthevasan Kandasamy, Yoram Bachrach, Ryota Tomioka, Daniel Tarlow, and David Carter. Batch policy gradient methods for improving neural conversation models. arXiv preprint arXiv:1702.03334, 2017.   
+Matt J Kusner and Jose Miguel Hern ´ andez-Lobato. Gans for sequences of discrete elements with ´ the gumbel-softmax distribution. arXiv preprint arXiv:1611.04051, 2016.   
+Jiwei Li, Michel Galley, Chris Brockett, Jianfeng Gao, and Bill Dolan. A diversity-promoting objective function for neural conversation models. arXiv preprint arXiv:1510.03055, 2015.   
+Jiwei Li, Will Monroe, Tianlin Shi, Alan Ritter, and Dan Jurafsky. Adversarial learning for neural dialogue generation. arXiv preprint arXiv:1701.06547, 2017.   
+Kevin Lin, Dianqi Li, Xiaodong He, Zhengyou Zhang, and Ming-Ting Sun. Adversarial ranking for language generation. arXiv preprint arXiv:1705.11001, 2017.   
+Chia-Wei Liu, Ryan Lowe, Iulian V Serban, Michael Noseworthy, Laurent Charlin, and Joelle Pineau. How not to evaluate your dialogue system: An empirical study of unsupervised evaluation metrics for dialogue response generation. arXiv preprint arXiv:1603.08023, 2016.   
+Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint arXiv:1411.1784, 2014.   
+Ofir Press, Amir Bar, Ben Bogin, Jonathan Berant, and Lior Wolf. Language generation with recurrent generative adversarial networks without pre-training. arXiv preprint arXiv:1706.01399, 2017.   
+Sai Rajeswar, Sandeep Subramanian, Francis Dutil, Christopher Pal, and Aaron Courville. Adversarial generation of natural language. arXiv preprint arXiv:1705.10929, 2017.   
+Marc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence level training with recurrent neural networks. arXiv preprint arXiv:1511.06732, 2015.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104–3112, 2014.
+
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction, volume 1. MIT press Cambridge, 1998.
+
+Jorg Tiedemann. News from OPUS - A collection of multilingual parallel corpora with tools ¨ and interfaces. In N. Nicolov, K. Bontcheva, G. Angelova, and R. Mitkov (eds.), Recent Advances in Natural Language Processing, volume V, pp. 237–248. John Benjamins, Amsterdam/Philadelphia, Borovets, Bulgaria, 2009. ISBN 978 90 272 4825 1.
+
+Oriol Vinyals and Quoc Le. A neural conversational model. arXiv preprint arXiv:1506.05869, 2015.
+
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992.
+
+Lantao Yu, Weinan Zhang, Jun Wang, and Yong Yu. Seqgan: Sequence generative adversarial nets with policy gradient. In AAAI, pp. 2852–2858, 2017.
+
+Yizhe Zhang, Zhe Gan, Kai Fan, Zhi Chen, Ricardo Henao, Dinghan Shen, and Lawrence Carin. Adversarial feature matching for text generation. arXiv preprint arXiv:1706.03850, 2017.
+
+Junbo Zhao, Michael Mathieu, and Yann LeCun. Energy-based generative adversarial network. arXiv preprint arXiv:1609.03126, 2016.
+
+# A APPENDIX: PSEUDO CODE OF STEPWISE GAN
+
+Table 4: Pseudo code of stepwise GAN   
+Algorithm 1 Stepwise GAN (StepGAN) Training   
+
+<table><tr><td>1</td><td>for number of training iterations do</td></tr><tr><td>2</td><td>for i=1, D-steps do Sample (y,xR) from real data</td></tr><tr><td>3</td><td></td></tr><tr><td>4</td><td>Sample xG ~ PG(.ly)</td></tr><tr><td>5</td><td>Update D using equation (7) T</td></tr><tr><td>6</td><td>D&#x27;(xly)=∑-1PD(x.tly)</td></tr><tr><td>7</td><td>D* = arg maxD Ey~pR(y),R~pR(xly)[log(D&#x27;(xR|y))] +Ey~PR(y),xG~PG(xly)[log(1-D&#x27;(xG|y)]</td></tr><tr><td>8</td><td>end for</td></tr><tr><td>9</td><td>for i=1, G-steps do</td></tr><tr><td>10</td><td>Sample y from real data</td></tr><tr><td>11</td><td>Sample xG ~ PG(.ly)</td></tr><tr><td>12</td><td>Update G using equation (9)</td></tr><tr><td>13</td><td>0G ←0G + na£D(x1...tly)Vlog(𝑝G(x£ly,x...t-1))</td></tr><tr><td>14</td><td>end for</td></tr><tr><td>15</td><td>end for</td></tr><tr><td></td><td></td></tr></table>
+
+# B WEIGHTED FACTORS SEARCH OF STEPGAN AND STEPGAN-SEQ
+
+Table 5: StepGAN and StepGAN-Seq with different weight factors. The dash (-) here notes that the weight factors yield neither improvements nor deterioration.   
+
+<table><tr><td colspan="7">StepGAN StepGAN-Seq</td></tr><tr><td colspan="2"></td><td>Acc</td><td>AccS</td><td>Cov</td><td>Acc</td><td>AccS Cov</td></tr><tr><td rowspan="3">Sequence</td><td>Uniform</td><td>97.19</td><td>75.92</td><td>66.08</td><td>97.11</td><td>74.85 67.49</td></tr><tr><td>Increase</td><td>97.17</td><td>75.33</td><td>66.75 97.18</td><td>73.30</td><td>68.19</td></tr><tr><td>Decrease</td><td>97.16</td><td>74.73</td><td>67.14</td><td>97.09 74.34</td><td>67.48</td></tr><tr><td rowspan="3">Counting</td><td>Uniform</td><td>77.23</td><td>71.43</td><td>70.18</td><td>74.91</td><td>70.70 69.84</td></tr><tr><td>Increasing</td><td>74.50</td><td>69.66</td><td>70.86</td><td>74.54 70.74</td><td>70.11</td></tr><tr><td>Decreasing</td><td>81.98</td><td>72.24</td><td>69.02</td><td>75.47 70.64</td><td>69.82</td></tr><tr><td rowspan="3">Addition</td><td>Uniform</td><td>44.26</td><td>32.39</td><td>31.91</td><td>44.77</td><td>32.34 31.65</td></tr><tr><td>Increasing</td><td>1</td><td>1 -</td><td>=</td><td>1</td><td>1</td></tr><tr><td>Decreasing</td><td>44.94</td><td>32.19</td><td>31.67</td><td>45.55 32.49</td><td>32.01</td></tr></table>
+
+We compare different weighted factors $\alpha ^ { G }$ for StepGAN and StepGAN-Seq, with $\begin{array} { r } { \alpha _ { t } ^ { D } = \frac { 1 } { T } } \end{array}$ for all the presented cases. As depicted in Table 5, the three grammars are trained using three sorts of weighted factors: uniform $\begin{array} { r } { \dot { \left( \alpha _ { t } ^ { G } \ = \ 1 \right) } } \end{array}$ ), increasing $( \alpha _ { t } ^ { G } \ = t )$ , and decreasing $( \alpha _ { t } ^ { G } \ = \ T - \ t + 1 )$ . The results clearly show that the time-step-decreasing weight factors positively affect training. We believe this is because the training spirit of decreased weighted factor start from first correcting prefix. After correcting prefix, it becomes easier to correct the suffix. Please refer to section 5 if you are interested in the details of Acc, AccS, and Cov.
+
+# C ENERGY-BASED STEPWISE GAN (EBSTEPGAN)
+
+We propose energy-based stepwise GAN (EBStepGAN) that only change the form of objective function of StepGAN. This is mainly inspired by energy-based GAN (Zhao et al., 2016). As depicted in Fig. 4, the discriminator $D$ here has the same architecture as generator $G$ , and its energy function is cross-entropy. Discriminator assigns low energy to real samples and high enery to generated samples. The advantage of EBStepGAN is that we can initialize both generator and discriminator with the same pre-trained model using MLE. The optimization functions are written as
+
+![](images/644661665ab6f5463846bfc5f87051f82283916167e2527b207cd6ca308a0415.jpg)  
+Figure 4: Illustration of energy-based stepwise GAN
+
+$$
+\begin{array} { l } { { \displaystyle D ^ { * } = \arg \operatorname* { m a x } _ { D } E _ { ( x ^ { R } , y ) \sim P ^ { R } ( X , Y ) } [ \sum _ { t = 1 } ^ { T } l o g ( P ^ { D } ( x _ { t } ^ { R } | y , x _ { 1 \dots t - 1 } ^ { R } ) ) ] } } \\ { { \displaystyle \qquad + m a x i m u m ( 0 , \beta - E _ { y \sim P ^ { R } ( Y ) , x ^ { G } \sim P ^ { G } ( X | y ) } [ \sum _ { t = 1 } ^ { T } l o g ( P ^ { D } ( x _ { t } ^ { G } | y , x _ { 1 \dots t - 1 } ^ { G } ) ) ] ) } } \end{array}
+$$
+
+$$
+G ^ { * } = \arg \operatorname* { m a x } _ { G } E _ { y \sim P ^ { R } ( Y ) , x ^ { G } \sim P ^ { G } ( X | y ) } [ \sum _ { t = 1 } ^ { T } l o g ( P ^ { D } ( x _ { t } ^ { G } | y , x _ { 1 \dots t - 1 } ^ { G } ) ) ] ,
+$$
+
+where $P ^ { D } ( x _ { t } ^ { G } | y , x _ { 1 \dots t - 1 } ^ { G } )$ in Equation (11) is the probability of generating $x _ { t } ^ { G }$ given $< y , x _ { 1 \ldots t - 1 } ^ { G } >$ based on the current model , and $\beta$ in Equation (10) is the threshold for preventing the discriminator from distinguishing generated samples from real samples too easily. When the energy of generated samples is too high, the threshold turns off the second term in (10). The results of EBStepGAN is shown in Table 6. According to Table 6, EBStepGAN does not show better performance than StepGAN in our current experiments.
+
+Table 6: Results of artificial grammars by EBStepGAN. Please check Table 2 for other results.   
+
+<table><tr><td colspan="4"> Sequence</td><td colspan="3">Counting</td><td colspan="3">Addition</td></tr><tr><td></td><td>Acc</td><td>AccS</td><td>Cov</td><td>Acc</td><td>AccS</td><td>Cov</td><td>Acc</td><td>AccS</td><td>Cov</td></tr><tr><td>EBStepGAN</td><td>97.32</td><td>80.09</td><td>57.12</td><td>79.78</td><td>71.52</td><td>68.44</td><td>45.74</td><td>32.68</td><td>32.11</td></tr></table>
+
+# D APPENDIX: EXAMPLES OF NEURAL DIALOGUE GENERATION
+
+Table 7: Examples of neural dialogue generation trained on OpenSubtitles   
+
+<table><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1>hello,i&#x27;m senator snatch</td></tr><tr><td rowspan=1 colspan=1>MLESeqGANMaliGANREGSStepGAN</td><td rowspan=1 colspan=1>i&#x27;m sorry .i&#x27;m sorry,i&#x27;m sorry.i&#x27;m a good man . i&#x27;m here to see you againsorry you &#x27;re late</td></tr><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1>i got the money right here .</td></tr><tr><td rowspan=1 colspan=1>MLESeqGANMaliGANREGSStepGAN</td><td rowspan=1 colspan=1>i&#x27;m sorry .i&#x27;m here to help .ican.ican &#x27;t do it .i&#x27;ll take you home .</td></tr><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1>hope you enjoyed your pee ..because it ’&#x27;s your last on this trip .</td></tr><tr><td rowspan=1 colspan=1>MLESeqGANMaliGANREGSStepGAN</td><td rowspan=1 colspan=1>it &#x27;s not a problem . it &#x27;s not your fault .it doesn &#x27;t matter . it &#x27;s not a dream . it &#x27;s the only thing i can do .</td></tr><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1>he say ... if you want to be an actor,he has something to show you .</td></tr><tr><td rowspan=1 colspan=1>MLESeqGANMaliGANREGSStepGAN</td><td rowspan=1 colspan=1>you &#x27;re not .you can &#x27;t do that .what &#x27;s he mean ?he &#x27;s a very good guy , you know .you &#x27;re not gonna be a liar .</td></tr><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1> thank you, thank you .</td></tr><tr><td rowspan=1 colspan=1>MLESeqGANMaliGANREGSStepGAN</td><td rowspan=1 colspan=1>i&#x27;m sorry.i&#x27;m sorry ,sir .thank you .i&#x27;ll be right back .you &#x27;re welcome .</td></tr><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1>i feel like a paris princess.</td></tr><tr><td rowspan=1 colspan=1>MLESeqGANMaliGANREGSStepGAN</td><td rowspan=1 colspan=1>iknow it .i know that you &#x27;re not there .i feel like ..i can &#x27;t see it . you &#x27;re not a child anymore .</td></tr><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1>i&#x27;m tired of all your questions</td></tr><tr><td rowspan=1 colspan=1>MLESeqGANMaliGANREGSStepGAN</td><td rowspan=1 colspan=1>i&#x27;m gonna have to ask you to come . i&#x27;m gonna call you .i&#x27;ma friend. i &#x27;m going to have to ask you to come in i&#x27;m going to be a friend of you .</td></tr><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1> it &#x27;s great .</td></tr><tr><td rowspan=1 colspan=2>MLE yeah.SeqGAN  it &#x27;s great, huh ?MaliGAN  it &#x27;s great .REGS i was just thinking about it .StepGAN you &#x27;re so sweet .</td></tr></table>

parse/train/r1YqWz-R-/r1YqWz-R-_content_list.json

@@ -0,0 +1,1248 @@
+[
+    {
+        "type": "text",
+        "text": "IMPROVING CONDITIONAL SEQUENCE GENERATIVE ADVERSARIAL NETWORKS BY STEPWISE EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            170
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            195,
+            398,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            261,
+            544,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Conditional sequence generation is a widely researched topic. One of the most important tasks is dialogue generation, which is composed of input-output pairs with the one-to-many property. Given the recent success of generative adversarial networks (GANs), GANs have been used for sequence generation. However, there is still limited work of its application on conditional sequence generation. We investigate the influence of GAN on conditional sequence generation with three artificial grammars and dialogue generation. Moreover, we propose stepwise GAN (StepGAN) for conditional sequence generation, which predicts the reward at each time-step. StepGAN can be seen as the general version of SeqGAN. It estimates the expected returns predicted by Monte-Carlo Search in SeqGAN, but it has a lower computational cost than Monte-Carlo Search. Experimental results show that stepwise GAN can outperform other state-of-the-art algorithms in most tasks. ",
+        "bbox": [
+            233,
+            290,
+            764,
+            457
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            482,
+            336,
+            497
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Conditional sequence generation is the task of generating the correspondent response given an input sequence. One of the most important applications is dialogue generation. Dialogue generation is one-to-many; that is, there can be many acceptable responses for a specific input. In previous work, the sequence-to-sequence based dialogue generation model is trained using maximum likelihood estimation, and achieves promising results in terms of both meaning and coherence (Vinyals & Le, 2015). Despite this success, the generated responses given the inputs are still sometimes broken and are often general (for example, I don’t know). Reinforcement learning was therefore proposed to preserve sequence-level quality as opposed to predicting each word given the sequence history (Ranzato et al., 2015; Kandasamy et al., 2017; Bahdanau et al., 2016). ",
+        "bbox": [
+            174,
+            512,
+            825,
+            638
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "More recently, generative adversarial networks have been applied to sequence generation, especially for natural language. The discrete nature of random variables for natural language precludes the use of back-propagation. To solve this problem, several approaches have been proposed, such as policy gradient (Yu et al., 2017; Li et al., 2017), Gumbel-Softmax (Kusner & Hernandez-Lobato, 2016), ´ MaliGAN (Che et al., 2017), and directly connected WGAN-GP (Gulrajani et al., 2017; Rajeswar et al., 2017; Press et al., 2017). In most previous work, multiple assistant methods are used to stabilize training and often introduce improvements, for example, Monte-Carlo search (Yu et al., 2017; Li et al., 2017; Che et al., 2017) and curriculum learning (Rajeswar et al., 2017; Press et al., 2017). Furthermore, modifications of the GAN objective function have been proposed to improve quality in text generation (Zhang et al., 2017; Lin et al., 2017). ",
+        "bbox": [
+            174,
+            645,
+            825,
+            784
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "SeqGAN has been successfully applied on dialogue generation (Li et al., 2017). Due to the high variance of SeqGAN with 1-sample estimate REINFORCE algorithm, researchers use Marte-Carlo search for variation reduction. This method costs extremely high computational resources, therefore Reward for Every Generation Step (REGS) is proposed to replace Monte-Carlo search (Li et al., 2017). Nonetheless, REGS results in a less accurate discriminator because it takes non-terminal sequences into consideration. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To address the weaknesses of Monte-Carlo Search and REGS, we propose stepwise GAN (StepGAN). In this approach, the discriminator evaluates the generated sequences at every generation step, and gives a score for every step. A final score for the whole sequence is the summation of the scores for every time step. This training scheme makes StepGAN a general version of SeqGAN, and can simulate the process of Monte-Carlo search with low extra computational cost. In the proposed approach, both generator and discriminator include weighted factors that change the relative importance of each time step. We find step-time-decreasing weight factors can facilitate the training. This is because the set of hyper-parameters simulate curriculum learning by focusing on generating the head of a sequence. After the first subsequence is fit, further improvement are found in later subsequences. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            200
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We construct artificial grammars to assist our realization of GANs in conditional sequence generation. In these tasks, we calculate the accuracy and the coverage of the generated conditioned sequence to evaluate the quality of the model. The coverage is the percentage of the conditioned sequences sampled from the model distribution over all the probable responses. While accuracy reflects coherence and meaningfulness, coverage measures the diversity of the responses. We further compare the proposed approach with several conditional sequence generation approaches on dialogue generation, and evaluate the results by humans. The proposed models are comparable with or even outperform state-of-the-art algorithms. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            319
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            342,
+            344,
+            358
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Conditional sequence generation using the seq2seq model (Sutskever et al., 2014; Vinyals & Le, 2015) has been widely studied, and also for dialogue generation. The model can be learned by maximum-likelihood estimation (MLE), which minimizes the word-level cross-entropy between the true data distribution and the generated approximation. Although this method yields reasonable responses, it suffers from exposure bias and does not take into account sequence-level structure (Ranzato et al., 2015). Exposure bias is introduced because of inconsistent conditions between the training and testing stages: while the ground-truth words are fed to the seq2seq model in the training stage, generated words are used in the testing stage. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            486
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To solve these problems with MLE, besides beam search and scheduled sampling (Bengio et al., 2015), (Ranzato et al., 2015) propose the REINFORCE and MIXER algorithms for sequence generation. By providing a task-specific score for the generated sequence, the REINFORCE algorithm (Williams, 1992) guides the seq2seq model to reach higher scores. Because the score is evaluated based on the whole generated sequence, both MLE problems are solved. However, as the REINFORCE algorithm cannot easily train the model from scratch, the MIXER algorithm is proposed to integrate MLE and REINFORCE. In this process, they first train the whole sequence using MLE, after which they accumulate the number of last words trained by REINFORCE. For further improvements, (Bahdanau et al., 2016) adopt another reinforcement learning (Sutton & Barto, 1998) based approach – the actor-critic architecture. They train a critic to predict the expected value of each time step to guide the actor. These algorithms outperform the original MLE algorithm on the task-specific score (BLEU) for text generation. Nonetheless, there is no evidence that these taskspecific scores are correlated with human prior knowledge. In particular, the relationship between the scores and human evaluation has been proven weak for dialogue generation (Liu et al., 2016). ",
+        "bbox": [
+            174,
+            492,
+            825,
+            686
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, the significant success of generative adversarial networks (GAN) for image processing has led researchers to use GANs for natural language. However, this has seen limited success because of the difficulty of backpropagation through discrete random variables. To address this problem, (Yu et al., 2017) use policy gradients on text generation. The reward is provided by a discriminator with Monte-Carlo search. In addition, (Li et al., 2017) adopt the same idea for dialogue generation. They also propose Reward for Every Generation Step (REGS), which is more time-efficient but is weaker than Monte-Carlo search. Another way to use GAN for natural-language tasks is by using GumbelSoftmax (Kusner & Hernandez-Lobato, 2016), which can simulate the discrete argmax outputs, ´ and be directly backpropagated from the discriminator. Also, MaliGAN (Che et al., 2017) directly derives the gradient estimator for discrete data. More recently, the improved Wasserstein GAN (WGAN-GP) (Gulrajani et al., 2017) has shown success for text generation by directly feeding the softmax layer to the discriminator, even without pre-training. This breakthrough then inspired (Press et al., 2017) and (Rajeswar et al., 2017) to further investigate WGAN-GP for better performance on text generation. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We focus on the influence of different objective function in GANs on conditional sequence generation throughout this paper. We compare the state-of-the-art algorithms without additional assistance such as teacher forcing, curriculum learning, etc. By this setting, we only consider the improvement attributed by the intrinsic of different algorithms rather than other additional assistances. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 CONDITIONAL SEQUENCE GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            154,
+            540,
+            170
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In conditional sequence generation, we generate an output sequence $x \\in X$ given an input condition $y \\in Y$ . When the output sequence is generated from a model, it is denoted $x ^ { G }$ ; when the output sequence is from real data (training examples), it is instead denoted $x ^ { R }$ . In dialogue generation, both $x$ and $y$ are sequences of words. They can be written as ",
+        "bbox": [
+            173,
+            185,
+            825,
+            242
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b6ddd1fa52ab57c49ed335a1686a3d35ecebc610e4d81a4ee471bf736566d6ea.jpg",
+        "text": "$$\n\\begin{array} { r } { x = \\{ x _ { t } \\} _ { t = 1 } ^ { T } , x _ { t } \\in V } \\\\ { y = \\{ y _ { t } \\} _ { t = 1 } ^ { T } , y _ { t } \\in V . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            250,
+            571,
+            292
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Words $x _ { t }$ and $y _ { t }$ represent the word at time step $t$ in the interval $T$ of the specific sequences $x$ and $y$ . Set $V$ is the vocabulary set from which the words are selected. In this paper, we generate $x ^ { G }$ given $y$ using the seq2seq model as the generator $G$ (Sutskever et al., 2014; Vinyals & Le, 2015). From Sections 3.1 to 3.3, we introduce maximum likelihood estimation, REINFORCE algorithm, and GAN for sequence generation. In Section 4, we introduce the proposed approaches. ",
+        "bbox": [
+            173,
+            297,
+            825,
+            368
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 MAXIMUM LIKELIHOOD ESTIMATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            386,
+            477,
+            400
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The basic idea of maximum likelihood estimation (MLE) for conditional sequence generation is to find the parameters for model $G$ that maximize the likelihood of generating the training data. When using MLE to train the generator model $G$ , the objective function is ",
+        "bbox": [
+            174,
+            412,
+            825,
+            455
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/98c2280934f1732ac9d5dfa19dc1eea051281da98e949e1e97ec6574931f9c05.jpg",
+        "text": "$$\nG ^ { * } = \\arg \\operatorname* { m a x } _ { G } E _ { ( x ^ { R } , y ) \\sim P ^ { R } ( X , Y ) } [ \\sum _ { t = 1 } ^ { T } \\log ( P ^ { G } ( x _ { t } ^ { R } | y , x _ { 1 \\dots t - 1 } ^ { R } ) ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            463,
+            709,
+            506
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "whof . $P ^ { R } ( X , Y )$ is the joint distribution of the ning stage, in Eq. (2), the pre $( x , y )$ pairs in the training n is learned based on $T$ e length, but the $x ^ { R }$ $< y , x _ { 1 \\ldots t - 1 } ^ { R } >$ condition in the testing stage is $< y , x _ { 1 \\ldots t - 1 } ^ { G } >$ . This is known as exposure bias, which can result in accumulating error when testing. This is also due to the likelihood is estimated at the word level (Ranzato et al., 2015) only as opposed to the whole sequence. ",
+        "bbox": [
+            173,
+            515,
+            825,
+            588
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 REINFORCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            606,
+            313,
+            621
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Conditional sequence generation can be formulated as reinforcement learning. Similar to (Ranzato et al., 2015), we describe it as a Markov decision process (MDP), where state $s$ consists of the condition and previous word sequence – in our case, $s = < y , x _ { 1 . . . t - 1 } ^ { G } > -$ and an action $a$ is the generated word conditioned on the current state – in our case, $a = x _ { t } ^ { G }$ is a word in the vocabulary. Each action is generated according to the policy, which is determined by the parameters of generator model $G$ . In typical reinforcement learning, the agent obtains a reward $r _ { t }$ at each time step $t$ . In sequence generation, $r _ { t }$ is zero except for $r _ { T }$ , which evaluates the goodness of the whole generating $x _ { 1 \\ldots T } ^ { G ^ { \\star } }$ given $y$ . The generator $G$ learns to maximize the expected reward ",
+        "bbox": [
+            173,
+            632,
+            825,
+            747
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9bc018fca1267a9ce7d0a66d3f4bfb64b19f00472f9734b80ba978d114ae3c6d.jpg",
+        "text": "$$\nG ^ { * } = \\arg \\operatorname* { m a x } _ { G } E _ { y \\sim P ^ { R } \\left( Y \\right) , x ^ { G } \\sim P ^ { G } \\left( X \\mid y \\right) } [ r _ { T } ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            756,
+            642,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $P ^ { R } ( Y )$ is the probability distribution of condition $y$ in the training data, $P ^ { G } ( X | y )$ is the probability of generating the sequence $x ^ { G }$ given the generator $G$ and condition . Note that the main difference between Equations (2) and (3) is that the condition sequence here is $x _ { 1 \\ldots t - 1 } ^ { G }$ rather than $x _ { 1 \\ldots t - 1 } ^ { R }$ . Moreover, each $x _ { t } ^ { G }$ here is sampled using softmax rather than argmax over vocabulary set $V$ . The parameters of the generator $\\theta _ { G }$ are updated as ",
+        "bbox": [
+            173,
+            786,
+            825,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/44b11792fb97c89a15701dfe1adad9ea95db34a7f69ddbe24062143b3c74c1dd.jpg",
+        "text": "$$\n\\theta _ { G }  \\theta _ { G } + \\eta ( r _ { T } - b _ { t } ) \\nabla \\log ( p _ { G } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            868,
+            665,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $b _ { t }$ is the baseline to reduce training variance (Sutton & Barto, 1998; Ranzato et al., 2015), and $\\eta$ is the learning rate. ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3 GENERATIVE ADVERSARIAL NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            490,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A generative adversarial network (GAN) is composed of a generator and a discriminator (Goodfellow et al., 2014). The discriminator differentiates between real data and data from the generator, and the generator attempts to generate plausible data that will deceive the discriminator. Here we use GAN for conditional sequence generation by considering our model $G$ as the generator and constructing a discriminator $D$ sequentially fed with input-output pairs $y$ and $x$ (Mirza & Osindero, 2014; Li et al., 2017). ",
+        "bbox": [
+            174,
+            128,
+            825,
+            213
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3.1 SEQGAN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            228,
+            295,
+            243
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since the vocabulary $V$ in the generated sequence is a discrete variable, we cannot backpropagate through the generator. In SeqGAN ( $\\mathrm { Y u }$ et al., 2017; Li et al., 2017), the generation task is formulated as a reinforcement learning scenario, similar to that described in Section 3.2, and the reward function is replaced with the discriminator in regular GAN. The discriminator $D$ is then updated through backpropagation, while the generator $G$ is updated using policy gradient with a reward evaluated over $x$ given $y$ by $D$ . The optimization functions for $D$ and $G$ are ",
+        "bbox": [
+            174,
+            252,
+            826,
+            337
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ce9e0c11c994a7a44c8e7b2af6bfa8145624990a44cec4006ecf0560ec87f505.jpg",
+        "text": "$$\n\\begin{array} { r l } { } & { \\mathcal { D } ^ { * } = \\underset { D } { \\arg \\operatorname* { m a x } } E _ { y \\sim P ^ { R } \\left( Y \\right) , x ^ { R } \\sim \\mathit { P } ^ { R } \\left( X \\mid y \\right) } [ \\log ( D ( x ^ { R } | y ) ) ] + E _ { y \\sim \\mathit { P } ^ { R } \\left( Y \\right) , x ^ { G } \\sim \\mathit { P } ^ { G } \\left( X \\mid y \\right) } [ \\log ( 1 - \\mathit { D } ( x ^ { G } | y ) ) ] } \\\\ { } & { \\mathcal { X } ^ { * } = \\underset { G } { \\arg \\operatorname* { m a x } } E _ { y \\sim \\mathit { P } ^ { R } \\left( Y \\right) , x ^ { G } \\sim \\mathit { P } ^ { G } \\left( X \\mid y \\right) } [ \\mathit { D } ( x ^ { G } | y ) ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            342,
+            838,
+            395
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the basic SeqGAN, $G$ in Equation (5) is optimized using the REINFORCE algorithm. The formulation for optimizing $G$ in Equation (5) is the same as Equation (3), except that $r _ { T }$ is replaced with $D ( x ^ { G } | y )$ . ",
+        "bbox": [
+            174,
+            412,
+            825,
+            457
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Due to the sparse reward that only given at the terminal state, this basic setting will cause high training variance. For example, when questioning ”What ’s your name ?”, ”I ’m sorry.” is a wrong answer, while ”I ’m John.” is a correct answer. Although they share the same prefix $\\because \\mathrm { m } ^ { \\prime }$ , the basic SeqGAN will give the prefix different reward in different sentences. The solution in (Yu et al., 2017; Che et al., 2017) is Monte Carlo search. For each prefix $x _ { 1 \\ldots t }$ , $N$ possible sequences $x _ { t + 1 \\ldots T }$ are samples according to the current policy, and the $N$ final rewards are averaged as the reward for current time step. In practice, we have to complete every prefixes for each training data in a batch, and evaluate all of the $m T N$ episodes, where $m$ is the batch size. This method costs extremely high computational resource. For time efficiency, (Li et al., 2017) proposes Reward for Every Generation Step (REGS) to replace Monte Carlo search. Because they train the discriminator in REGS with prefixes without considering whether the episode is terminated, REGS causes a less accurate discriminator. ",
+        "bbox": [
+            173,
+            462,
+            825,
+            628
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3.2 WASSERSTEIN GAN WITH GRADIENT PENALTY (WGAN-GP) ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            643,
+            660,
+            659
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In recent work, WGAP-GP has been successfully used for sequence generation (Gulrajani et al., 2017; Rajeswar et al., 2017; Press et al., 2017). Instead of using more complicate methods such as policy gradient, they directly feed the softmax layer into the discriminator. The generator can therefore be updated through backpropagation. We then formulate the conditional version of WGAN-GP as ",
+        "bbox": [
+            176,
+            667,
+            823,
+            738
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5d4154666cc02187cd0707df45bdac71f7dc204ae8657411673abc48b460b45d.jpg",
+        "text": "$$\n\\begin{array} { r l } & { D ^ { * } = \\underset { D } { \\arg \\operatorname* { m a x } } E _ { y \\sim P ^ { R } ( y ) , x ^ { R } \\sim P ^ { R } ( X | y ) } [ D ( x ^ { R } | y ) ] - E _ { y \\sim P ^ { R } ( y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ D ( x ^ { G } | y ) ] } \\\\ & { G ^ { * } = \\underset { G } { \\arg \\operatorname* { m a x } } E _ { y \\sim P ^ { R } ( Y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ D ( x ^ { G } | y ) ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            217,
+            741,
+            781,
+            794
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 PROPOSED APPROACH: STEPWISE GAN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            808,
+            540,
+            825
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The basic idea of stepwise GAN (see Fig. 1), or StepGAN, is to construct a sequence-to-sequence model as discriminator $D$ . At each time step of $D$ ’s decoder, the hidden vector is passed to a fully-connected layer. The discriminator $D$ then outputs the evaluation score for each subsequence $\\langle y , x _ { 1 \\ldots t } \\rangle$ , denoted as $D ( x _ { 1 . . . t } | y )$ . With discriminator $D$ , we seek to minimize the summation of $D ( x _ { 1 \\ldots t } ^ { G } | y )$ over the time steps when input the generated sequences $x ^ { G }$ . Simultaneously, $D$ maximizes the summation of $D ( x _ { 1 \\ldots t } ^ { \\mathrm { { R } } } | y )$ when the input is real data $x ^ { R }$ . The optimization of $D$ and $G$ is ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/15cf72773c0dc3be0e77149c6fc0495b5b4749ccc9002f79e1d792498ede3668.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of stepwise GAN "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            106,
+            799,
+            463
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "thus ",
+        "bbox": [
+            173,
+            522,
+            205,
+            535
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/29aa556b62f5c357fead9cd74064eed16e37e2eea11267141d15e2ead1ca778b.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle D ^ { \\prime } ( x | y ) = \\sum _ { t = 1 } ^ { T } \\alpha _ { t } ^ { D } D \\big ( x _ { 1 \\dots t } | y \\big ) } } \\\\ { { \\displaystyle D ^ { * } = \\arg \\operatorname* { m a x } _ { D } E _ { y \\sim P ^ { R } ( y ) , x ^ { R } \\sim P ^ { R } ( X | y ) } [ \\log ( D ^ { \\prime } ( x ^ { R } | y ) ) ] } } \\\\ { { \\displaystyle \\qquad + E _ { y \\sim P ^ { R } ( y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ \\log \\big ( 1 - D ^ { \\prime } ( x ^ { G } | y ) \\big ) ] , } } \\\\ { { \\displaystyle G ^ { * } = \\arg \\operatorname* { m a x } _ { G } E _ { y \\sim P ^ { R } ( Y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ D ( x ^ { G } | y ) ] , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            541,
+            696,
+            656
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha _ { t } ^ { D }$ is a weighted factor with $\\textstyle \\sum _ { t = 1 } ^ { T } \\alpha _ { t } ^ { D } = 1$ . In practice, we set $\\begin{array} { r } { \\alpha _ { t } ^ { D } = \\frac { 1 } { T } } \\end{array}$ , but it is possible assign scores for each prefix. Although we only use one way to train $D$ , we think there are two ways to interpret the $D$ ’s scores, and different view points lead to different update formulations for $G$ : ",
+        "bbox": [
+            173,
+            664,
+            826,
+            724
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• $D ( x _ { 1 . . . t } | y )$ evaluates the extra benefit of adding the word $x _ { t }$ into the sequence. The formulation for $G$ ’s parameter update is ",
+        "bbox": [
+            217,
+            734,
+            823,
+            765
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5726e8a8a466f9279639e08091d448724a752320368f1f5bfbd3bb16c39a92ea.jpg",
+        "text": "$$\n\\theta _ { G }  \\theta _ { G } + \\eta \\alpha _ { t } ^ { G } ( \\sum _ { t ^ { \\prime } = t } ^ { T } D ( x _ { 1 \\dots t ^ { \\prime } } | y ) ) \\nabla \\log ( p _ { G } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            772,
+            733,
+            815
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$G$ has to increase the summation $\\scriptstyle \\sum _ { t ^ { \\prime } = t } ^ { T } D ( x _ { 1 \\dots t ^ { \\prime } } | y )$ . We call this stepGAN-Seq. ",
+        "bbox": [
+            228,
+            824,
+            759,
+            843
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• $D ( x _ { 1 . . . t } | y )$ evaluates the average goodness of all the sequences beginning with $x _ { 1 \\ldots t }$ . The update formulation for $\\theta _ { G }$ is ",
+        "bbox": [
+            217,
+            845,
+            828,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/015ceee31cdf7858cebe3f34d6057ef0b76e5c713ef2f6f947c9fa63931d5c66.jpg",
+        "text": "$$\n\\theta _ { G } \\gets \\theta _ { G } + \\eta \\alpha _ { t } ^ { G } D ( x _ { 1 \\dots t } | y ) \\nabla \\log ( p _ { G } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            882,
+            710,
+            901
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The $G$ only needs to learn to increase $D ( x _ { 1 \\ldots t } | y )$ . We call this stepGAN in following. ",
+        "bbox": [
+            235,
+            909,
+            794,
+            925
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using factor $\\alpha _ { t } ^ { G }$ , we diversify training by arbitrarily weighting the importance of each time step1. We explore the influence of different values of $\\alpha _ { t } ^ { \\check { G } }$ and compare the two update formulations in section 5 and appendix B. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "StepGAN-Seq is a generalized version of SeqGAN. If we set $\\alpha _ { T } ^ { D } = 1$ , $\\alpha _ { t } ^ { D } = 0$ for $t < T$ , and $\\alpha _ { t } ^ { G } = 1$ for all $t$ , then stepGAN-Seq is equivalent to SeqGAN without Monte Carlo search. Also, REGS (Li et al., 2017) can be induced by set $\\alpha _ { t } ^ { D } = 1$ at a randomly chosen time step. ",
+        "bbox": [
+            174,
+            151,
+            825,
+            196
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "StepGAN is similar to the actor-critic architecture in (Bahdanau et al., 2016). Instead of the assigned task-specific score, we learn the score by adversarial learning. Because $D$ ’s scores are the expected return in this setting, we would like StepGAN to approximate the expected return obtained by SeqGAN or MaliGAN with Monte Carlo search. This approach only need to add a set of weight factors, and therefore much time efficient than Monte Carlo search. For more details of the algorithm, please refer to appendix A for pseudo-code. ",
+        "bbox": [
+            174,
+            203,
+            825,
+            286
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            310,
+            326,
+            327
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use a recurrent neural network for both the discriminator and generator due to its strong sequential correlation (Press et al., 2017; Rajeswar et al., 2017). Specifically, we use gated recurrent units (GRUs) (Chung et al., 2014) in our experiments. We view the noise feature in GAN as the random process of sampling from the softmax layer distribution. ",
+        "bbox": [
+            174,
+            344,
+            825,
+            400
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 ARTIFICIAL GRAMMARS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            421,
+            385,
+            435
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To better evaluate GANs for conditional sequence generation, we define three artificial grammars: sequence, counting, and addition. The three grammars are described in Table 1. For the sequence grammar, the aim is to generate a continued consecutive number sequence behind the input $Y$ . For example, for input $\\langle 1 , 2 , 3 \\rangle$ , the answer would be a consecutive number sequence of any length starting with 4, such as $\\langle 4 , 5 , 6 , 7 , 8 \\rangle$ . The counting grammar is more complicated. The generated sequence should contain exactly 3 words, where the median is a randomly selected word from the input sequence. The first generated word should be the number of words on the left-hand side of the selected median, while the last generated word should be the number of words on the right-hand side. For example, when the input is $\\langle 5 , 9 , 2 , 8 , 3 , 2 , 9 , 1 \\rangle$ , one permissible generated sequence is $\\langle 0 , 5 , 7 \\rangle$ . Last, for the addition grammar we generate the addition of two numbers randomly segmented from the input sequence. That is, for input $\\langle 8 , 1 , 3 , 4 \\rangle$ , then one permissible output is the addition of 8 and 134 – thus $\\langle 1 , 4 , 2 \\rangle$ . Note that both the input and output numbers for this grammar are represented in terms of their corresponding digits. ",
+        "bbox": [
+            174,
+            449,
+            825,
+            628
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The purpose of these design is to imitate major properties in dialogue generation, such as variablelength, repeated prefixes, the same sequence space, one-to-many, and many-to-one. The variablelength property means there is no fixed length for the input and output sequences. The repeated prefixes property means the beginning subsequences are usually shared by many data, for instance What and I am in natural language. The same sequence space here means that the input and output have the same structure and as such are sampled from the same space. Finally, one-to-many and many-to-one are quite common in dialogue generation. For example, when asking How are you?, responses vary from I’m fine to Great! How are you?. Also, the same response can be paired with multiple questions, such as for My name is Paul in response to What’s your name? and Who are you?. ",
+        "bbox": [
+            173,
+            636,
+            825,
+            775
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We then randomly generate 100,000 samples as training data, 10,000 as development data, and 10,000 samples as testing data. The architectures are set to one layer with 128 hidden units. We evaluate our results using the three measures in Table 2. The first is the accuracy of samples generated from the argmax policy (Acc), the second is that generated from the softmax probability (AccS), and the last is the coverage of softmax samples over all the permissible answers of the specific grammar (Cov). We report them to ensure whether the one-to-many property is being learned. AccS and Cov are important because they can indicate if the model can learn the underlying distribution of answers. When mode collapse happens, which means the model only know a specific type of answers, it will obtain high AccS and low Cov scores. To ensure a fair comparison, all the algorithms are based on the same pre-trained model: the MLE model listed in Table 2. ",
+        "bbox": [
+            174,
+            781,
+            823,
+            893
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/a488ea6f1ce399dde9cc4f1dcd75f80c6c31db2893dcf3a32c7012970d14d62a.jpg",
+        "table_caption": [
+            "Table 1: Grammar definitions and examples "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Grammar</td><td>Definition</td><td>Examples</td></tr><tr><td>Sequence</td><td>Continue the sequence for a random length</td><td>123: 4, 45,...</td></tr><tr><td>Counting</td><td>Randomly choose a digit, and then calculate the left-and right-hand lengths</td><td>123: 012,121, 230</td></tr><tr><td>Addition</td><td>Randomly partition,and then add the two numbers</td><td>123: 15,24</td></tr></table>",
+        "bbox": [
+            204,
+            131,
+            794,
+            207
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/2ccf2814fe842e1e86b9ca31c6920623cd4405e3eef1d617612e5cbc1121d7e4.jpg",
+        "table_caption": [
+            "Table 2: Results of artificial grammars with different algorithms. Evaluation label Acc $( \\% )$ is the accuracy of argmax samples, AccS $( \\% )$ is the accuracy of softmax samples, and Cov $( \\% )$ is the coverage of softmax samples over permissible answers. The dash (-) here indicates that the algorithm introduced no improvements based on the pre-trained model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"4\"> Sequence</td><td colspan=\"3\">Counting</td><td colspan=\"3\">Addition</td></tr><tr><td></td><td>Acc</td><td>AccS</td><td>Cov</td><td>Acc</td><td>AccS</td><td>Cov</td><td>Acc</td><td>AccS</td><td>Cov</td></tr><tr><td>MLE</td><td>97.43</td><td>81.32</td><td>53.77</td><td>73.48</td><td>68.89</td><td>70.63</td><td>44.57</td><td>32.28</td><td>31.79</td></tr><tr><td>REINFORCE</td><td>99.81</td><td>97.30</td><td>4.54</td><td>99.97</td><td>99.36</td><td>16.99</td><td>79.98</td><td>75.60</td><td>18.32</td></tr><tr><td>WGAN-GP</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>basic-MaliGAN</td><td>97.34</td><td>81.66</td><td>54.19</td><td>74.12</td><td>70.35</td><td>70.15</td><td>44.27</td><td>32.05</td><td>31.92</td></tr><tr><td>basic-SeqGAN</td><td>97.20</td><td>80.28</td><td>57.61</td><td>74.59</td><td>70.56</td><td>70.39</td><td>44.87</td><td>32.30</td><td>31.90</td></tr><tr><td>MC-SeqGAN</td><td>97.20</td><td>80.98</td><td>55.49</td><td>72.96</td><td>68.10</td><td>70.54</td><td>44.72</td><td>32.28</td><td>31.83</td></tr><tr><td>REGS</td><td>97.42</td><td>81.36</td><td>53.82</td><td>75.99</td><td>70.93</td><td>69.40</td><td>44.64</td><td>32.32</td><td>32.01</td></tr><tr><td>StepGAN-Seq</td><td>97.11</td><td>74.85</td><td>67.49</td><td>75.47</td><td>70.64</td><td>69.82</td><td>45.55</td><td>32.49</td><td>32.01</td></tr><tr><td>StepGAN</td><td>97.19</td><td>75.92</td><td>66.08</td><td>81.98</td><td>72.24</td><td>69.02</td><td>44.94</td><td>32.19</td><td>31.67</td></tr></table>",
+        "bbox": [
+            181,
+            299,
+            818,
+            458
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            489,
+            821,
+            517
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We discuss the results of MLE, REINFORCE, and state-of-the-art GAN algorithms on Sequence, Counting, and Addition in Table 2. REINFORCE has higher Acc and AccS than ${ \\mathrm { M L E } } ^ { 2 }$ , but it results in strong mode-collapse (very low Cov). We have a very strong MLE baseline for Sequence. Therefore we cannot pretrain discriminator well based on this baseline MLE model. Every GAN algorithms cannot outperform MLE by this setting. StepGAN improves Acc on both Counting and Addition without heavily trade-off with Cov. That is, training model using StepGAN enhances and maintains the knowledge of underlying distribution rather than resulting in strong mode-collapse as REINFORCE. ",
+        "bbox": [
+            173,
+            529,
+            825,
+            640
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To investigate the trade-off between AccS and Cov, we plot the accuracy-coverage curve in Fig. 2. The trade-off between accuracy and coverage is controlled by sharpening the softmax layer. Besides Fig. 2a, of which the GANs do not obtain good results, StepGAN improves the accuracy-coverage curves in Fig. 2b and Fig. 2c. This is consistent with our realization of Table 2 that StepGAN fits model to the underlying distribution better. ",
+        "bbox": [
+            174,
+            647,
+            825,
+            717
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 DIALOGUE GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            736,
+            387,
+            750
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We split OpenSubtitles (Tiedemann, 2009) into training set, development set, and testing set with a vocabulary of the top 4,000 most frequently occurring words. Both the generator and discriminator are 1-layer GRUs with a hidden dimension set to $5 1 2 ^ { 3 }$ . To compare the improvements introduced by all the algorithms, we first pre-trained the generator using MLE, after which we further trained the model for 1-epoch by different GANs. SeqGAN, MaliGAN, REGS, and StepGAN were compared. We do not compare Monte Carlo search with other approaches because its time complexity is much larger. All discriminators of SeqGAN, MaliGAN, REGS, and StepGAN were pre-trained on real ",
+        "bbox": [
+            174,
+            762,
+            825,
+            859
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/51918436916ce27a7936dcb270ad55e741a33a77f82a6d8e511af766a2b1dde4.jpg",
+        "image_caption": [
+            "Figure 2: Sampled accuracy and coverage curves "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            107,
+            803,
+            246
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Human evaluation and BLEU score for dialogue generation. CoHS $( \\% )$ is coherence human score. SHS $( \\% )$ is sentence structure human score. ",
+        "bbox": [
+            169,
+            290,
+            823,
+            319
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/eb38d3e441297806e4dbd66d23ba6617503091769c8b72ea736106bb5dbdf0bf.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">CoHS (%)</td><td colspan=\"3\">SHS (%)</td><td colspan=\"3\">BLEU</td></tr><tr><td></td><td>Argmax</td><td>BS</td><td>MMI</td><td>Argmax</td><td>BS</td><td>MMI</td><td>Argmax</td><td>BS</td><td>MMI</td></tr><tr><td>MLE</td><td>44.89</td><td>54.22</td><td>60.44</td><td>15.11</td><td>1.33</td><td>7.56</td><td>0.222</td><td>0.281</td><td>0.272</td></tr><tr><td>SeqGAN</td><td>41.33</td><td>53.33</td><td>63.55</td><td>30.67</td><td>6.22</td><td>10.22</td><td>0.202</td><td>0.267</td><td>0.251</td></tr><tr><td>MaliGAN</td><td>35.56</td><td>51.11</td><td>45.33</td><td>20.89</td><td>5.78</td><td>8.00</td><td>0.180</td><td>0.271</td><td>0.263</td></tr><tr><td>REGS</td><td>36.44</td><td>54.67</td><td>53.78</td><td>36.44</td><td>9.33</td><td>9.78</td><td>0.180</td><td>0.256</td><td>0.246</td></tr><tr><td>StepGAN</td><td>47.56</td><td>63.56</td><td>61.33</td><td>40.89</td><td>3.56</td><td>8.89</td><td>0.171</td><td>0.254</td><td>0.248</td></tr></table>",
+        "bbox": [
+            179,
+            335,
+            818,
+            439
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "data and generated data from the pre-trained generator. Note that these models were all trained without MIXER, curriculum learning, or teacher forcing, etc. Both the generator and discriminator are optimized by SGD. We used grid search in the experiments with learning rate={1e-1,1e-2,1e-3}, discriminator iteration step={1,5}, and used batchsize $_ { = 6 4 }$ . ",
+        "bbox": [
+            174,
+            474,
+            825,
+            530
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For human evaluation, we randomly selected 25 inputs from the testing set, and decoded using argmax policy, beam search, and MMI (Li et al., 2015)4. We presented both an input and the generated outputs to 8 and 4 judges respectively, and we asked them to do Turing test (correct or not) of the coherence and sentence structure. Coherence is the rationality of the generated responses given inputs. Sentence structure is the correctness and complexity of grammar. The sentences provide specific information would be considered as having better sentence structure rather than the general ones (egs. I don’t know.) due to more complex grammar. In Table 3, the two measures are labeled as CoHS (Coherence Human Score) and SHS (Sentence structure Human Score). We also show the BLEU score of each algorithm. It was already found that BLEU score is inconsistent with human evaluation (Liu et al., 2016), we also observe the same phenomenon it in our experiments. ",
+        "bbox": [
+            173,
+            536,
+            825,
+            675
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We show the CoHS and SHS of 15 different results (5 different algorithms and 3 different decoding methods) in Table 3. First, we can see decoding using beam search or MMI improve CoHS. StepGAN obtains the best performance in terms of CoHS when using argmax policy or beam search, but StepGAN cannot further increase the performance using MMI. When using MMI, the CoHS of MLE, SeqGAN and StepGAN are comparable. Second, argmax policy has higher SHS than beam search and MMI in all cases. In the meantime, GANs have higher SHS than MLE, and StepGAN has the highest score with argmax. The inconsistency of improvement between argmax policy, beam search and MMI is very likely because that the GANs are learned with the softmax policy and do not consider beam search and MMI during training. Additionally, we know beam search and MMI maximize the probability of response given an input without maintaining the probability of the response itself. This makes them prefer a coherence response rather than a good sentence structure. These statistics show that SeqGAN, MaliGAN, and REGS cannot consistently improve both coherence and sentence structure, whereas StepGAN outperforms MLE in terms both CoHS and SHS with all decoding methods.5 ",
+        "bbox": [
+            173,
+            683,
+            825,
+            876
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/2f5e0ffc3242f4a5aab01b71dbbb5daaaca0aa7de2df387887037e42946a04f8.jpg",
+        "image_caption": [
+            "Figure 3: The variation of discriminators’ scores using different GAN algorithms during training iterations. The printed color is normalized throughout the generation steps $\\mathbf { \\bar { x } }$ -axis) for each algorithm. (a)(b) are given “how are you ?” as input, and (c)(d) are given “what ’s your name ?” as input. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            109,
+            782,
+            371
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To understand what the discriminators learn, we measure the variance throughout the training iterations at each generation step. In adversarial learning, discriminator’s scores oscillate during training according to the current performance of generator. We argue that discriminator’s score for the most crucial generation step is the most easy to oscillate. This is because the generation step is the most important one for discriminator to identify whether it’s real or fake. In Fig. (3), we show four examples. Fig. (3a) and Fig. (3b) are respectively true response and wrong response given input question ”how are you ?”, and Fig. (3c) and Fig. (3d) are given input question ”what ’s your name ?. The darker color indicates the higher variance on the generation step. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            585
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Fig. (3), the colors for SeqGAN is always the same. Because the disriminator of SeqGAN only evaluate the whole sequence, the generation steps means no difference to discriminator. Second, REGS and StepGAN both aim to approximate Monte-Carlo search on SeqGAN, but in practice, we can clearly see that the variance of REGS is very different from Monte Carlo search. This is because REGS considers non-terminated episodes, which makes REGS has to spend extra effort on the generation maximum length to check whether there’s a terminal state $( < E O S > )$ . The results of StepGAN and Monte Carlo search (MC-SeqGAN) are quite similar. Based on MC-SeqGAN and StepGAN, the important parts (with darker colors) in the sentences for discriminating the true ones from fake correspond to human knowledge. For example, ”fine , thank you ” are the most important region in Fig. (3a), ”sorry , i ’m sorry” are the most important region in Fig. (3b) when answering ”how are you ?”. When given ”what ’s your name ?”, MC-SeqGAN and StepGAN focus on ”’m john” in Fig. (3c) and ”sorry” in Fig. (3d). We believe the success of StepGAN comes from estimating the goodness of a sequence at every generation step as Monte Carlo search, but with little extra computation. ",
+        "bbox": [
+            173,
+            592,
+            825,
+            786
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            816,
+            318,
+            832
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper we propose StepGAN to approximate Monte Carlo search with a much lower computational cost.We show that the proposed StepGAN performs equally to or outperforms the state-ofthe-art GAN algorithms on artificial grammars. On a representative real-world conditional sequence generation task–dialogue generation, StepGAN also outperforms other approaches on both coherence and sentence structure. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our proposed artificial grammars not only accurately reflect model coverage and accuracy but also boast clearly distinguishable styles. For example, the sequence style can be the length, the counting style can be the selected digit position, and the addition style can be the selected partition position. This property lends itself to investigating style transfering for sequences generation, which is one of our aims for future work. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nDzmitry Bahdanau, Philemon Brakel, Kelvin Xu, Anirudh Goyal, Ryan Lowe, Joelle Pineau, Aaron Courville, and Yoshua Bengio. An actor-critic algorithm for sequence prediction. arXiv preprint arXiv:1607.07086, 2016.   \nSamy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 1171–1179, 2015.   \nTong Che, Yanran Li, Ruixiang Zhang, R Devon Hjelm, Wenjie Li, Yangqiu Song, and Yoshua Bengio. Maximum-likelihood augmented discrete generative adversarial networks. arXiv preprint arXiv:1702.07983, 2017.   \nJunyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.   \nIan 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.   \nIshaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of wasserstein gans. arXiv preprint arXiv:1704.00028, 2017.   \nKirthevasan Kandasamy, Yoram Bachrach, Ryota Tomioka, Daniel Tarlow, and David Carter. Batch policy gradient methods for improving neural conversation models. arXiv preprint arXiv:1702.03334, 2017.   \nMatt J Kusner and Jose Miguel Hern ´ andez-Lobato. Gans for sequences of discrete elements with ´ the gumbel-softmax distribution. arXiv preprint arXiv:1611.04051, 2016.   \nJiwei Li, Michel Galley, Chris Brockett, Jianfeng Gao, and Bill Dolan. A diversity-promoting objective function for neural conversation models. arXiv preprint arXiv:1510.03055, 2015.   \nJiwei Li, Will Monroe, Tianlin Shi, Alan Ritter, and Dan Jurafsky. Adversarial learning for neural dialogue generation. arXiv preprint arXiv:1701.06547, 2017.   \nKevin Lin, Dianqi Li, Xiaodong He, Zhengyou Zhang, and Ming-Ting Sun. Adversarial ranking for language generation. arXiv preprint arXiv:1705.11001, 2017.   \nChia-Wei Liu, Ryan Lowe, Iulian V Serban, Michael Noseworthy, Laurent Charlin, and Joelle Pineau. How not to evaluate your dialogue system: An empirical study of unsupervised evaluation metrics for dialogue response generation. arXiv preprint arXiv:1603.08023, 2016.   \nMehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint arXiv:1411.1784, 2014.   \nOfir Press, Amir Bar, Ben Bogin, Jonathan Berant, and Lior Wolf. Language generation with recurrent generative adversarial networks without pre-training. arXiv preprint arXiv:1706.01399, 2017.   \nSai Rajeswar, Sandeep Subramanian, Francis Dutil, Christopher Pal, and Aaron Courville. Adversarial generation of natural language. arXiv preprint arXiv:1705.10929, 2017.   \nMarc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence level training with recurrent neural networks. arXiv preprint arXiv:1511.06732, 2015. ",
+        "bbox": [
+            169,
+            194,
+            828,
+            934
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104–3112, 2014. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction, volume 1. MIT press Cambridge, 1998. ",
+        "bbox": [
+            173,
+            141,
+            821,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jorg Tiedemann. News from OPUS - A collection of multilingual parallel corpora with tools ¨ and interfaces. In N. Nicolov, K. Bontcheva, G. Angelova, and R. Mitkov (eds.), Recent Advances in Natural Language Processing, volume V, pp. 237–248. John Benjamins, Amsterdam/Philadelphia, Borovets, Bulgaria, 2009. ISBN 978 90 272 4825 1. ",
+        "bbox": [
+            174,
+            179,
+            823,
+            234
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals and Quoc Le. A neural conversational model. arXiv preprint arXiv:1506.05869, 2015. ",
+        "bbox": [
+            173,
+            244,
+            821,
+            260
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992. ",
+        "bbox": [
+            173,
+            268,
+            823,
+            296
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lantao Yu, Weinan Zhang, Jun Wang, and Yong Yu. Seqgan: Sequence generative adversarial nets with policy gradient. In AAAI, pp. 2852–2858, 2017. ",
+        "bbox": [
+            173,
+            306,
+            823,
+            334
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yizhe Zhang, Zhe Gan, Kai Fan, Zhi Chen, Ricardo Henao, Dinghan Shen, and Lawrence Carin. Adversarial feature matching for text generation. arXiv preprint arXiv:1706.03850, 2017. ",
+        "bbox": [
+            171,
+            343,
+            823,
+            372
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junbo Zhao, Michael Mathieu, and Yann LeCun. Energy-based generative adversarial network. arXiv preprint arXiv:1609.03126, 2016. ",
+        "bbox": [
+            171,
+            381,
+            821,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX: PSEUDO CODE OF STEPWISE GAN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            593,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/36032d27352dfeba3b79e53b3edfc36ca22c1080b9805cc24a877d1dcceb9a67.jpg",
+        "table_caption": [
+            "Table 4: Pseudo code of stepwise GAN ",
+            "Algorithm 1 Stepwise GAN (StepGAN) Training "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>1</td><td>for number of training iterations do</td></tr><tr><td>2</td><td>for i=1, D-steps do Sample (y,xR) from real data</td></tr><tr><td>3</td><td></td></tr><tr><td>4</td><td>Sample xG ~ PG(.ly)</td></tr><tr><td>5</td><td>Update D using equation (7) T</td></tr><tr><td>6</td><td>D&#x27;(xly)=∑-1PD(x.tly)</td></tr><tr><td>7</td><td>D* = arg maxD Ey~pR(y),R~pR(xly)[log(D&#x27;(xR|y))] +Ey~PR(y),xG~PG(xly)[log(1-D&#x27;(xG|y)]</td></tr><tr><td>8</td><td>end for</td></tr><tr><td>9</td><td>for i=1, G-steps do</td></tr><tr><td>10</td><td>Sample y from real data</td></tr><tr><td>11</td><td>Sample xG ~ PG(.ly)</td></tr><tr><td>12</td><td>Update G using equation (9)</td></tr><tr><td>13</td><td>0G ←0G + na£D(x1...tly)Vlog(𝑝G(x£ly,x...t-1))</td></tr><tr><td>14</td><td>end for</td></tr><tr><td>15</td><td>end for</td></tr><tr><td></td><td></td></tr></table>",
+        "bbox": [
+            253,
+            185,
+            743,
+            416
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B WEIGHTED FACTORS SEARCH OF STEPGAN AND STEPGAN-SEQ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            454,
+            751,
+            472
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/7f26433ca7bf61c7ac142ba13ecfb24904cbf6f3fbade2612157dda630eceb1e.jpg",
+        "table_caption": [
+            "Table 5: StepGAN and StepGAN-Seq with different weight factors. The dash (-) here notes that the weight factors yield neither improvements nor deterioration. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"7\">StepGAN StepGAN-Seq</td></tr><tr><td colspan=\"2\"></td><td>Acc</td><td>AccS</td><td>Cov</td><td>Acc</td><td>AccS Cov</td></tr><tr><td rowspan=\"3\">Sequence</td><td>Uniform</td><td>97.19</td><td>75.92</td><td>66.08</td><td>97.11</td><td>74.85 67.49</td></tr><tr><td>Increase</td><td>97.17</td><td>75.33</td><td>66.75 97.18</td><td>73.30</td><td>68.19</td></tr><tr><td>Decrease</td><td>97.16</td><td>74.73</td><td>67.14</td><td>97.09 74.34</td><td>67.48</td></tr><tr><td rowspan=\"3\">Counting</td><td>Uniform</td><td>77.23</td><td>71.43</td><td>70.18</td><td>74.91</td><td>70.70 69.84</td></tr><tr><td>Increasing</td><td>74.50</td><td>69.66</td><td>70.86</td><td>74.54 70.74</td><td>70.11</td></tr><tr><td>Decreasing</td><td>81.98</td><td>72.24</td><td>69.02</td><td>75.47 70.64</td><td>69.82</td></tr><tr><td rowspan=\"3\">Addition</td><td>Uniform</td><td>44.26</td><td>32.39</td><td>31.91</td><td>44.77</td><td>32.34 31.65</td></tr><tr><td>Increasing</td><td>1</td><td>1 -</td><td>=</td><td>1</td><td>1</td></tr><tr><td>Decreasing</td><td>44.94</td><td>32.19</td><td>31.67</td><td>45.55 32.49</td><td>32.01</td></tr></table>",
+        "bbox": [
+            238,
+            537,
+            759,
+            698
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We compare different weighted factors $\\alpha ^ { G }$ for StepGAN and StepGAN-Seq, with $\\begin{array} { r } { \\alpha _ { t } ^ { D } = \\frac { 1 } { T } } \\end{array}$ for all the presented cases. As depicted in Table 5, the three grammars are trained using three sorts of weighted factors: uniform $\\begin{array} { r } { \\dot { \\left( \\alpha _ { t } ^ { G } \\ = \\ 1 \\right) } } \\end{array}$ ), increasing $( \\alpha _ { t } ^ { G } \\ = t )$ , and decreasing $( \\alpha _ { t } ^ { G } \\ = \\ T - \\ t + 1 )$ . The results clearly show that the time-step-decreasing weight factors positively affect training. We believe this is because the training spirit of decreased weighted factor start from first correcting prefix. After correcting prefix, it becomes easier to correct the suffix. Please refer to section 5 if you are interested in the details of Acc, AccS, and Cov. ",
+        "bbox": [
+            173,
+            717,
+            826,
+            815
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C ENERGY-BASED STEPWISE GAN (EBSTEPGAN) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            835,
+            616,
+            853
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We propose energy-based stepwise GAN (EBStepGAN) that only change the form of objective function of StepGAN. This is mainly inspired by energy-based GAN (Zhao et al., 2016). As depicted in Fig. 4, the discriminator $D$ here has the same architecture as generator $G$ , and its energy function is cross-entropy. Discriminator assigns low energy to real samples and high enery to generated samples. The advantage of EBStepGAN is that we can initialize both generator and discriminator with the same pre-trained model using MLE. The optimization functions are written as ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/644661665ab6f5463846bfc5f87051f82283916167e2527b207cd6ca308a0415.jpg",
+        "image_caption": [
+            "Figure 4: Illustration of energy-based stepwise GAN "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            279,
+            99,
+            710,
+            366
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            417,
+            823,
+            448
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b3598c995fbe2c319dde3ae92ed9e325d9b5bba7a13173e619a25b16fb614fc0.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle D ^ { * } = \\arg \\operatorname* { m a x } _ { D } E _ { ( x ^ { R } , y ) \\sim P ^ { R } ( X , Y ) } [ \\sum _ { t = 1 } ^ { T } l o g ( P ^ { D } ( x _ { t } ^ { R } | y , x _ { 1 \\dots t - 1 } ^ { R } ) ) ] } } \\\\ { { \\displaystyle \\qquad + m a x i m u m ( 0 , \\beta - E _ { y \\sim P ^ { R } ( Y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ \\sum _ { t = 1 } ^ { T } l o g ( P ^ { D } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } ) ) ] ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            454,
+            761,
+            542
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f3ac7a85ca44672cf3e5e7d54a3470e8f5451e0024ee44cee726b00f61fe5f54.jpg",
+        "text": "$$\nG ^ { * } = \\arg \\operatorname* { m a x } _ { G } E _ { y \\sim P ^ { R } ( Y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ \\sum _ { t = 1 } ^ { T } l o g ( P ^ { D } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } ) ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            558,
+            725,
+            601
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $P ^ { D } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } )$ in Equation (11) is the probability of generating $x _ { t } ^ { G }$ given $< y , x _ { 1 \\ldots t - 1 } ^ { G } >$ based on the current model , and $\\beta$ in Equation (10) is the threshold for preventing the discriminator from distinguishing generated samples from real samples too easily. When the energy of generated samples is too high, the threshold turns off the second term in (10). The results of EBStepGAN is shown in Table 6. According to Table 6, EBStepGAN does not show better performance than StepGAN in our current experiments. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            693
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/0e6de376861cc4f5891efd891a5a12414391cd676f1a6890fa180de05e54835c.jpg",
+        "table_caption": [
+            "Table 6: Results of artificial grammars by EBStepGAN. Please check Table 2 for other results. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"4\"> Sequence</td><td colspan=\"3\">Counting</td><td colspan=\"3\">Addition</td></tr><tr><td></td><td>Acc</td><td>AccS</td><td>Cov</td><td>Acc</td><td>AccS</td><td>Cov</td><td>Acc</td><td>AccS</td><td>Cov</td></tr><tr><td>EBStepGAN</td><td>97.32</td><td>80.09</td><td>57.12</td><td>79.78</td><td>71.52</td><td>68.44</td><td>45.74</td><td>32.68</td><td>32.11</td></tr></table>",
+        "bbox": [
+            191,
+            737,
+            808,
+            784
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D APPENDIX: EXAMPLES OF NEURAL DIALOGUE GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            103,
+            709,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/7bac822b5ad2120cbefc663273e4b022347f0610e89dc4164a2289e27d2fde78.jpg",
+        "table_caption": [
+            "Table 7: Examples of neural dialogue generation trained on OpenSubtitles "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1>hello,i&#x27;m senator snatch</td></tr><tr><td rowspan=1 colspan=1>MLESeqGANMaliGANREGSStepGAN</td><td rowspan=1 colspan=1>i&#x27;m sorry .i&#x27;m sorry,i&#x27;m sorry.i&#x27;m a good man . i&#x27;m here to see you againsorry you &#x27;re late</td></tr><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1>i got the money right here .</td></tr><tr><td rowspan=1 colspan=1>MLESeqGANMaliGANREGSStepGAN</td><td rowspan=1 colspan=1>i&#x27;m sorry .i&#x27;m here to help .ican.ican &#x27;t do it .i&#x27;ll take you home .</td></tr><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1>hope you enjoyed your pee ..because it ’&#x27;s your last on this trip .</td></tr><tr><td rowspan=1 colspan=1>MLESeqGANMaliGANREGSStepGAN</td><td rowspan=1 colspan=1>it &#x27;s not a problem . it &#x27;s not your fault .it doesn &#x27;t matter . it &#x27;s not a dream . it &#x27;s the only thing i can do .</td></tr><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1>he say ... if you want to be an actor,he has something to show you .</td></tr><tr><td rowspan=1 colspan=1>MLESeqGANMaliGANREGSStepGAN</td><td rowspan=1 colspan=1>you &#x27;re not .you can &#x27;t do that .what &#x27;s he mean ?he &#x27;s a very good guy , you know .you &#x27;re not gonna be a liar .</td></tr><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1> thank you, thank you .</td></tr><tr><td rowspan=1 colspan=1>MLESeqGANMaliGANREGSStepGAN</td><td rowspan=1 colspan=1>i&#x27;m sorry.i&#x27;m sorry ,sir .thank you .i&#x27;ll be right back .you &#x27;re welcome .</td></tr><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1>i feel like a paris princess.</td></tr><tr><td rowspan=1 colspan=1>MLESeqGANMaliGANREGSStepGAN</td><td rowspan=1 colspan=1>iknow it .i know that you &#x27;re not there .i feel like ..i can &#x27;t see it . you &#x27;re not a child anymore .</td></tr><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1>i&#x27;m tired of all your questions</td></tr><tr><td rowspan=1 colspan=1>MLESeqGANMaliGANREGSStepGAN</td><td rowspan=1 colspan=1>i&#x27;m gonna have to ask you to come . i&#x27;m gonna call you .i&#x27;ma friend. i &#x27;m going to have to ask you to come in i&#x27;m going to be a friend of you .</td></tr><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1> it &#x27;s great .</td></tr><tr><td rowspan=1 colspan=2>MLE yeah.SeqGAN  it &#x27;s great, huh ?MaliGAN  it &#x27;s great .REGS i was just thinking about it .StepGAN you &#x27;re so sweet .</td></tr></table>",
+        "bbox": [
+            220,
+            169,
+            777,
+            872
+        ],
+        "page_idx": 13
+    }
+]

parse/train/rklaWn0qK7/rklaWn0qK7.md

@@ -0,0 +1,423 @@
+# LEARNING NEURAL PDE SOLVERS WITH CONVER-GENCE GUARANTEES
+
+Jun-Ting Hsieh\* Stanford junting@stanford.edu
+
+Shengjia Zhao\* Stanford sjzhao@stanford.edu
+
+Stephan Eismann Stanford seismann@stanford.edu
+
+Lucia Mirabella   
+Siemens   
+lucia.mirabella $@$ siemens.com
+
+Stefano Ermon Stanford ermon@stanford.edu
+
+# ABSTRACT
+
+Partial differential equations (PDEs) are widely used across the physical and computational sciences. Decades of research and engineering went into designing fast iterative solution methods. Existing solvers are general purpose, but may be sub-optimal for specific classes of problems. In contrast to existing hand-crafted solutions, we propose an approach to learn a fast iterative solver tailored to a specific domain. We achieve this goal by learning to modify the updates of an existing solver using a deep neural network. Crucially, our approach is proven to preserve strong correctness and convergence guarantees. After training on a single geometry, our model generalizes to a wide variety of geometries and boundary conditions, and achieves 2-3 times speedup compared to state-of-the-art solvers.
+
+# 1 INTRODUCTION
+
+Partial differential equations (PDEs) are ubiquitous tools for modeling physical phenomena, such as heat, electrostatics, and quantum mechanics. Traditionally, PDEs are solved with hand-crafted approaches that iteratively update and improve a candidate solution until convergence. Decades of research and engineering went into designing update rules with fast convergence properties.
+
+The performance of existing solvers varies greatly across application domains, with no method uniformly dominating the others. Generic solvers are typically effective, but could be far from optimal for specific domains. In addition, high performing update rules could be too complex to design by hand. In recent years, we have seen that for many classical problems, complex updates learned from data or experience can out-perform hand-crafted ones. For example, for Markov chain Monte Carlo, learned proposal distributions lead to orders of magnitude speedups compared to handdesigned ones (Song et al., 2017; Levy et al., 2017). Other domains that benefited significantly include learned optimizers (Andrychowicz et al., 2016) and learned data structures (Kraska et al., 2018). Our goal is to bring similar benefits to PDE solvers.
+
+Hand-designed solvers are relatively simple to analyze and are guaranteed to be correct in a large class of problems. The main challenge is how to provide the same guarantees with a potentially much more complex learned solver. To achieve this goal, we build our learned iterator on top of an existing standard iterative solver to inherit its desirable properties. The iterative solver updates the solution at each step, and we learn a parameterized function to modify this update. This function class is chosen so that for any choice of parameters, the fixed point of the original iterator is preserved. This guarantees correctness, and training can be performed to enhance convergence speed. Because of this design, we only train on a single problem instance; our model correctly generalizes to a variety of different geometries and boundary conditions with no observable loss of performance. As a result, our approach provides: (i) theoretical guarantees of convergence to the correct stationary solution, (ii) faster convergence than existing solvers, and (iii) generalizes to geometries and boundary conditions very different from the ones seen at training time. This is in stark contrast with existing deep learning approaches for PDE solving (Tang et al., 2017; Farimani et al., 2017) that are limited to specific geometries and boundary conditions, and offer no guarantee of correctness.
+
+Our approach applies to any PDE with existing linear iterative solvers. As an example application, we solve the 2D Poisson equations. Our method achieves a $2 { - } 3 \times$ speedup on number of multiplyadd operations when compared to standard iterative solvers, even on domains that are significantly different from our training set. Moreover, compared with state-of-the-art solvers implemented in FEniCS (Logg et al., 2012), our method achieves faster performance in terms of wall clock CPU time. Our method is also simple as opposed to deeply optimized solvers such as our baseline in FEniCS (minimal residual method $^ +$ algebraic multigrid preconditioner). Finally, since we utilize standard convolutional networks which can be easily parallelized on GPU, our approach leads to an additional $3 0 \times$ speedup when run on GPU.
+
+# 2 BACKGROUND
+
+In this section, we give a brief introduction of linear PDEs and iterative solvers. We refer readers to LeVeque (2007) for a thorough review.
+
+# 2.1 LINEAR PDES
+
+Linear PDE solvers find functions that satisfy a (possibly infinite) set of linear differential equations. More formally, let $\mathcal { F } = \{ \boldsymbol { u } : \mathbb { R } ^ { k }  \mathbb { R } \}$ be the space of candidate functions, and $\mathcal { A } : \mathcal { F }  \mathcal { F }$ be a linear operator; the goal is to find a function $u \in { \mathcal { F } }$ that satisfies a linear equation ${ \mathcal { A } } u = { \mathcal { E } }$ , where $\boldsymbol { \mathscr { f } }$ is another function $\mathbb { R } ^ { k }  \mathbb { R }$ given by our problem. Many PDEs fall into this framework. For example, heat diffusion satisfies $\nabla ^ { 2 } u = \ell$ (Poisson equation), where $\begin{array} { r } { \nabla ^ { 2 } = \frac { \partial ^ { 2 } } { \partial x _ { 1 } ^ { 2 } } + \cdot \cdot \cdot + \frac { \partial ^ { 2 } } { \partial x _ { k } ^ { 2 } } } \end{array}$ is the linear Laplace operator; $u$ maps spatial coordinates (e.g. in $\mathbb { R } ^ { 3 }$ ) into its temperature, and $\boldsymbol { \mathscr { f } }$ maps spatial coordinates into the heat in/out flow. Solving this equation lets us know the stationary temperature given specified heat in/out flow.
+
+Usually the equation ${ \mathcal { A } } u = { \mathcal { E } }$ does not uniquely determine $_ { \mathcal { W } }$ . For example, $u =$ constant for any constant is a solution to the equation $\bar { \nabla } ^ { 2 } \bar { u _ { \ } } = \ 0$ . To ensure a unique solution we provide additional equations, called “boundary conditions”. Several boundary conditions arise very naturally in physical problems. A very common one is the Dirichlet boundary condition, where we pick some subset $\mathcal { G } \subset \mathbf { \mathbb { R } } ^ { k }$ and fix the values of the function on $\mathcal { G }$ to some fixed value $\mathcal { \ell }$ ,
+
+$$
+u ( x ) = \ell ( x ) , { \mathrm { ~ f o r ~ a l l ~ } } x \in { \mathcal { G } }
+$$
+
+where the function $\boldsymbol { \ell }$ is usually clear from the underlying physical problem. As in previous literature, we refer to $\mathcal { G }$ as the geometry of the problem, and $\mathcal { \ell }$ as the boundary value. We refer to the pair $( \mathcal G , \mathcal { \ell } )$ as the boundary condition. In this paper, we only consider linear PDEs and boundary conditions that have unique solutions.
+
+# 2.2 FINITE DIFFERENCE METHOD
+
+Most real-world PDEs do not admit an analytic solution and must be solved numerically. The first step is to discretize the solution space $\mathcal { F }$ from $\mathbb { R } ^ { k } \to \mathbb { R }$ into $\mathbb { D } ^ { k } \to \mathbb { R }$ , where $\mathbb { D }$ is a discrete subset of $\mathbb { R }$ . When the space is compact, it is discretized into an $n \times n \times n \cdots$ ( $k$ many) uniform Cartesian grid with mesh width $h$ . Any function in $\mathcal { F }$ is approximated by its value on the $n ^ { k }$ grid points. We denote the discretized function as a vector $u$ in $\mathbb { R } ^ { \bar { n ^ { k } } }$ . In this paper, we focus on 2D problems $k = 2 ,$ ), but the strategy applies to any dimension.
+
+We discretize all three terms in the equation ${ \mathcal { A } } u = { \mathcal { E } }$ and boundary condition $( \mathcal G , \mathcal { \ell } )$ . The PDE solution $_ { \mathcal { W } }$ is discretized such that $u _ { i , j } = u ( x _ { i } , y _ { j } )$ corresponds to the value of $_ { \mathcal { W } }$ at grid point $( x _ { i } , y _ { j } )$ . We can similarly discretize n of partial derivative operato $\boldsymbol { \mathscr { f } }$ and . Fo $\boldsymbol { \ell }$ . In linear PDEs, the linear operatxample, for the Poisson equation $\mathcal { A }$ $\begin{array} { r } { \mathcal { A } = \nabla ^ { 2 } = \sum _ { i } \frac { \partial ^ { 2 } } { \partial x _ { i } ^ { 2 } } } \end{array}$ Therefore we can first discretize each partial derivative, then linearly combine the discretized partial derivatives to obtain a discretized $\mathcal { A }$ .
+
+Finite difference is a method that approximates partial derivatives in a discretized space, and as mesh width $h  0$ , the approximation approaches the true derivative. For example, $\scriptstyle { \frac { \partial ^ { 2 } } { \partial x ^ { 2 } } } u$ can be discretized in 2D as $\begin{array} { r } { \frac { \partial ^ { 2 } } { \partial x ^ { 2 } } u \approx \frac { 1 } { h ^ { 2 } } ( u _ { i - 1 , j } - 2 u _ { i , j } + u _ { i + 1 , j } ) } \end{array}$ , the Laplace operator in 2D can be correspondingly approximated as:
+
+$$
+\nabla ^ { 2 } u = \frac { \partial ^ { 2 } u } { \partial x ^ { 2 } } + \frac { \partial ^ { 2 } u } { \partial y ^ { 2 } } \approx \frac { 1 } { h ^ { 2 } } ( u _ { i - 1 , j } + u _ { i + 1 , j } + u _ { i , j - 1 } + u _ { i , j + 1 } - 4 u _ { i , j } )
+$$
+
+After discretization, we can rewrite ${ \mathcal { A } } u = { \mathcal { E } }$ as a linear matrix equation
+
+$$
+A u = f
+$$
+
+where $u , f \in \mathbb { R } ^ { n ^ { 2 } }$ , and $A$ is a matrix in $\mathbb { R } ^ { n ^ { 2 } \times n ^ { 2 } }$ (these are $n ^ { 2 }$ dimensional because we focus on 2D problems). In many PDEs such as the Poisson and Helmholtz equation, $A$ is sparse, banded, and symmetric.
+
+# 2.3 BOUNDARY CONDITION
+
+We also need to include the boundary condition $u ( x ) = \ell ( x )$ for all $x \in { \mathcal { G } }$ . If a discretized point $( x _ { i } , y _ { j } )$ belongs to $\mathcal { G }$ , we need to fix the value of $u _ { i , j }$ to $b _ { i , j }$ . To achieve this, we first define $e \in \{ 0 , 1 \} ^ { n ^ { 2 } }$ to be a vector of 0’s and 1’s, in which 0 indicates that the corresponding point belongs to $\mathcal { G }$ . Then, we define a “reset” matrix $G = d i a g ( e )$ , a diagonal matrix $\mathbb { R } ^ { n ^ { 2 } } \to \mathbb { R } ^ { n ^ { 2 } }$ such that
+
+$$
+( G u ) _ { i , j } = { \left\{ \begin{array} { l l } { u _ { i , j } } & { ( x _ { i } , y _ { j } ) \notin { \mathcal { G } } } \\ { 0 } & { ( x _ { i } , y _ { j } ) \in { \mathcal { G } } } \end{array} \right. }
+$$
+
+Intuitively $G$ ”masks” every point in $\mathcal { G }$ to 0. Similarly, $I - G$ can mask every point not in $\mathcal { G }$ to 0. Note that the boundary values are fixed and do not need to satisfy $A u = f$ . Thus, the solution $u$ to the PDE under geometry $\mathcal { G }$ should satisfy:
+
+$$
+\begin{array} { c } { { G ( A u ) = G f } } \\ { { ( I - G ) u = ( I - G ) b } } \end{array}
+$$
+
+The first equation ensures that the interior points (points not in $\mathcal { G }$ ) satisfy $A u = f$ , and the second ensures that the boundary condition is satisfied.
+
+To summarize, $( \mathcal { A } , \mathcal { G } , \ell , \ell , n )$ is our PDE problem, and we first discretize the problem on an $n \times n$ grid to obtain $( A , G , f , b , n )$ . Our objective is to obtain a solution $u$ that satisfies Eq. (4), i.e. $A u = f$ for the interior points and boundary condition $u _ { i , j } = b _ { i , j }$ , $\forall ( x _ { i } , y _ { j } ) \in \mathcal { G }$ .
+
+# 2.4 ITERATIVE SOLVERS
+
+A linear iterative solver is defined as a function that inputs the current proposed solution $u \in \mathbb { R } ^ { n ^ { 2 } }$ and outputs an updated solution $u ^ { \prime }$ . Formally it is a function $\Psi : \mathbb { R } ^ { n ^ { 2 } }  \mathbb { R } ^ { n ^ { 2 } }$ that can be expressed as
+
+$$
+u ^ { \prime } = \Psi ( u ) = T u + c
+$$
+
+where $T$ is a constant update matrix and $c$ is a constant vector. For each iterator $\Psi$ there may be special vectors $u ^ { * } \in \mathbb { R } ^ { n ^ { 2 } }$ that satisfy $\boldsymbol { u } ^ { * } = \boldsymbol { \Psi } ( \boldsymbol { u } ^ { * } )$ . These vectors are called fixed points.
+
+The iterative solver $\Psi$ should map any initial $u ^ { 0 } \in \mathbb { R } ^ { n ^ { 2 } }$ to a correct solution of the PDE problem.   
+This is formalized in the following theorem.
+
+Definition 1 (Valid Iterator). An iterator $\Psi$ is valid w.r.t. a PDE problem $( A , G , f , b , n )$ if it satisfies:
+
+a) Convergence: There is a unique fixed point $u ^ { * }$ such that $\Psi$ converges to $u ^ { * }$ from any initialization: $\begin{array} { r } { \forall u ^ { 0 } \in \mathbb { R } ^ { n ^ { 2 } } , \operatorname* { l i m } _ { k \to \infty } \Psi ^ { k } ( u ^ { 0 } ) = u ^ { * } } \end{array}$ .
+
+$^ b$ ) Fixed Point: The fixed point $u ^ { * }$ is the solution to the linear system $A u = f$ under boundary condition $( G , b )$ .
+
+Convergence: Condition (a) in Definition 1 is satisfied if the matrix $T$ is convergent, i.e. $T ^ { k } \to 0$ as $k  \infty$ . It has been proven that $T$ is convergent if and only if the spectral radius $\rho ( T ) < 1$ (Olver, 2008):
+
+Theorem 1. (Olver, 2008, Prop 7.25) For a linear iterator $\Psi ( u ) = T u + c , \Psi$ converges to a unique stable fixed point from any initialization if and only if the spectral radius $\rho ( T ) < 1$ .
+
+Proof. See Appendix A.
+
+It is important to note that Condition (a) only depends on $T$ and not the constant $c$ .
+
+Fixed Point: Condition (b) in Definition 1 contains two requirements: satisfy $A u \ : = \ : f$ , and the boundary condition $( G , b )$ . To satisfy $A u = f$ a standard approach is to design $\Psi$ by matrix splitting: split the matrix $A$ into $A = M - N$ ; rewrite $A u = f$ as $M u = N u + f$ (LeVeque, 2007). This naturally suggests the iterative update
+
+$$
+u ^ { \prime } = M ^ { - 1 } N u + M ^ { - 1 } f
+$$
+
+Because Eq. (6) is a rewrite of $A u = f$ , stationary points $u ^ { * }$ of Eq. (6) satisfy $A u ^ { * } = f$ . Clearly, the choices of $M$ and $N$ are arbitrary but crucial. From Theorem 1, we must choose $M$ such that the update converges. In addition, $\dot { M ^ { - 1 } }$ must easy to compute (e.g., diagonal).
+
+Finally we also need to satisfy the boundary condition $( I - G ) u = ( I - G ) b$ in Eq.4. After each update in Eq. (6), the boundary condition could be violated. We use the “reset” operator defined in Eq. (3) to “reset” the values of $u _ { i , j }$ to $b _ { i , j }$ by $G u + ( I - G ) b$ .
+
+The final update rule becomes
+
+$$
+u ^ { \prime } = G ( M ^ { - 1 } N u + M ^ { - 1 } f ) + ( I - G ) b
+$$
+
+Despite the added complexity, it is still a linear update rule in the form of $u ^ { \prime } = T u + c$ in Eq. (5): we have $T = G M ^ { - 1 } { \dot { N } }$ and $\dot { c } = G M ^ { - 1 } f + ( 1 - \mathbf { \dot { \cal G } } ) b$ . As long as $M$ is a full rank diagonal matrix, fixed points of this equation satisfies Eq. (4). In other words, such a fixed point is a solution of the PDE problem $( A , G , f , b , n )$ .
+
+Proposition 1. If $M$ is a full rank diagonal matrix, and $u ^ { * } \in \mathbb { R } ^ { n ^ { 2 } \times n ^ { 2 } }$ satisfies Eq. (7), then $u ^ { * }$ satisfies Eq. (4).
+
+# 2.4.1 JACOBI METHOD
+
+A simple but effective way to choose $M$ is the Jacobi method, which sets $M \ : = \ : I$ (a full rank diagonal matrix, as required by Proposition 1). For Poisson equations, this update rule has the following form,
+
+$$
+\begin{array} { l } { { \hat { u } _ { i , j } = \displaystyle \frac { 1 } { 4 } \big ( u _ { i - 1 , j } + u _ { i + 1 , j } + u _ { i , j - 1 } + u _ { i , j + 1 } \big ) + \frac { h ^ { 2 } } { 4 } f _ { i , j } } } \\ { { u ^ { \prime } = G \hat { u } + ( 1 - G ) b } } \end{array}
+$$
+
+For Poisson equations and any geometry $G$ , the update matrix $T = G ( I - A )$ has spectral radius $\rho ( T ) < 1$ (see Appendix B). In addition, by Proposition 1 any fixed point of the update rule Eq.(8,9) must satisfy Eq. (4). Both convergence and fixed point conditions from Definition 1 are satisfied: Jacobi iterator Eq.(8,9) is valid for any Poisson PDE problem.
+
+In addition, each step of the Jacobi update can be implemented as a neural network layer, i.e., Eq. (8) can be efficiently implemented by convolving $u$ with kernel $\left( \begin{array} { c c c } { { 0 } } & { { 1 / 4 } } & { { 0 } } \\ { { 1 / 4 } } & { { 0 } } & { { 1 / 4 } } \\ { { 0 } } & { { 1 / 4 } } & { { 0 } } \end{array} \right)$ and adding $h ^ { 2 } f / 4$ . The “reset” step in Eq. (9) can also be implemented as multiplying $u$ with $\mathbf { G }$ and adding the boundary values $( 1 - G ) b$ .
+
+# 2.4.2 MULTIGRID METHOD
+
+The Jacobi method has very slow convergence rate (LeVeque, 2007). This is evident from the update rule, where the value at each grid point is only influenced by its immediate neighbors. To propagate information from one grid point to another, we need as many iterations as their distance on the grid. The key insight of the Multigrid method is to perform Jacobi updates on a downsampled (coarser) grid and then upsample the results. A common structure is the V-cycle (Briggs et al., 2000). In each
+
+V-cycle, there are $k$ downsampling layers followed by $k$ upsampling layers, and multiple Jacobi updates are performed at each resolution. The downsampling and upsampling operations are also called restriction and prolongation, and are often implemented using weighted restriction and linear interpolation respectively. The advantage of the multigrid method is clear: on a downsampled grid (by a factor of 2) with mesh width $2 h$ , information propagation is twice as fast, and each iteration requires only 1/4 operations compared to the original grid with mesh width $h$ .
+
+# 3 LEARNING FAST AND PROVABLY CORRECT ITERATIVE PDE SOLVERS
+
+A PDE problem consists of five components $( \mathcal { A } , \mathcal { G } , \ell , \ell , n )$ . One is often interested in solving the same PDE class $\mathcal { A }$ under varying $\boldsymbol { \mathscr { f } }$ , discretization $n$ , and boundary conditions $( \mathcal G , \mathcal { \ell } )$ . For example, solving the Poisson equation under different boundary conditions (e.g., corresponding to different mechanical systems governed by the same physics). In this paper, we fix $\mathcal { A }$ but vary ${ \mathcal { G } } , { \mathcal { f } } , { \mathcal { k } } , n$ , and learn an iterator that solves a class of PDE problems governed by the same $\mathcal { A }$ . For a discretized PDE problem $( A , G , f , b , n )$ and given a standard (hand designed) iterative solver $\Psi$ , our goal is to improve upon $\Psi$ and learn a solver $\Phi$ that has (1) correct fixed point and (2) fast convergence (on average) on the class of problems of interest. We will proceed to parameterize a family of $\Phi$ that satisfies (1) by design, and achieve (2) by optimization.
+
+In practice, we can only train $\Phi$ on a small number of problems $( A , f _ { i } , G _ { i } , b _ { i } , n _ { i } )$ . To be useful, $\Phi$ must deliver good performance on every choice of $G , f , b$ , and different grid sizes $n$ . We show, theoretically and empirically, that our iterator family has good generalization properties: even if we train on a single problem $( A , G , f , b , n )$ , the iterator performs well on very different choices of $G , f , b$ , and grid size $n$ . For example, we train our iterator on a $6 4 \times 6 4$ square domain, and test on a $2 5 6 \times 2 5 6$ L-shaped domain (see Figure 1).
+
+# 3.1 FORMULATION
+
+For a fixed PDE problem class $\mathcal { A }$ , let $\Psi$ be a standard linear iterative solver known to be valid. We will use more formal notation $\Psi ( u ; G , f , b , n )$ as $\Psi$ is a function of $u$ , but also depends on $G , f , b , n$ . Our assumption is that for any choice of $G , f , b , n$ (but fixed PDE class $\mathcal { A }$ ), $\Psi ( u ; G , f , b , n )$ is valid. We previously showed that Jacobi iterator Eq.(8,9) have this property for the Poisson PDE class.
+
+We design our new family of iterators $\Phi _ { H } : \mathbb { R } ^ { n ^ { 2 } }  \mathbb { R } ^ { n ^ { 2 } }$
+
+$$
+\begin{array} { c } { { w = \Psi ( u ; G , f , b , n ) - u } } \\ { { { } } } \\ { { \Phi _ { H } ( u ; G , f , b , n ) = \Psi ( u ; G , f , b , n ) + G H w } } \end{array}
+$$
+
+where $H$ is a learned linear operator (it satisfies $H 0 = 0$ ). The term $G H w$ can be interpreted as a correction term to $\Psi ( u ; G , \bar { f } , b , n )$ . When there is no confusion, we neglect the dependence on $G , f , b , n$ and denote as $\Psi ( u )$ and $\Phi _ { H } ( u )$ .
+
+$\Phi _ { H }$ should have similar computation complexity as $\Psi$ . Therefore, we choose $H$ to be a convolutional operator, which can be parameterized by a deep linear convolutional network. We will discuss the parameterization of $H$ in detail in Section 3.4; we first prove some parameterization independent properties.
+
+The correct PDE solution is a fixed point of $\Phi _ { H }$ by the following lemma:
+
+Lemma 1. For any PDE problem $( A , G , f , b , n )$ and choice of $H$ , if $u ^ { * }$ is a fixed point of $\Psi$ , it is $a$ fixed point of $\Phi _ { H }$ in Eq. (10).
+
+Proof. Based on the iterative rule in Eq. (10), if $u ^ { * }$ satisfies $\Psi ( u ^ { * } ) = u ^ { * }$ then $w = \Psi ( u ^ { * } ) - u ^ { * } = \mathbf { 0 }$ Therefore, $\Phi _ { H } ( u ^ { * } ) = \Psi ( u ^ { * } ) + G H \mathbf { 0 } = u ^ { * }$ . □
+
+Moreover, the space of $\Phi _ { H }$ subsumes the standard solver $\Psi$ . If $H = 0$ , then $\Phi _ { H } = \Psi$ . Furthermore, denote $\Psi ( u ) = T u + c$ , then if $H = T$ , then since $G T = T$ (see Eq. (7)),
+
+$$
+\Phi _ { H } ( u ) = \Psi ( u ) + G T ( \Psi ( u ) - u ) = T \Psi ( u ) + c = \Psi ^ { 2 } ( u )
+$$
+
+which is equal to two iterations of $\Psi$ . Computing $\Psi$ requires one convolution $T$ , while computing $\Phi _ { H }$ requires two convolutions: $T$ and $H$ . Therefore, if we choose $H = T$ , then $\Phi _ { H }$ computes two iterations of $\Psi$ with two convolutions: it is at least as efficient as the standard solver $\Psi$ .
+
+# 3.2 TRAINING AND GENERALIZATION
+
+We train our iterator $\Phi _ { H } ( u ; G , f , b , n )$ to converge quickly to the ground truth solution on a set $\mathcal { D } = \{ ( G _ { l } , f _ { l } , b _ { l } , n _ { l } ) \} _ { l = 1 } ^ { M }$ of problem instances. For each instance, the ground truth solution $u ^ { * }$ is obtained from the existing solver $\Psi$ . The learning objective is then
+
+$$
+\operatorname* { m i n } _ { H } \sum _ { ( G _ { l } , f _ { l } , b _ { l } , n _ { l } ) \in \mathcal { D } } \mathbb { E } _ { u ^ { 0 } \sim \mathcal { N } ( 0 , 1 ) } \| \Phi _ { H } ^ { k } ( u ^ { 0 } ; G _ { l } , f _ { l } , b _ { l } , n _ { l } ) - u ^ { * } \| _ { 2 } ^ { 2 }
+$$
+
+Intuitively, we look for a matrix $H$ such that the corresponding iterator $\Phi _ { H }$ will get us as close as possible to the solution in $k$ steps, starting from a random initialization $u ^ { 0 }$ sampled from a white Gaussian. $k$ in our experiments is uniformly chosen from [1, 20], similar to the procedure in (Song et al., 2017). Smaller $k$ is easier to learn with less steps to back-propagate through, while larger $k$ better approximates our test-time setting: we care about the final approximation accuracy after a given number of iteration steps. Combining smaller and larger $k$ performs best in practice.
+
+We show in the following theorem that there is a convex open set of $H$ that the learning algorithm can explore. To simplify the statement of the theorem, for any linear iterator $\Phi ( u ) = \mathbf { \bar { \mathit { T } } } u \mathbf { \bar { \mathit { + } } } c$ we will refer to the spectral radius (norm) of $\Phi$ as the spectral radius (norm) of $T$ .
+
+Theorem 2. For fixed $G , f , b , n ,$ , the spectral norm of $\Phi _ { H } ( u ; G , f , b , n )$ is a convex function of $H$ and the set of $H$ such that the spectral norm of $\Phi _ { H } ( u ; G , f , b , n ) < 1$ is a convex open set.
+
+Proof. See Appendix A.
+
+Therefore, to find an iterator with small spectral norm, the learning algorithm only has to explore a convex open set. Note that Theorem 2 holds for spectral norm, whereas validity requires small spectral radius in Theorem 1. Nonetheless, several important PDE problems (Poisson, Helmholtz, etc) are symmetric, so it is natural to use a symmetric iterator, which means that spectral norm is equal to spectral radius. In our experiments, we do not explicitly enforce symmetry, but we observe that the optimization finds symmetric iterators automatically.
+
+For training, we use a single grid size $n$ , a single geometry $G$ , $f = 0$ , and a restricted set of boundary conditions $b$ . The geometry we use is a square domain shown in Figure 1a. Although we train on a single domain, the model has surprising generalization properties, which we show in the following:
+
+Proposition 2. For fixed $A , G , n$ and fixed $H$ , if for some $f _ { 0 } , b _ { 0 } , \Phi _ { H } ( u ; G , f _ { 0 } , b _ { 0 } , n )$ is valid for the PDE problem $( A , G , f _ { 0 } , b _ { 0 } , n )$ , then for all $f$ and $b$ , the iterator $\Phi _ { H } ( u ; G , f , b , n )$ is valid for the PDE problem $( A , G , f , b , n )$ .
+
+Proof. See Appendix A.
+
+The proposition states that we freely generalize to different $f$ and $b$ . There is no guarantee that we can generalize to different $G$ and $n$ . Generalization to different $G$ and $n$ has to be empirically verified: in our experiments, our learned iterator converges to the correct solution for a variety of grid sizes $n$ and geometries $G$ , even though it was only trained on one grid size and geometry.
+
+Even when generalization fails, there is no risk of obtaining incorrect results. The iterator will simply fail to converge. This is because according to Lemma 1, fixed points of our new iterator is the same as the fixed point of hand designed iterator $\Psi$ . Therefore if our iterator is convergent, it is valid.
+
+# 3.3 INTERPRETATION OF $H$
+
+What is $H$ trying to approximate? In this section we show that we are training our linear function $G H$ to approximate $\bar { T ( I - T ) } ^ { - 1 }$ : if it were able to approximate $T ( I - T ) ^ { - 1 }$ perfectly, our iterator $\Phi _ { H }$ will converge to the correct solution in a single iteration.
+
+Let the original update rule be $\Psi ( u ) = T u + c$ , and the unknown ground truth solution be $u ^ { * }$ satisfying $u ^ { * } = T u ^ { * } + c$ . Let $r = u ^ { * } - u$ be the current error, and $e = u ^ { * } - \Psi ( u )$ be the new error after applying one step of $\Psi$ . They are related by
+
+$$
+e = u ^ { * } - \Psi ( u ) = u ^ { * } - ( T u + c ) = T ( u ^ { * } - u ) = T r
+$$
+
+In addition, let $w = \Psi ( u ) - u$ be the update $\Psi$ makes. This is related to the current error $r$ by
+
+$$
+w = \Psi ( u ) - u = T u + c - u + ( u ^ { * } - T u ^ { * } - c ) = T ( u - u ^ { * } ) + ( u ^ { * } - u ) = ( I - T ) r
+$$
+
+From Eq. (10) we can observe that the linear operator $G H$ takes as input $\Psi$ ’s update $w$ , and tries to approximate the error $e$ : $G H w \approx e$ . If the approximation were perfect: $G H w = e$ , the iterator $\Phi _ { H }$ would converge in a single iteration. Therefore, we are trying to find some linear operator $R$ , such that $R w = e$ . In fact, if we combine Eq. (13) and Eq. (14), we can observe that $T ( I - T ) ^ { - 1 }$ is (uniquely) the linear operator we are looking for
+
+$$
+T ( I - T ) ^ { - 1 } w = e
+$$
+
+where $( I - T ) ^ { - 1 }$ exists because $\rho ( T ) < 1$ , so all eigenvalues of $I - T$ must be strictly positive.   
+Therefore, we would like our linear function $G H$ to approximate $T ( I - T ) ^ { - 1 }$ .
+
+Note that $( I - T ) ^ { - 1 }$ is a dense matrix in general, meaning that it is impossible to exactly achieve $G H = T ( { \cal I } - { \cal T } ) \dot { - } 1$ with a convolutional operator $H$ . However, the better $G H$ is able to approximate $T ( I - T ) ^ { - 1 }$ , the faster our iterator converges to the solution $u ^ { * }$ .
+
+# 3.4 LINEAR DEEP NETWORKS
+
+In our iterator design, $H$ is a linear function parameterized by a linear deep network without nonlinearity or bias terms. Even though our objective in Eq. (12) is a non-linear function of the parameters of the deep network, this is not an issue in practice. In particular, Arora et al. (2018) observes that when modeling linear functions, deep networks can be faster to optimize with gradient descent compared to linear ones, despite non-convexity.
+
+Even though a linear deep network can only represent a linear function, it has several advantages. On an $n \times n$ grid, each convolution layer only requires $O ( n ^ { 2 } )$ computation and have a constant number of parameters, while a general linear function requires ${ \dot { O ( n ^ { 4 } ) } }$ computation and have $O ( n ^ { 4 } )$ parameters. Stacking $d$ convolution layers allows us to parameterize complex linear functions with large receptive fields, while only requiring $O ( d n ^ { 2 } )$ computation and $O ( d ) ^ { \top }$ parameters. We experiment on two types of linear deep networks:
+
+Conv model. We model $H$ as a network with $3 \times 3$ convolutional layers without non-linearity or bias. We will refer to a model with $k$ layers as $^ { 6 6 } \mathrm { C o n v } k ^ { \prime }$ , e.g. Conv3 has 3 convolutional layers.
+
+U-Net model. The Conv models suffer from the same problem as Jacobi: the receptive field grows only by 1 for each additional layer. To resolve this problem, we design the deep network counterpart of the Multigrid method. Instead of manually designing the sub-sampling $/$ super-sampling functions, we use a U-Net architecture (Ronneberger et al., 2015) to learn them from data. Because each layer reduces the grid size by half, and the $i$ -th layer of the U-Net only operates on $( 2 ^ { - i } n )$ -sized grids, the total computation is only increased by a factor of
+
+$$
+1 + 1 / 4 + 1 / 1 6 + \cdot \cdot \cdot < 4 / 3
+$$
+
+compared to a two-layer convolution. The minimal overhead provides a very large improvement of convergence speed in our experiments. We will refer to Multigrid and U-Net models with $k$ sub-sampling layers as Multigrid $k$ and U-Netk, e.g. U-Net2 is a model with 2 sub-sampling layers.
+
+# 4 EXPERIMENTS
+
+# 4.1 SETTING
+
+We evaluate our method on the 2D Poisson equation with Dirichlet boundary conditions, $\nabla ^ { 2 } u =$ $\boldsymbol { \mathscr { f } }$ . There exist several iterative solvers for the Poisson equation, including Jacobi, Gauss-Seidel, conjugate-gradient, and multigrid methods. We select the Jacobi method as our standard solver $\Psi$ .
+
+To reemphasize, our goal is to train a model on simple domains where the ground truth solutions can be easily obtained, and then evaluate its performance on different geometries and boundary conditions. Therefore, for training, we select the simplest Laplace equation, $\nabla ^ { 2 } u = 0$ , on a square domain with boundary conditions such that each side is a random fixed value. Figure 1a shows an example of our training domain and its ground truth solution. This setting is also used in Farimani et al. (2017) and Sharma et al. (2018).
+
+![](images/01bc31a70964c1ce2d6a0127cb1e7606a6068129d165c44803c821bc43907593.jpg)  
+Figure 1: The ground truth solutions of examples in different settings. We only train our models on the square domain, and we test on all 4 settings.
+
+For testing, we use larger grid sizes than training. For example, we test on $2 5 6 \times 2 5 6$ grid for a model trained on $6 4 \times 6 4$ grids. Moreover, we designed challenging geometries to test the generalization of our models. We test generalization on 4 different settings: (i) same geometry but larger grid, (ii) L-shape geometry, (iii) Cylinders geometry, and (iv) Poisson equation in same geometry, but $f \neq 0$ . The two geometries are designed because the models were trained on square domains and have never seen sharp or curved boundaries. Examples of the 4 settings are shown in Figure 1.
+
+# 4.2 EVALUATION
+
+As discussed in Section 2.4, the convergence rate of any linear iterator can be determined from the spectral radius $\rho ( T )$ , which provides guarantees on convergence and convergence rate. However, a fair comparison should also consider the computation cost of $H$ . Thus, we evaluate the convergence rate by calculating the computation cost required for the error to drop below a certain threshold.
+
+On GPU, the Jacobi iterator and our model can both be efficiently implemented as convolutional layers. Thus, we measure the computation cost by the number of convolutional layers. On CPU, each Jacobi iteration $\begin{array} { r } { u _ { i , j } ^ { \prime } = \frac { 1 } { 4 } ( u _ { i - 1 , j } + u _ { i + 1 , j } + \dot { u } _ { i , j - 1 } + u _ { i , j + 1 } ) } \end{array}$ has 4 multiply-add operations, while a $3 \times 3$ convolutional kernel requires 9 operations, so we measure the computation cost by the number of multiply-add operations. This metric is biased in favor of Jacobi because there is little practical reason to implement convolutions on CPU. Nonetheless, we report both metrics in our experiments.
+
+# 4.3 CONV MODEL
+
+Table 1 shows results of the Conv model. The model is trained on a $1 6 \times 1 6$ square domain, and tested on $6 4 \times 6 4$ . For all settings, our models converge to the correct solution, and require less computation than Jacobi. The best model, Conv3, is $\sim 5 \times$ faster than Jacobi in terms of layers, and $\sim 2 . 5 \times$ faster in terms of multiply-add operations.
+
+As discussed in Section 3.2, if our iterator converges for a geometry, then it is guaranteed to converge to the correct solution for any $f$ and boundary values $b$ . The experiment results show that our model not only converges but also converges faster than the standard solver, even though it is only trained on a smaller square domain.
+
+# 4.4 U-NET MODEL
+
+For the U-Net models, we compare them against Multigrid models with the same number of subsampling and smoothing layers. Therefore, our models have the same number of convolutional layers, and roughly $9 / 4$ times the number of operations compared to Multigrid. The model is trained on a $6 4 \times 6 4$ square domain, and tested on $2 5 6 \times 2 5 6$ .
+
+The bottom part of Table 1 shows the results of the U-Net model. Similar to the results of Conv models, our models outperforms Multigrid in all settings. Note that U-Net2 has lower computation cost compared with Multigrid2 than U-Net3 compared to Multigrid 3. This is because Multigrid2 is a relatively worse baseline. U-Net3 still converges faster than U-Net2.
+
+Table 1: Comparisons between our models and the baseline solvers. The Conv models are compared with Jacobi, and the U-Net models are compared with Multigrid. The numbers are the ratio between the computation costs of our models and the baselines. None of the values are greater than 1, which means that all of our models achieve a speed up on every problem and both performance metric (convolutional layers and multiply-add operations).   
+
+<table><tr><td>Model</td><td>Baseline</td><td>Square layers /ops</td><td>L-shape layers /ops</td><td>Cylinders layers /ops</td><td>Square-Poisson layers /ops</td></tr><tr><td>Conv1</td><td>Jacobi</td><td>0.432/0.702</td><td>0.432/0.702</td><td>0.432/0.702</td><td>0.431/0.701</td></tr><tr><td>Conv2</td><td>Jacobi</td><td>0.286 / 0.524</td><td>0.286 / 0.524</td><td>0.286 / 0.524</td><td>0.285 / 0.522</td></tr><tr><td>Conv3</td><td>Jacobi</td><td>0.219 / 0.424</td><td>0.219 / 0.423</td><td>0.220 / 0.426</td><td>0.217 /0.421</td></tr><tr><td>Conv4</td><td>Jacobi</td><td>0.224 /0.449</td><td>0.224 / 0.449</td><td>0.224 / 0.448</td><td>0.222 / 0.444</td></tr><tr><td>U-Net2</td><td>Multigrid2</td><td>0.091/0.205</td><td>0.090/0.203</td><td>0.091/0.204</td><td>0.079 / 0.178</td></tr><tr><td>U-Net3</td><td>Multigrid3</td><td>0.220 / 0.494</td><td>0.213 / 0.479</td><td>0.201 / 0.453</td><td>0.185 / 0.417</td></tr></table>
+
+![](images/c0b538377cbeba01e76b0a46a9018bd4d9a6cb98ad497d2921cd394020197279.jpg)  
+Figure 2: CPU runtime comparisons of our model with the FEniCS model. Our method is comparable or faster than the best solver in FEniCS in all cases. When run on GPU, our solver provides an additional $3 0 \times$ speedup.
+
+# 4.5 COMPARISON WITH FENICS
+
+The FEniCS package (Logg et al., 2012) provides a collection of tools with high-level Python and $\mathrm { C } { + } { + }$ interfaces to solve differential equations. The open-source project is developed and maintained by a global community of scientists and software developers. Its extensive optimization over the years, including the support for parallel computation, has led to its widespread adaption in industry and academia (Alnæs et al., 2015).
+
+We measure the wall clock time of the FEniCS model and our model, run on the same hardware. The FEniCS model is set to be the minimal residual method with algebraic multigrid preconditioner, which we measure to be the fastest compared to other methods such as Jacobi or Incomplete LU factorization preconditioner. We ignore the time it takes to set up geometry and boundary conditions, and only consider the time the solver takes to solve the problem. We set the error threshold to be 1 percent of the initial error. For the square domain, we use a quadrilateral mesh. For the L-shape and cylinder domains, however, we let FEniCS generate the mesh automatically, while ensuring the number of mesh points to be similar.
+
+Figure 2 shows that our model is comparable or faster than FEniCS in wall clock time. These experiments are all done on CPU. Our model efficiently runs on GPU, while the fast but complex methods in FEniCS do not have efficient GPU implementations available. On GPU, we measure an additional $3 0 \times$ speedup (on Tesla K80 GPU, compared with a 64-core CPU).
+
+# 5 RELATED WORK
+
+Recently, there have been several works on applying deep learning to solve the Poisson equation. However, to the best of our knowledge, previous works used deep networks to directly generate the solution; they have no correctness guarantees and are not generalizable to arbitrary grid sizes and boundary conditions. Most related to our work are (Farimani et al., 2017) and (Sharma et al., 2018), which learn deep networks to output the solution of the 2D Laplace equation (a special case where $f = 0 ,$ ). (Farimani et al., 2017) trained a U-Net model that takes in the boundary condition as a 2D image and outputs the solution. The model is trained by L1 loss to the ground truth solution and an adversarial discriminator loss. (Sharma et al., 2018) also trained a U-net model but used a weakly-supervised loss. There are other related works that solved the Poisson equation in concrete physical problems. (Tang et al., 2017) solved for electric potential in 2D/3D space; (Tompson et al., 2017) solved for pressure fields for fluid simulation; (Zhang et al., 2018) solved particle simulation of a PN Junction.
+
+There are other works that solve other types of PDEs. For example, many studies aimed to use deep learning to accelerate and approximate fluid dynamics, governed by the Euler equation or the Navier-Stokes equations (Guo et al., 2016; Yang et al., 2016; Chu & Thuerey, 2017; Kutz, 2017). (Eismann et al., 2018) use Bayesian optimization to design shapes with reduced drag coefficients in laminar fluid flow. Other applications include solving the Schrodinger equation (Mills et al., 2017), turbulence modeling (Singh et al., 2017), and the American options and Black Scholes PDE (Sirignano & Spiliopoulos, 2018). A lot of these PDEs are nonlinear and may not have a standard linear iterative solver, which is a limitation to our current method since our model must be built on top of an existing linear solver to ensure correctness. We consider the extension to different PDEs as future work.
+
+# 6 CONCLUSION
+
+We presented a method to learn an iterative solver for PDEs that improves on an existing standard solver. The correct solution is theoretically guaranteed to be the fixed point of our iterator. We show that our model, trained on simple domains, can generalize to different grid sizes, geometries and boundary conditions. It converges correctly and achieves significant speedups compared to standard solvers, including highly optimized ones implemented in FEniCS.
+
+# REFERENCES
+
+Martin S Alnæs, Jan Blechta, Johan Hake, August Johansson, Benjamin Kehlet, Anders Logg, Chris Richardson, Johannes Ring, Marie E Rognes, and Garth N Wells. The fenics project version 1.5. Archive of Numerical Software, 3(100):9–23, 2015.
+
+Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, Brendan Shillingford, and Nando De Freitas. Learning to learn by gradient descent by gradient descent. In Advances in Neural Information Processing Systems, 2016.
+
+Sanjeev Arora, Nadav Cohen, and Elad Hazan. On the optimization of deep networks: Implicit acceleration by overparameterization. arXiv preprint arXiv:1802.06509, 2018.
+
+William L Briggs, Steve F McCormick, et al. A multigrid tutorial, volume 72. Siam, 2000.
+
+Mengyu Chu and Nils Thuerey. Data-driven synthesis of smoke flows with cnn-based feature descriptors. ACM Transactions on Graphics (TOG), 36(4):69, 2017.
+
+Stephan Eismann, Daniel Levy, Rui Shu, Stefan Bartzsch, and Stefano Ermon. Bayesian optimization and attribute adjustment. In Proc. 34th Conference on Uncertainty in Artificial Intelligence, 2018.
+
+Amir Barati Farimani, Joseph Gomes, and Vijay S Pande. Deep learning the physics of transport phenomena. arXiv preprint arXiv:1709.02432, 2017.
+
+Stanley P Frankel. Convergence rates of iterative treatments of partial differential equations. Mathematical Tables and Other Aids to Computation, 4(30):65–75, 1950.
+
+Xiaoxiao Guo, Wei Li, and Francesco Iorio. Convolutional neural networks for steady flow approximation. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 481–490, 2016.
+
+Tim Kraska, Alex Beutel, Ed H Chi, Jeffrey Dean, and Neoklis Polyzotis. The case for learned index structures. In Proceedings of the 2018 International Conference on Management of Data, pp. 489–504. ACM, 2018.
+
+J Nathan Kutz. Deep learning in fluid dynamics. Journal of Fluid Mechanics, 814:1–4, 2017.
+
+Randall J LeVeque. Finite difference methods for ordinary and partial differential equations: steadystate and time-dependent problems, volume 98. Siam, 2007.
+
+Daniel Levy, Matthew D Hoffman, and Jascha Sohl-Dickstein. Generalizing hamiltonian monte carlo with neural networks. arXiv preprint arXiv:1711.09268, 2017.
+
+Anders Logg, Kent-Andre Mardal, and Garth Wells. Automated solution of differential equations by the finite element method: The FEniCS book. Springer, 2012. ISBN 978-3-642-23098-1. doi: 10.1007/978-3-642-23099-8.
+
+Kyle Mills, Michael Spanner, and Isaac Tamblyn. Deep learning and the schrodinger equation.¨ Physical Review A, 96(4):042113, 2017.
+
+Peter J Olver. Numerical solution of ordinary differential equations. Numerical Analysis Lecture Notes, 2008.
+
+Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In International Conference on Medical image computing and computerassisted intervention, pp. 234–241. Springer, 2015.
+
+Rishi Sharma, Amir Barati Farimani, Joe Gomes, Peter Eastman, and Vijay Pande. Weaklysupervised deep learning of heat transport via physics informed loss. arXiv preprint arXiv:1807.11374, 2018.
+
+Anand Pratap Singh, Shivaji Medida, and Karthik Duraisamy. Machine-learning-augmented predictive modeling of turbulent separated flows over airfoils. AIAA Journal, pp. 2215–2227, 2017.
+
+Justin Sirignano and Konstantinos Spiliopoulos. Dgm: A deep learning algorithm for solving partial differential equations. Journal of Computational Physics, 375:1339–1364, 2018.
+
+Jiaming Song, Shengjia Zhao, and Stefano Ermon. A-nice-mc: Adversarial training for mcmc. In Advances in Neural Information Processing Systems, 2017.
+
+Wei Tang, Tao Shan, Xunwang Dang, Maokun Li, Fan Yang, Shenheng Xu, and Ji Wu. Study on a poisson’s equation solver based on deep learning technique. In IEEE Electrical Design of Advanced Packaging and Systems Symposium (EDAPS). IEEE, 2017.
+
+Jonathan Tompson, Kristofer Schlachter, Pablo Sprechmann, and Ken Perlin. Accelerating eulerian fluid simulation with convolutional networks. In International Conference on Machine Learning, 2017.
+
+Cheng Yang, Xubo Yang, and Xiangyun Xiao. Data-driven projection method in fluid simulation. Computer Animation and Virtual Worlds, 27(3-4):415–424, 2016.
+
+Zhongyang Zhang, Ling Zhang, Ze Sun, Nicholas Erickson, Ryan From, and Jun Fan. Solving poisson’s equation using deep learning in particle simulation of pn junction. arXiv preprint arXiv:1810.10192, 2018.
+
+# A PROOFS
+
+Theorem 1. For a linear iterator $\Psi ( u ) = T u + c , \Psi$ $\Psi$ converges to a unique stable fixed point from any initialization if and only if the spectral radius $\rho ( T ) < 1$ .
+
+Proof. Suppose $\rho ( T ) < 1$ , then $( I { - } T ) ^ { - 1 }$ must exist because all eigenvalues of $I { - } T$ must be strictly positive. Let $u ^ { * } = ( I - T ) ^ { - 1 } c ;$ ; this $u ^ { * }$ is a stationary point of the iterator $\Psi$ , i.e. $u ^ { * } = T u ^ { * } + c$ . For any initialization $u ^ { 0 }$ , let $\boldsymbol { u } ^ { \hat { k } } = \boldsymbol { \Psi } ^ { k } ( \boldsymbol { u } ^ { 0 } )$ . The error $e ^ { k } = u ^ { * } - u ^ { k }$ satisfies
+
+$$
+T e ^ { k } = ( T u ^ { * } + c ) - ( T u ^ { k } + c ) = u ^ { * } - u ^ { k + 1 } = e ^ { k + 1 } \Rightarrow e ^ { k } = T ^ { k } e ^ { 0 }
+$$
+
+Since $\rho ( T ) < 1$ , we know $T ^ { k }  0$ as $k  \infty$ (LeVeque, 2007), which means the error $e ^ { k } \to 0$ Therefore, $\Psi$ converges to $u ^ { * }$ from any $u ^ { 0 }$ .
+
+Now suppose $\rho ( T ) \geq 1$ . Let $\lambda _ { 1 }$ be the largest absolute eigenvalue where $\rho ( T ) = | \lambda _ { 1 } | \geq 1$ , and $v _ { 1 }$ be its corresponding eigenvector. We select initialization $u ^ { 0 } = u ^ { * } + v _ { 1 }$ , then $e ^ { 0 } = v _ { 1 }$ . Because $| \lambda _ { 1 } | \ge 1$ , we have $| \lambda _ { 1 } ^ { k } | \geq \bar { 1 }$ , then
+
+$$
+T ^ { k } e ^ { 0 } = \lambda _ { 1 } ^ { k } v _ { 1 } \triangleleft _ { k \to \infty } 0
+$$
+
+However we know that under a different initialization $\hat { u } ^ { 0 } = u ^ { * }$ , we have $\hat { e } ^ { 0 } = 0$ , so $T ^ { k } \hat { e } ^ { 0 } = 0$ . Therefore the iteration cannot converge to the same fixed point from different initializations $u ^ { 0 }$ and $\hat { u } ^ { 0 }$ .
+
+Proposition 1 If $M$ is a full rank diagonal matrix, and $u ^ { * } \in \mathbb { R } ^ { n ^ { 2 } \times n ^ { 2 } }$ satisfies Eq. $( 7 )$ , then $u ^ { * }$ satisfies Eq. (4).
+
+Proof of Proposition $^ { l }$ . Let $u ^ { * }$ be a fixed point of Eq. (7) then
+
+$$
+G u ^ { * } + ( I - G ) u ^ { * } = G ( M ^ { - 1 } N u ^ { * } + M ^ { - 1 } f ) + ( I - G ) b
+$$
+
+This is equivalent to
+
+$$
+\begin{array} { c } { { ( I - G ) u ^ { * } = ( I - G ) b } } \\ { { \nonumber } } \\ { { G ( u ^ { * } - M ^ { - 1 } N u ^ { * } - M ^ { - 1 } f ) = 0 } } \end{array}
+$$
+
+The latter equation is equivalent to $G M ^ { - 1 } ( A u ^ { * } - f ) = 0$ . If $M$ is a full rank diagonal matrix, this implies $G ( A u ^ { * } - f ) = 0$ , which is $G A u ^ { * } = G f$ . Therefore, $u ^ { * }$ satisfies Eq.(4). □
+
+Theorem 2. For fixed $G , f , b , n$ , the spectral norm of $\Phi _ { H } ( u ; G , f , b , n )$ is a convex function of $H$ , and the set of $H$ such that the spectral norm of $\Phi _ { H } ( u ; G , f , b , n ) < 1$ is a convex open set.
+
+Proof. As before, denote $\Psi ( u ) = T u + c$ . Observe that
+
+$$
+\Phi _ { H } ( u ; G , f , b , n ) = T u + c + G H ( T u + c - u ) = ( T + G H T - G H ) u + G H c + c T ( T + G H T - G H ) .
+$$
+
+The spectral norm $\lVert \cdot \rVert _ { 2 }$ is convex with respect to its argument, and $( T + G H T - G H )$ is linear in $H$ . Thus, $\| T + G H T - G H \| _ { 2 }$ is convex in $H$ as well. Thus, under the condition that $\| T +$ $G H T - G H \vert _ { 2 } < 1$ , the set of $H$ must be convex because it is a sub-level set of the convex function $\| T + G H T - G H \| _ { 2 }$ .
+
+To prove that it is open, observe that $\lVert \cdot \rVert _ { 2 }$ is a continuous function, so $\| T + G H T - G H \| _ { 2 }$ is a continuous map from $H$ to the spectral radius of $\Phi _ { H }$ . If we consider the set of $H$ such that $\| T + G H T - G H \| _ { 2 } < 1$ , this set is the preimage of $( - \epsilon , 1 )$ for any $\epsilon > 0$ . As $( - \epsilon , 1 )$ is open, its preimage must be open.
+
+Proposition 2. For fixed $A , G , n$ and fixed $H$ , if for some $f _ { 0 } , b _ { 0 } , \Phi _ { H } ( u ; G , f _ { 0 } , b _ { 0 } , n )$ is valid for the PDE problem $( A , G , f _ { 0 } , b _ { 0 } , n )$ , then for all $f$ and $b$ , the iterator $\Phi _ { H } ( u ; G , f , b , n )$ is valid for the PDE problem $( A , G , f , b , n )$ .
+
+Proof. From Theorem 1 and Lemma 1, our iterator is valid if and only if $\rho ( T + G H T - G H ) < 1$ . The iterator $T + G H T - G H$ only depends on $A , G$ , and is independent of the constant $c$ in Eq. (18). Thus, the validity of the iterator is independent with $f$ and $b$ . Thus, if the iterator is valid for some $f _ { 0 }$ and $b _ { 0 }$ , then it is valid for any choice of $f$ and $b$ .
+
+# B PROOF OF CONVERGENCE OF JACOBI METHOD
+
+In Section 2.4.1, we show that for Poisson equation, the update matrix $T = G ( I - A )$ . We now formally prove that $\rho ( G ( I - A ) ) < 1$ for any $G$ .
+
+For any matrix $T$ , the spectral radius is bounded by the spectral norm: $\rho ( T ) \ \leq \ \| T \| _ { 2 }$ , and the equality holds if $T$ is symmetric. Since $( I - A )$ is a symmetric matrix, $\rho ( I - A ) = \| I - A \| _ { 2 }$ . It has been proven that $\rho ( I - A ) < 1$ (Frankel, 1950). Moreover, $\| G \| _ { 2 } = 1$ . Finally, matrix norms are sub-multiplicative, so
+
+$$
+\rho ( T ) \leq \| G ( I - A ) \| _ { 2 } \leq \| G \| _ { 2 } \| I - A \| _ { 2 } < 1
+$$
+
+$\rho ( T ) < 1$ is true for any $G$ . Thus, the standard Jacobi method is valid for the Poisson equation under any geometry.

parse/train/rklaWn0qK7/rklaWn0qK7_content_list.json

@@ -0,0 +1,2175 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING NEURAL PDE SOLVERS WITH CONVER-GENCE GUARANTEES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jun-Ting Hsieh\\* Stanford junting@stanford.edu ",
+        "bbox": [
+            184,
+            194,
+            328,
+            237
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Shengjia Zhao\\* Stanford sjzhao@stanford.edu ",
+        "bbox": [
+            421,
+            194,
+            562,
+            237
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Stephan Eismann Stanford seismann@stanford.edu ",
+        "bbox": [
+            653,
+            195,
+            813,
+            237
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Lucia Mirabella   \nSiemens   \nlucia.mirabella $@$ siemens.com ",
+        "bbox": [
+            183,
+            258,
+            383,
+            300
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Stefano Ermon Stanford ermon@stanford.edu ",
+        "bbox": [
+            535,
+            258,
+            676,
+            300
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            337,
+            544,
+            352
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Partial differential equations (PDEs) are widely used across the physical and computational sciences. Decades of research and engineering went into designing fast iterative solution methods. Existing solvers are general purpose, but may be sub-optimal for specific classes of problems. In contrast to existing hand-crafted solutions, we propose an approach to learn a fast iterative solver tailored to a specific domain. We achieve this goal by learning to modify the updates of an existing solver using a deep neural network. Crucially, our approach is proven to preserve strong correctness and convergence guarantees. After training on a single geometry, our model generalizes to a wide variety of geometries and boundary conditions, and achieves 2-3 times speedup compared to state-of-the-art solvers. ",
+        "bbox": [
+            233,
+            367,
+            764,
+            506
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            531,
+            336,
+            546
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Partial differential equations (PDEs) are ubiquitous tools for modeling physical phenomena, such as heat, electrostatics, and quantum mechanics. Traditionally, PDEs are solved with hand-crafted approaches that iteratively update and improve a candidate solution until convergence. Decades of research and engineering went into designing update rules with fast convergence properties. ",
+        "bbox": [
+            174,
+            563,
+            823,
+            617
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The performance of existing solvers varies greatly across application domains, with no method uniformly dominating the others. Generic solvers are typically effective, but could be far from optimal for specific domains. In addition, high performing update rules could be too complex to design by hand. In recent years, we have seen that for many classical problems, complex updates learned from data or experience can out-perform hand-crafted ones. For example, for Markov chain Monte Carlo, learned proposal distributions lead to orders of magnitude speedups compared to handdesigned ones (Song et al., 2017; Levy et al., 2017). Other domains that benefited significantly include learned optimizers (Andrychowicz et al., 2016) and learned data structures (Kraska et al., 2018). Our goal is to bring similar benefits to PDE solvers. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            750
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hand-designed solvers are relatively simple to analyze and are guaranteed to be correct in a large class of problems. The main challenge is how to provide the same guarantees with a potentially much more complex learned solver. To achieve this goal, we build our learned iterator on top of an existing standard iterative solver to inherit its desirable properties. The iterative solver updates the solution at each step, and we learn a parameterized function to modify this update. This function class is chosen so that for any choice of parameters, the fixed point of the original iterator is preserved. This guarantees correctness, and training can be performed to enhance convergence speed. Because of this design, we only train on a single problem instance; our model correctly generalizes to a variety of different geometries and boundary conditions with no observable loss of performance. As a result, our approach provides: (i) theoretical guarantees of convergence to the correct stationary solution, (ii) faster convergence than existing solvers, and (iii) generalizes to geometries and boundary conditions very different from the ones seen at training time. This is in stark contrast with existing deep learning approaches for PDE solving (Tang et al., 2017; Farimani et al., 2017) that are limited to specific geometries and boundary conditions, and offer no guarantee of correctness. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our approach applies to any PDE with existing linear iterative solvers. As an example application, we solve the 2D Poisson equations. Our method achieves a $2 { - } 3 \\times$ speedup on number of multiplyadd operations when compared to standard iterative solvers, even on domains that are significantly different from our training set. Moreover, compared with state-of-the-art solvers implemented in FEniCS (Logg et al., 2012), our method achieves faster performance in terms of wall clock CPU time. Our method is also simple as opposed to deeply optimized solvers such as our baseline in FEniCS (minimal residual method $^ +$ algebraic multigrid preconditioner). Finally, since we utilize standard convolutional networks which can be easily parallelized on GPU, our approach leads to an additional $3 0 \\times$ speedup when run on GPU. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            284,
+            326,
+            300
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we give a brief introduction of linear PDEs and iterative solvers. We refer readers to LeVeque (2007) for a thorough review. ",
+        "bbox": [
+            174,
+            314,
+            823,
+            343
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 LINEAR PDES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            358,
+            313,
+            373
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Linear PDE solvers find functions that satisfy a (possibly infinite) set of linear differential equations. More formally, let $\\mathcal { F } = \\{ \\boldsymbol { u } : \\mathbb { R } ^ { k }  \\mathbb { R } \\}$ be the space of candidate functions, and $\\mathcal { A } : \\mathcal { F }  \\mathcal { F }$ be a linear operator; the goal is to find a function $u \\in { \\mathcal { F } }$ that satisfies a linear equation ${ \\mathcal { A } } u = { \\mathcal { E } }$ , where $\\boldsymbol { \\mathscr { f } }$ is another function $\\mathbb { R } ^ { k }  \\mathbb { R }$ given by our problem. Many PDEs fall into this framework. For example, heat diffusion satisfies $\\nabla ^ { 2 } u = \\ell$ (Poisson equation), where $\\begin{array} { r } { \\nabla ^ { 2 } = \\frac { \\partial ^ { 2 } } { \\partial x _ { 1 } ^ { 2 } } + \\cdot \\cdot \\cdot + \\frac { \\partial ^ { 2 } } { \\partial x _ { k } ^ { 2 } } } \\end{array}$ is the linear Laplace operator; $u$ maps spatial coordinates (e.g. in $\\mathbb { R } ^ { 3 }$ ) into its temperature, and $\\boldsymbol { \\mathscr { f } }$ maps spatial coordinates into the heat in/out flow. Solving this equation lets us know the stationary temperature given specified heat in/out flow. ",
+        "bbox": [
+            173,
+            383,
+            825,
+            505
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Usually the equation ${ \\mathcal { A } } u = { \\mathcal { E } }$ does not uniquely determine $_ { \\mathcal { W } }$ . For example, $u =$ constant for any constant is a solution to the equation $\\bar { \\nabla } ^ { 2 } \\bar { u _ { \\ } } = \\ 0$ . To ensure a unique solution we provide additional equations, called “boundary conditions”. Several boundary conditions arise very naturally in physical problems. A very common one is the Dirichlet boundary condition, where we pick some subset $\\mathcal { G } \\subset \\mathbf { \\mathbb { R } } ^ { k }$ and fix the values of the function on $\\mathcal { G }$ to some fixed value $\\mathcal { \\ell }$ , ",
+        "bbox": [
+            174,
+            511,
+            825,
+            582
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7e35f48aabc5044b010c5357d90f1bd840b624cf20fe388968614f19190b0ad2.jpg",
+        "text": "$$\nu ( x ) = \\ell ( x ) , { \\mathrm { ~ f o r ~ a l l ~ } } x \\in { \\mathcal { G } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            584,
+            593,
+            601
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where the function $\\boldsymbol { \\ell }$ is usually clear from the underlying physical problem. As in previous literature, we refer to $\\mathcal { G }$ as the geometry of the problem, and $\\mathcal { \\ell }$ as the boundary value. We refer to the pair $( \\mathcal G , \\mathcal { \\ell } )$ as the boundary condition. In this paper, we only consider linear PDEs and boundary conditions that have unique solutions. ",
+        "bbox": [
+            174,
+            602,
+            823,
+            659
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 FINITE DIFFERENCE METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            674,
+            421,
+            689
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Most real-world PDEs do not admit an analytic solution and must be solved numerically. The first step is to discretize the solution space $\\mathcal { F }$ from $\\mathbb { R } ^ { k } \\to \\mathbb { R }$ into $\\mathbb { D } ^ { k } \\to \\mathbb { R }$ , where $\\mathbb { D }$ is a discrete subset of $\\mathbb { R }$ . When the space is compact, it is discretized into an $n \\times n \\times n \\cdots$ ( $k$ many) uniform Cartesian grid with mesh width $h$ . Any function in $\\mathcal { F }$ is approximated by its value on the $n ^ { k }$ grid points. We denote the discretized function as a vector $u$ in $\\mathbb { R } ^ { \\bar { n ^ { k } } }$ . In this paper, we focus on 2D problems $k = 2 ,$ ), but the strategy applies to any dimension. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            787
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We discretize all three terms in the equation ${ \\mathcal { A } } u = { \\mathcal { E } }$ and boundary condition $( \\mathcal G , \\mathcal { \\ell } )$ . The PDE solution $_ { \\mathcal { W } }$ is discretized such that $u _ { i , j } = u ( x _ { i } , y _ { j } )$ corresponds to the value of $_ { \\mathcal { W } }$ at grid point $( x _ { i } , y _ { j } )$ . We can similarly discretize n of partial derivative operato $\\boldsymbol { \\mathscr { f } }$ and . Fo $\\boldsymbol { \\ell }$ . In linear PDEs, the linear operatxample, for the Poisson equation $\\mathcal { A }$ $\\begin{array} { r } { \\mathcal { A } = \\nabla ^ { 2 } = \\sum _ { i } \\frac { \\partial ^ { 2 } } { \\partial x _ { i } ^ { 2 } } } \\end{array}$ Therefore we can first discretize each partial derivative, then linearly combine the discretized partial derivatives to obtain a discretized $\\mathcal { A }$ . ",
+        "bbox": [
+            173,
+            794,
+            825,
+            886
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finite difference is a method that approximates partial derivatives in a discretized space, and as mesh width $h  0$ , the approximation approaches the true derivative. For example, $\\scriptstyle { \\frac { \\partial ^ { 2 } } { \\partial x ^ { 2 } } } u$ can be discretized in 2D as $\\begin{array} { r } { \\frac { \\partial ^ { 2 } } { \\partial x ^ { 2 } } u \\approx \\frac { 1 } { h ^ { 2 } } ( u _ { i - 1 , j } - 2 u _ { i , j } + u _ { i + 1 , j } ) } \\end{array}$ , the Laplace operator in 2D can be correspondingly approximated as: ",
+        "bbox": [
+            174,
+            892,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            101,
+            826,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7b3ede8956385d72516a843418937da4714e5f648adc1d5635a1dc1c11a92592.jpg",
+        "text": "$$\n\\nabla ^ { 2 } u = \\frac { \\partial ^ { 2 } u } { \\partial x ^ { 2 } } + \\frac { \\partial ^ { 2 } u } { \\partial y ^ { 2 } } \\approx \\frac { 1 } { h ^ { 2 } } ( u _ { i - 1 , j } + u _ { i + 1 , j } + u _ { i , j - 1 } + u _ { i , j + 1 } - 4 u _ { i , j } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            137,
+            738,
+            172
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "After discretization, we can rewrite ${ \\mathcal { A } } u = { \\mathcal { E } }$ as a linear matrix equation ",
+        "bbox": [
+            176,
+            184,
+            645,
+            200
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/29191fdd9fae6f3a8ff9f6d91db06d742515ce114305d21a090f87eab030a329.jpg",
+        "text": "$$\nA u = f\n$$",
+        "text_format": "latex",
+        "bbox": [
+            470,
+            205,
+            529,
+            222
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $u , f \\in \\mathbb { R } ^ { n ^ { 2 } }$ , and $A$ is a matrix in $\\mathbb { R } ^ { n ^ { 2 } \\times n ^ { 2 } }$ (these are $n ^ { 2 }$ dimensional because we focus on 2D problems). In many PDEs such as the Poisson and Helmholtz equation, $A$ is sparse, banded, and symmetric. ",
+        "bbox": [
+            174,
+            228,
+            825,
+            273
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 BOUNDARY CONDITION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            289,
+            382,
+            304
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We also need to include the boundary condition $u ( x ) = \\ell ( x )$ for all $x \\in { \\mathcal { G } }$ . If a discretized point $( x _ { i } , y _ { j } )$ belongs to $\\mathcal { G }$ , we need to fix the value of $u _ { i , j }$ to $b _ { i , j }$ . To achieve this, we first define $e \\in \\{ 0 , 1 \\} ^ { n ^ { 2 } }$ to be a vector of 0’s and 1’s, in which 0 indicates that the corresponding point belongs to $\\mathcal { G }$ . Then, we define a “reset” matrix $G = d i a g ( e )$ , a diagonal matrix $\\mathbb { R } ^ { n ^ { 2 } } \\to \\mathbb { R } ^ { n ^ { 2 } }$ such that ",
+        "bbox": [
+            173,
+            314,
+            825,
+            378
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/803cb590101bff864d1c78c0d7a667c8ccc856f5b2eb4f670af6cbcbc278437c.jpg",
+        "text": "$$\n( G u ) _ { i , j } = { \\left\\{ \\begin{array} { l l } { u _ { i , j } } & { ( x _ { i } , y _ { j } ) \\notin { \\mathcal { G } } } \\\\ { 0 } & { ( x _ { i } , y _ { j } ) \\in { \\mathcal { G } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            385,
+            604,
+            421
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Intuitively $G$ ”masks” every point in $\\mathcal { G }$ to 0. Similarly, $I - G$ can mask every point not in $\\mathcal { G }$ to 0. Note that the boundary values are fixed and do not need to satisfy $A u = f$ . Thus, the solution $u$ to the PDE under geometry $\\mathcal { G }$ should satisfy: ",
+        "bbox": [
+            173,
+            426,
+            826,
+            469
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/99c2b97af9560c84d53796897038905c94fc4066f80de8597cd00e4059549677.jpg",
+        "text": "$$\n\\begin{array} { c } { { G ( A u ) = G f } } \\\\ { { ( I - G ) u = ( I - G ) b } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            473,
+            575,
+            512
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The first equation ensures that the interior points (points not in $\\mathcal { G }$ ) satisfy $A u = f$ , and the second ensures that the boundary condition is satisfied. ",
+        "bbox": [
+            171,
+            515,
+            823,
+            544
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To summarize, $( \\mathcal { A } , \\mathcal { G } , \\ell , \\ell , n )$ is our PDE problem, and we first discretize the problem on an $n \\times n$ grid to obtain $( A , G , f , b , n )$ . Our objective is to obtain a solution $u$ that satisfies Eq. (4), i.e. $A u = f$ for the interior points and boundary condition $u _ { i , j } = b _ { i , j }$ , $\\forall ( x _ { i } , y _ { j } ) \\in \\mathcal { G }$ . ",
+        "bbox": [
+            173,
+            550,
+            825,
+            594
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.4 ITERATIVE SOLVERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            609,
+            357,
+            623
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A linear iterative solver is defined as a function that inputs the current proposed solution $u \\in \\mathbb { R } ^ { n ^ { 2 } }$ and outputs an updated solution $u ^ { \\prime }$ . Formally it is a function $\\Psi : \\mathbb { R } ^ { n ^ { 2 } }  \\mathbb { R } ^ { n ^ { 2 } }$ that can be expressed as ",
+        "bbox": [
+            174,
+            635,
+            825,
+            679
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/71f61be8fb65be34660bf4fcf58f4060367587a526d8773c8bd315756786d566.jpg",
+        "text": "$$\nu ^ { \\prime } = \\Psi ( u ) = T u + c\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            678,
+            571,
+            695
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $T$ is a constant update matrix and $c$ is a constant vector. For each iterator $\\Psi$ there may be special vectors $u ^ { * } \\in \\mathbb { R } ^ { n ^ { 2 } }$ that satisfy $\\boldsymbol { u } ^ { * } = \\boldsymbol { \\Psi } ( \\boldsymbol { u } ^ { * } )$ . These vectors are called fixed points. ",
+        "bbox": [
+            176,
+            698,
+            825,
+            729
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The iterative solver $\\Psi$ should map any initial $u ^ { 0 } \\in \\mathbb { R } ^ { n ^ { 2 } }$ to a correct solution of the PDE problem.   \nThis is formalized in the following theorem. ",
+        "bbox": [
+            176,
+            736,
+            823,
+            767
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 1 (Valid Iterator). An iterator $\\Psi$ is valid w.r.t. a PDE problem $( A , G , f , b , n )$ if it satisfies: ",
+        "bbox": [
+            173,
+            770,
+            820,
+            786
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "a) Convergence: There is a unique fixed point $u ^ { * }$ such that $\\Psi$ converges to $u ^ { * }$ from any initialization: $\\begin{array} { r } { \\forall u ^ { 0 } \\in \\mathbb { R } ^ { n ^ { 2 } } , \\operatorname* { l i m } _ { k \\to \\infty } \\Psi ^ { k } ( u ^ { 0 } ) = u ^ { * } } \\end{array}$ . ",
+        "bbox": [
+            205,
+            795,
+            825,
+            829
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$^ b$ ) Fixed Point: The fixed point $u ^ { * }$ is the solution to the linear system $A u = f$ under boundary condition $( G , b )$ . ",
+        "bbox": [
+            207,
+            837,
+            823,
+            867
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Convergence: Condition (a) in Definition 1 is satisfied if the matrix $T$ is convergent, i.e. $T ^ { k } \\to 0$ as $k  \\infty$ . It has been proven that $T$ is convergent if and only if the spectral radius $\\rho ( T ) < 1$ (Olver, 2008): ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. (Olver, 2008, Prop 7.25) For a linear iterator $\\Psi ( u ) = T u + c , \\Psi$ converges to a unique stable fixed point from any initialization if and only if the spectral radius $\\rho ( T ) < 1$ . ",
+        "bbox": [
+            171,
+            102,
+            825,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proof. See Appendix A. ",
+        "bbox": [
+            174,
+            147,
+            336,
+            162
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It is important to note that Condition (a) only depends on $T$ and not the constant $c$ . ",
+        "bbox": [
+            173,
+            176,
+            714,
+            193
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Fixed Point: Condition (b) in Definition 1 contains two requirements: satisfy $A u \\ : = \\ : f$ , and the boundary condition $( G , b )$ . To satisfy $A u = f$ a standard approach is to design $\\Psi$ by matrix splitting: split the matrix $A$ into $A = M - N$ ; rewrite $A u = f$ as $M u = N u + f$ (LeVeque, 2007). This naturally suggests the iterative update ",
+        "bbox": [
+            173,
+            198,
+            825,
+            256
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/14219c93d1f343cc5a0239b497ece5a11afc678de4d36991b21ee882de065a2a.jpg",
+        "text": "$$\nu ^ { \\prime } = M ^ { - 1 } N u + M ^ { - 1 } f\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            261,
+            573,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Because Eq. (6) is a rewrite of $A u = f$ , stationary points $u ^ { * }$ of Eq. (6) satisfy $A u ^ { * } = f$ . Clearly, the choices of $M$ and $N$ are arbitrary but crucial. From Theorem 1, we must choose $M$ such that the update converges. In addition, $\\dot { M ^ { - 1 } }$ must easy to compute (e.g., diagonal). ",
+        "bbox": [
+            174,
+            285,
+            825,
+            329
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally we also need to satisfy the boundary condition $( I - G ) u = ( I - G ) b$ in Eq.4. After each update in Eq. (6), the boundary condition could be violated. We use the “reset” operator defined in Eq. (3) to “reset” the values of $u _ { i , j }$ to $b _ { i , j }$ by $G u + ( I - G ) b$ . ",
+        "bbox": [
+            174,
+            334,
+            825,
+            378
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The final update rule becomes ",
+        "bbox": [
+            174,
+            383,
+            372,
+            398
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5bcd93e430d54e1f72e7b4149b49a12ee10abd7acdb48f3c5bafc87e8c3ae247.jpg",
+        "text": "$$\nu ^ { \\prime } = G ( M ^ { - 1 } N u + M ^ { - 1 } f ) + ( I - G ) b\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            405,
+            627,
+            422
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Despite the added complexity, it is still a linear update rule in the form of $u ^ { \\prime } = T u + c$ in Eq. (5): we have $T = G M ^ { - 1 } { \\dot { N } }$ and $\\dot { c } = G M ^ { - 1 } f + ( 1 - \\mathbf { \\dot { \\cal G } } ) b$ . As long as $M$ is a full rank diagonal matrix, fixed points of this equation satisfies Eq. (4). In other words, such a fixed point is a solution of the PDE problem $( A , G , f , b , n )$ . ",
+        "bbox": [
+            174,
+            429,
+            825,
+            486
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1. If $M$ is a full rank diagonal matrix, and $u ^ { * } \\in \\mathbb { R } ^ { n ^ { 2 } \\times n ^ { 2 } }$ satisfies Eq. (7), then $u ^ { * }$ satisfies Eq. (4). ",
+        "bbox": [
+            171,
+            489,
+            823,
+            522
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.4.1 JACOBI METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            536,
+            348,
+            550
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A simple but effective way to choose $M$ is the Jacobi method, which sets $M \\ : = \\ : I$ (a full rank diagonal matrix, as required by Proposition 1). For Poisson equations, this update rule has the following form, ",
+        "bbox": [
+            174,
+            559,
+            823,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a5437d3a6256f1d4397653b934135b43d7d2aa8ecf2fa3fe06e56f4b357ccb37.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\hat { u } _ { i , j } = \\displaystyle \\frac { 1 } { 4 } \\big ( u _ { i - 1 , j } + u _ { i + 1 , j } + u _ { i , j - 1 } + u _ { i , j + 1 } \\big ) + \\frac { h ^ { 2 } } { 4 } f _ { i , j } } } \\\\ { { u ^ { \\prime } = G \\hat { u } + ( 1 - G ) b } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            609,
+            679,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For Poisson equations and any geometry $G$ , the update matrix $T = G ( I - A )$ has spectral radius $\\rho ( T ) < 1$ (see Appendix B). In addition, by Proposition 1 any fixed point of the update rule Eq.(8,9) must satisfy Eq. (4). Both convergence and fixed point conditions from Definition 1 are satisfied: Jacobi iterator Eq.(8,9) is valid for any Poisson PDE problem. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            723
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In addition, each step of the Jacobi update can be implemented as a neural network layer, i.e., Eq. (8) can be efficiently implemented by convolving $u$ with kernel $\\left( \\begin{array} { c c c } { { 0 } } & { { 1 / 4 } } & { { 0 } } \\\\ { { 1 / 4 } } & { { 0 } } & { { 1 / 4 } } \\\\ { { 0 } } & { { 1 / 4 } } & { { 0 } } \\end{array} \\right)$ and adding $h ^ { 2 } f / 4$ . The “reset” step in Eq. (9) can also be implemented as multiplying $u$ with $\\mathbf { G }$ and adding the boundary values $( 1 - G ) b$ . ",
+        "bbox": [
+            173,
+            728,
+            825,
+            815
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.4.2 MULTIGRID METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            829,
+            379,
+            844
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The Jacobi method has very slow convergence rate (LeVeque, 2007). This is evident from the update rule, where the value at each grid point is only influenced by its immediate neighbors. To propagate information from one grid point to another, we need as many iterations as their distance on the grid. The key insight of the Multigrid method is to perform Jacobi updates on a downsampled (coarser) grid and then upsample the results. A common structure is the V-cycle (Briggs et al., 2000). In each ",
+        "bbox": [
+            173,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "V-cycle, there are $k$ downsampling layers followed by $k$ upsampling layers, and multiple Jacobi updates are performed at each resolution. The downsampling and upsampling operations are also called restriction and prolongation, and are often implemented using weighted restriction and linear interpolation respectively. The advantage of the multigrid method is clear: on a downsampled grid (by a factor of 2) with mesh width $2 h$ , information propagation is twice as fast, and each iteration requires only 1/4 operations compared to the original grid with mesh width $h$ . ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 LEARNING FAST AND PROVABLY CORRECT ITERATIVE PDE SOLVERS",
+        "text_level": 1,
+        "bbox": [
+            173,
+            207,
+            787,
+            223
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A PDE problem consists of five components $( \\mathcal { A } , \\mathcal { G } , \\ell , \\ell , n )$ . One is often interested in solving the same PDE class $\\mathcal { A }$ under varying $\\boldsymbol { \\mathscr { f } }$ , discretization $n$ , and boundary conditions $( \\mathcal G , \\mathcal { \\ell } )$ . For example, solving the Poisson equation under different boundary conditions (e.g., corresponding to different mechanical systems governed by the same physics). In this paper, we fix $\\mathcal { A }$ but vary ${ \\mathcal { G } } , { \\mathcal { f } } , { \\mathcal { k } } , n$ , and learn an iterator that solves a class of PDE problems governed by the same $\\mathcal { A }$ . For a discretized PDE problem $( A , G , f , b , n )$ and given a standard (hand designed) iterative solver $\\Psi$ , our goal is to improve upon $\\Psi$ and learn a solver $\\Phi$ that has (1) correct fixed point and (2) fast convergence (on average) on the class of problems of interest. We will proceed to parameterize a family of $\\Phi$ that satisfies (1) by design, and achieve (2) by optimization. ",
+        "bbox": [
+            173,
+            236,
+            825,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In practice, we can only train $\\Phi$ on a small number of problems $( A , f _ { i } , G _ { i } , b _ { i } , n _ { i } )$ . To be useful, $\\Phi$ must deliver good performance on every choice of $G , f , b$ , and different grid sizes $n$ . We show, theoretically and empirically, that our iterator family has good generalization properties: even if we train on a single problem $( A , G , f , b , n )$ , the iterator performs well on very different choices of $G , f , b$ , and grid size $n$ . For example, we train our iterator on a $6 4 \\times 6 4$ square domain, and test on a $2 5 6 \\times 2 5 6$ L-shaped domain (see Figure 1). ",
+        "bbox": [
+            174,
+            369,
+            825,
+            453
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            469,
+            318,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For a fixed PDE problem class $\\mathcal { A }$ , let $\\Psi$ be a standard linear iterative solver known to be valid. We will use more formal notation $\\Psi ( u ; G , f , b , n )$ as $\\Psi$ is a function of $u$ , but also depends on $G , f , b , n$ . Our assumption is that for any choice of $G , f , b , n$ (but fixed PDE class $\\mathcal { A }$ ), $\\Psi ( u ; G , f , b , n )$ is valid. We previously showed that Jacobi iterator Eq.(8,9) have this property for the Poisson PDE class. ",
+        "bbox": [
+            173,
+            494,
+            825,
+            551
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We design our new family of iterators $\\Phi _ { H } : \\mathbb { R } ^ { n ^ { 2 } }  \\mathbb { R } ^ { n ^ { 2 } }$ ",
+        "bbox": [
+            173,
+            559,
+            562,
+            575
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bae33c2e028190309f0bf6077e346545064990523d35384339c9cff9a42c8a58.jpg",
+        "text": "$$\n\\begin{array} { c } { { w = \\Psi ( u ; G , f , b , n ) - u } } \\\\ { { { } } } \\\\ { { \\Phi _ { H } ( u ; G , f , b , n ) = \\Psi ( u ; G , f , b , n ) + G H w } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            578,
+            651,
+            613
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $H$ is a learned linear operator (it satisfies $H 0 = 0$ ). The term $G H w$ can be interpreted as a correction term to $\\Psi ( u ; G , \\bar { f } , b , n )$ . When there is no confusion, we neglect the dependence on $G , f , b , n$ and denote as $\\Psi ( u )$ and $\\Phi _ { H } ( u )$ . ",
+        "bbox": [
+            176,
+            614,
+            823,
+            657
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\Phi _ { H }$ should have similar computation complexity as $\\Psi$ . Therefore, we choose $H$ to be a convolutional operator, which can be parameterized by a deep linear convolutional network. We will discuss the parameterization of $H$ in detail in Section 3.4; we first prove some parameterization independent properties. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            719
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The correct PDE solution is a fixed point of $\\Phi _ { H }$ by the following lemma: ",
+        "bbox": [
+            174,
+            726,
+            655,
+            741
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1. For any PDE problem $( A , G , f , b , n )$ and choice of $H$ , if $u ^ { * }$ is a fixed point of $\\Psi$ , it is $a$ fixed point of $\\Phi _ { H }$ in Eq. (10). ",
+        "bbox": [
+            173,
+            743,
+            823,
+            772
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proof. Based on the iterative rule in Eq. (10), if $u ^ { * }$ satisfies $\\Psi ( u ^ { * } ) = u ^ { * }$ then $w = \\Psi ( u ^ { * } ) - u ^ { * } = \\mathbf { 0 }$ Therefore, $\\Phi _ { H } ( u ^ { * } ) = \\Psi ( u ^ { * } ) + G H \\mathbf { 0 } = u ^ { * }$ . □ ",
+        "bbox": [
+            173,
+            786,
+            820,
+            816
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Moreover, the space of $\\Phi _ { H }$ subsumes the standard solver $\\Psi$ . If $H = 0$ , then $\\Phi _ { H } = \\Psi$ . Furthermore, denote $\\Psi ( u ) = T u + c$ , then if $H = T$ , then since $G T = T$ (see Eq. (7)), ",
+        "bbox": [
+            171,
+            830,
+            823,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c69fa8fdefab1fd1658f09da6544404bc337ce18a0c56ee31d3902c80d864978.jpg",
+        "text": "$$\n\\Phi _ { H } ( u ) = \\Psi ( u ) + G T ( \\Psi ( u ) - u ) = T \\Psi ( u ) + c = \\Psi ^ { 2 } ( u )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            862,
+            692,
+            880
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "which is equal to two iterations of $\\Psi$ . Computing $\\Psi$ requires one convolution $T$ , while computing $\\Phi _ { H }$ requires two convolutions: $T$ and $H$ . Therefore, if we choose $H = T$ , then $\\Phi _ { H }$ computes two iterations of $\\Psi$ with two convolutions: it is at least as efficient as the standard solver $\\Psi$ . ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 TRAINING AND GENERALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            450,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We train our iterator $\\Phi _ { H } ( u ; G , f , b , n )$ to converge quickly to the ground truth solution on a set $\\mathcal { D } = \\{ ( G _ { l } , f _ { l } , b _ { l } , n _ { l } ) \\} _ { l = 1 } ^ { M }$ of problem instances. For each instance, the ground truth solution $u ^ { * }$ is obtained from the existing solver $\\Psi$ . The learning objective is then ",
+        "bbox": [
+            173,
+            128,
+            823,
+            171
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b6ef15d39875fb878e2abe56300fbe4c7d7d571c749626ef2b7d734add213d3f.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { H } \\sum _ { ( G _ { l } , f _ { l } , b _ { l } , n _ { l } ) \\in \\mathcal { D } } \\mathbb { E } _ { u ^ { 0 } \\sim \\mathcal { N } ( 0 , 1 ) } \\| \\Phi _ { H } ^ { k } ( u ^ { 0 } ; G _ { l } , f _ { l } , b _ { l } , n _ { l } ) - u ^ { * } \\| _ { 2 } ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            175,
+            700,
+            210
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, we look for a matrix $H$ such that the corresponding iterator $\\Phi _ { H }$ will get us as close as possible to the solution in $k$ steps, starting from a random initialization $u ^ { 0 }$ sampled from a white Gaussian. $k$ in our experiments is uniformly chosen from [1, 20], similar to the procedure in (Song et al., 2017). Smaller $k$ is easier to learn with less steps to back-propagate through, while larger $k$ better approximates our test-time setting: we care about the final approximation accuracy after a given number of iteration steps. Combining smaller and larger $k$ performs best in practice. ",
+        "bbox": [
+            173,
+            219,
+            825,
+            305
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We show in the following theorem that there is a convex open set of $H$ that the learning algorithm can explore. To simplify the statement of the theorem, for any linear iterator $\\Phi ( u ) = \\mathbf { \\bar { \\mathit { T } } } u \\mathbf { \\bar { \\mathit { + } } } c$ we will refer to the spectral radius (norm) of $\\Phi$ as the spectral radius (norm) of $T$ . ",
+        "bbox": [
+            174,
+            310,
+            825,
+            353
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2. For fixed $G , f , b , n ,$ , the spectral norm of $\\Phi _ { H } ( u ; G , f , b , n )$ is a convex function of $H$ and the set of $H$ such that the spectral norm of $\\Phi _ { H } ( u ; G , f , b , n ) < 1$ is a convex open set. ",
+        "bbox": [
+            174,
+            356,
+            821,
+            385
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proof. See Appendix A. ",
+        "bbox": [
+            174,
+            400,
+            334,
+            415
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Therefore, to find an iterator with small spectral norm, the learning algorithm only has to explore a convex open set. Note that Theorem 2 holds for spectral norm, whereas validity requires small spectral radius in Theorem 1. Nonetheless, several important PDE problems (Poisson, Helmholtz, etc) are symmetric, so it is natural to use a symmetric iterator, which means that spectral norm is equal to spectral radius. In our experiments, we do not explicitly enforce symmetry, but we observe that the optimization finds symmetric iterators automatically. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            513
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For training, we use a single grid size $n$ , a single geometry $G$ , $f = 0$ , and a restricted set of boundary conditions $b$ . The geometry we use is a square domain shown in Figure 1a. Although we train on a single domain, the model has surprising generalization properties, which we show in the following: ",
+        "bbox": [
+            174,
+            520,
+            825,
+            563
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proposition 2. For fixed $A , G , n$ and fixed $H$ , if for some $f _ { 0 } , b _ { 0 } , \\Phi _ { H } ( u ; G , f _ { 0 } , b _ { 0 } , n )$ is valid for the PDE problem $( A , G , f _ { 0 } , b _ { 0 } , n )$ , then for all $f$ and $b$ , the iterator $\\Phi _ { H } ( u ; G , f , b , n )$ is valid for the PDE problem $( A , G , f , b , n )$ . ",
+        "bbox": [
+            176,
+            565,
+            825,
+            608
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proof. See Appendix A. ",
+        "bbox": [
+            174,
+            622,
+            334,
+            637
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The proposition states that we freely generalize to different $f$ and $b$ . There is no guarantee that we can generalize to different $G$ and $n$ . Generalization to different $G$ and $n$ has to be empirically verified: in our experiments, our learned iterator converges to the correct solution for a variety of grid sizes $n$ and geometries $G$ , even though it was only trained on one grid size and geometry. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            709
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Even when generalization fails, there is no risk of obtaining incorrect results. The iterator will simply fail to converge. This is because according to Lemma 1, fixed points of our new iterator is the same as the fixed point of hand designed iterator $\\Psi$ . Therefore if our iterator is convergent, it is valid. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            771
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 INTERPRETATION OF $H$ ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            786,
+            375,
+            803
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "What is $H$ trying to approximate? In this section we show that we are training our linear function $G H$ to approximate $\\bar { T ( I - T ) } ^ { - 1 }$ : if it were able to approximate $T ( I - T ) ^ { - 1 }$ perfectly, our iterator $\\Phi _ { H }$ will converge to the correct solution in a single iteration. ",
+        "bbox": [
+            174,
+            813,
+            825,
+            856
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Let the original update rule be $\\Psi ( u ) = T u + c$ , and the unknown ground truth solution be $u ^ { * }$ satisfying $u ^ { * } = T u ^ { * } + c$ . Let $r = u ^ { * } - u$ be the current error, and $e = u ^ { * } - \\Psi ( u )$ be the new error after applying one step of $\\Psi$ . They are related by ",
+        "bbox": [
+            174,
+            862,
+            825,
+            905
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d4d52a2d4171c3d4afb2577142533216ee7f546cb7b9647329f4651ae1782cc6.jpg",
+        "text": "$$\ne = u ^ { * } - \\Psi ( u ) = u ^ { * } - ( T u + c ) = T ( u ^ { * } - u ) = T r\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            907,
+            678,
+            925
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In addition, let $w = \\Psi ( u ) - u$ be the update $\\Psi$ makes. This is related to the current error $r$ by ",
+        "bbox": [
+            174,
+            103,
+            787,
+            118
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c7a8e535ba951b7af3a6966688906ea4766b00de6f3bfeda76e82e62925f6cf6.jpg",
+        "text": "$$\nw = \\Psi ( u ) - u = T u + c - u + ( u ^ { * } - T u ^ { * } - c ) = T ( u - u ^ { * } ) + ( u ^ { * } - u ) = ( I - T ) r\n$$",
+        "text_format": "latex",
+        "bbox": [
+            196,
+            125,
+            776,
+            142
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "From Eq. (10) we can observe that the linear operator $G H$ takes as input $\\Psi$ ’s update $w$ , and tries to approximate the error $e$ : $G H w \\approx e$ . If the approximation were perfect: $G H w = e$ , the iterator $\\Phi _ { H }$ would converge in a single iteration. Therefore, we are trying to find some linear operator $R$ , such that $R w = e$ . In fact, if we combine Eq. (13) and Eq. (14), we can observe that $T ( I - T ) ^ { - 1 }$ is (uniquely) the linear operator we are looking for ",
+        "bbox": [
+            173,
+            156,
+            825,
+            228
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b8363cd596d8015ef50782c83cea94263518f7c2d57c7d2230af11b9ff8944b.jpg",
+        "text": "$$\nT ( I - T ) ^ { - 1 } w = e\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            233,
+            562,
+            252
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $( I - T ) ^ { - 1 }$ exists because $\\rho ( T ) < 1$ , so all eigenvalues of $I - T$ must be strictly positive.   \nTherefore, we would like our linear function $G H$ to approximate $T ( I - T ) ^ { - 1 }$ . ",
+        "bbox": [
+            174,
+            258,
+            823,
+            287
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Note that $( I - T ) ^ { - 1 }$ is a dense matrix in general, meaning that it is impossible to exactly achieve $G H = T ( { \\cal I } - { \\cal T } ) \\dot { - } 1$ with a convolutional operator $H$ . However, the better $G H$ is able to approximate $T ( I - T ) ^ { - 1 }$ , the faster our iterator converges to the solution $u ^ { * }$ . ",
+        "bbox": [
+            174,
+            294,
+            825,
+            337
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 LINEAR DEEP NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            353,
+            397,
+            367
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In our iterator design, $H$ is a linear function parameterized by a linear deep network without nonlinearity or bias terms. Even though our objective in Eq. (12) is a non-linear function of the parameters of the deep network, this is not an issue in practice. In particular, Arora et al. (2018) observes that when modeling linear functions, deep networks can be faster to optimize with gradient descent compared to linear ones, despite non-convexity. ",
+        "bbox": [
+            173,
+            378,
+            825,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Even though a linear deep network can only represent a linear function, it has several advantages. On an $n \\times n$ grid, each convolution layer only requires $O ( n ^ { 2 } )$ computation and have a constant number of parameters, while a general linear function requires ${ \\dot { O ( n ^ { 4 } ) } }$ computation and have $O ( n ^ { 4 } )$ parameters. Stacking $d$ convolution layers allows us to parameterize complex linear functions with large receptive fields, while only requiring $O ( d n ^ { 2 } )$ computation and $O ( d ) ^ { \\top }$ parameters. We experiment on two types of linear deep networks: ",
+        "bbox": [
+            174,
+            457,
+            825,
+            540
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Conv model. We model $H$ as a network with $3 \\times 3$ convolutional layers without non-linearity or bias. We will refer to a model with $k$ layers as $^ { 6 6 } \\mathrm { C o n v } k ^ { \\prime }$ , e.g. Conv3 has 3 convolutional layers. ",
+        "bbox": [
+            174,
+            546,
+            823,
+            575
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "U-Net model. The Conv models suffer from the same problem as Jacobi: the receptive field grows only by 1 for each additional layer. To resolve this problem, we design the deep network counterpart of the Multigrid method. Instead of manually designing the sub-sampling $/$ super-sampling functions, we use a U-Net architecture (Ronneberger et al., 2015) to learn them from data. Because each layer reduces the grid size by half, and the $i$ -th layer of the U-Net only operates on $( 2 ^ { - i } n )$ -sized grids, the total computation is only increased by a factor of ",
+        "bbox": [
+            173,
+            582,
+            825,
+            666
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eaf0d861cf0e70a291b05207c40a6a68a681a79e8293172ef6167495075c0bdc.jpg",
+        "text": "$$\n1 + 1 / 4 + 1 / 1 6 + \\cdot \\cdot \\cdot < 4 / 3\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            672,
+            596,
+            690
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "compared to a two-layer convolution. The minimal overhead provides a very large improvement of convergence speed in our experiments. We will refer to Multigrid and U-Net models with $k$ sub-sampling layers as Multigrid $k$ and U-Netk, e.g. U-Net2 is a model with 2 sub-sampling layers. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            741
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            761,
+            326,
+            776
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 SETTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            792,
+            277,
+            808
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our method on the 2D Poisson equation with Dirichlet boundary conditions, $\\nabla ^ { 2 } u =$ $\\boldsymbol { \\mathscr { f } }$ . There exist several iterative solvers for the Poisson equation, including Jacobi, Gauss-Seidel, conjugate-gradient, and multigrid methods. We select the Jacobi method as our standard solver $\\Psi$ . ",
+        "bbox": [
+            174,
+            818,
+            823,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To reemphasize, our goal is to train a model on simple domains where the ground truth solutions can be easily obtained, and then evaluate its performance on different geometries and boundary conditions. Therefore, for training, we select the simplest Laplace equation, $\\nabla ^ { 2 } u = 0$ , on a square domain with boundary conditions such that each side is a random fixed value. Figure 1a shows an example of our training domain and its ground truth solution. This setting is also used in Farimani et al. (2017) and Sharma et al. (2018). ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/01bc31a70964c1ce2d6a0127cb1e7606a6068129d165c44803c821bc43907593.jpg",
+        "image_caption": [
+            "Figure 1: The ground truth solutions of examples in different settings. We only train our models on the square domain, and we test on all 4 settings. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            102,
+            823,
+            236
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            301,
+            823,
+            330
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For testing, we use larger grid sizes than training. For example, we test on $2 5 6 \\times 2 5 6$ grid for a model trained on $6 4 \\times 6 4$ grids. Moreover, we designed challenging geometries to test the generalization of our models. We test generalization on 4 different settings: (i) same geometry but larger grid, (ii) L-shape geometry, (iii) Cylinders geometry, and (iv) Poisson equation in same geometry, but $f \\neq 0$ . The two geometries are designed because the models were trained on square domains and have never seen sharp or curved boundaries. Examples of the 4 settings are shown in Figure 1. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            421
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            439,
+            305,
+            453
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As discussed in Section 2.4, the convergence rate of any linear iterator can be determined from the spectral radius $\\rho ( T )$ , which provides guarantees on convergence and convergence rate. However, a fair comparison should also consider the computation cost of $H$ . Thus, we evaluate the convergence rate by calculating the computation cost required for the error to drop below a certain threshold. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            521
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On GPU, the Jacobi iterator and our model can both be efficiently implemented as convolutional layers. Thus, we measure the computation cost by the number of convolutional layers. On CPU, each Jacobi iteration $\\begin{array} { r } { u _ { i , j } ^ { \\prime } = \\frac { 1 } { 4 } ( u _ { i - 1 , j } + u _ { i + 1 , j } + \\dot { u } _ { i , j - 1 } + u _ { i , j + 1 } ) } \\end{array}$ has 4 multiply-add operations, while a $3 \\times 3$ convolutional kernel requires 9 operations, so we measure the computation cost by the number of multiply-add operations. This metric is biased in favor of Jacobi because there is little practical reason to implement convolutions on CPU. Nonetheless, we report both metrics in our experiments. ",
+        "bbox": [
+            174,
+            527,
+            825,
+            626
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 CONV MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            643,
+            313,
+            657
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows results of the Conv model. The model is trained on a $1 6 \\times 1 6$ square domain, and tested on $6 4 \\times 6 4$ . For all settings, our models converge to the correct solution, and require less computation than Jacobi. The best model, Conv3, is $\\sim 5 \\times$ faster than Jacobi in terms of layers, and $\\sim 2 . 5 \\times$ faster in terms of multiply-add operations. ",
+        "bbox": [
+            174,
+            669,
+            825,
+            726
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As discussed in Section 3.2, if our iterator converges for a geometry, then it is guaranteed to converge to the correct solution for any $f$ and boundary values $b$ . The experiment results show that our model not only converges but also converges faster than the standard solver, even though it is only trained on a smaller square domain. ",
+        "bbox": [
+            176,
+            733,
+            825,
+            787
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 U-NET MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            806,
+            320,
+            820
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For the U-Net models, we compare them against Multigrid models with the same number of subsampling and smoothing layers. Therefore, our models have the same number of convolutional layers, and roughly $9 / 4$ times the number of operations compared to Multigrid. The model is trained on a $6 4 \\times 6 4$ square domain, and tested on $2 5 6 \\times 2 5 6$ . ",
+        "bbox": [
+            174,
+            832,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The bottom part of Table 1 shows the results of the U-Net model. Similar to the results of Conv models, our models outperforms Multigrid in all settings. Note that U-Net2 has lower computation cost compared with Multigrid2 than U-Net3 compared to Multigrid 3. This is because Multigrid2 is a relatively worse baseline. U-Net3 still converges faster than U-Net2. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/cfdd0234162ab0d28a088ba55207551dda239b5bd108849c176e7ddfe5fa69c3.jpg",
+        "table_caption": [
+            "Table 1: Comparisons between our models and the baseline solvers. The Conv models are compared with Jacobi, and the U-Net models are compared with Multigrid. The numbers are the ratio between the computation costs of our models and the baselines. None of the values are greater than 1, which means that all of our models achieve a speed up on every problem and both performance metric (convolutional layers and multiply-add operations). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Baseline</td><td>Square layers /ops</td><td>L-shape layers /ops</td><td>Cylinders layers /ops</td><td>Square-Poisson layers /ops</td></tr><tr><td>Conv1</td><td>Jacobi</td><td>0.432/0.702</td><td>0.432/0.702</td><td>0.432/0.702</td><td>0.431/0.701</td></tr><tr><td>Conv2</td><td>Jacobi</td><td>0.286 / 0.524</td><td>0.286 / 0.524</td><td>0.286 / 0.524</td><td>0.285 / 0.522</td></tr><tr><td>Conv3</td><td>Jacobi</td><td>0.219 / 0.424</td><td>0.219 / 0.423</td><td>0.220 / 0.426</td><td>0.217 /0.421</td></tr><tr><td>Conv4</td><td>Jacobi</td><td>0.224 /0.449</td><td>0.224 / 0.449</td><td>0.224 / 0.448</td><td>0.222 / 0.444</td></tr><tr><td>U-Net2</td><td>Multigrid2</td><td>0.091/0.205</td><td>0.090/0.203</td><td>0.091/0.204</td><td>0.079 / 0.178</td></tr><tr><td>U-Net3</td><td>Multigrid3</td><td>0.220 / 0.494</td><td>0.213 / 0.479</td><td>0.201 / 0.453</td><td>0.185 / 0.417</td></tr></table>",
+        "bbox": [
+            196,
+            188,
+            802,
+            309
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/c0b538377cbeba01e76b0a46a9018bd4d9a6cb98ad497d2921cd394020197279.jpg",
+        "image_caption": [
+            "Figure 2: CPU runtime comparisons of our model with the FEniCS model. Our method is comparable or faster than the best solver in FEniCS in all cases. When run on GPU, our solver provides an additional $3 0 \\times$ speedup. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            339,
+            825,
+            488
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            580,
+            823,
+            609
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 COMPARISON WITH FENICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            640,
+            411,
+            655
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The FEniCS package (Logg et al., 2012) provides a collection of tools with high-level Python and $\\mathrm { C } { + } { + }$ interfaces to solve differential equations. The open-source project is developed and maintained by a global community of scientists and software developers. Its extensive optimization over the years, including the support for parallel computation, has led to its widespread adaption in industry and academia (Alnæs et al., 2015). ",
+        "bbox": [
+            174,
+            672,
+            825,
+            742
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We measure the wall clock time of the FEniCS model and our model, run on the same hardware. The FEniCS model is set to be the minimal residual method with algebraic multigrid preconditioner, which we measure to be the fastest compared to other methods such as Jacobi or Incomplete LU factorization preconditioner. We ignore the time it takes to set up geometry and boundary conditions, and only consider the time the solver takes to solve the problem. We set the error threshold to be 1 percent of the initial error. For the square domain, we use a quadrilateral mesh. For the L-shape and cylinder domains, however, we let FEniCS generate the mesh automatically, while ensuring the number of mesh points to be similar. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            861
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 shows that our model is comparable or faster than FEniCS in wall clock time. These experiments are all done on CPU. Our model efficiently runs on GPU, while the fast but complex methods in FEniCS do not have efficient GPU implementations available. On GPU, we measure an additional $3 0 \\times$ speedup (on Tesla K80 GPU, compared with a 64-core CPU). ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            344,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Recently, there have been several works on applying deep learning to solve the Poisson equation. However, to the best of our knowledge, previous works used deep networks to directly generate the solution; they have no correctness guarantees and are not generalizable to arbitrary grid sizes and boundary conditions. Most related to our work are (Farimani et al., 2017) and (Sharma et al., 2018), which learn deep networks to output the solution of the 2D Laplace equation (a special case where $f = 0 ,$ ). (Farimani et al., 2017) trained a U-Net model that takes in the boundary condition as a 2D image and outputs the solution. The model is trained by L1 loss to the ground truth solution and an adversarial discriminator loss. (Sharma et al., 2018) also trained a U-net model but used a weakly-supervised loss. There are other related works that solved the Poisson equation in concrete physical problems. (Tang et al., 2017) solved for electric potential in 2D/3D space; (Tompson et al., 2017) solved for pressure fields for fluid simulation; (Zhang et al., 2018) solved particle simulation of a PN Junction. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            300
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "There are other works that solve other types of PDEs. For example, many studies aimed to use deep learning to accelerate and approximate fluid dynamics, governed by the Euler equation or the Navier-Stokes equations (Guo et al., 2016; Yang et al., 2016; Chu & Thuerey, 2017; Kutz, 2017). (Eismann et al., 2018) use Bayesian optimization to design shapes with reduced drag coefficients in laminar fluid flow. Other applications include solving the Schrodinger equation (Mills et al., 2017), turbulence modeling (Singh et al., 2017), and the American options and Black Scholes PDE (Sirignano & Spiliopoulos, 2018). A lot of these PDEs are nonlinear and may not have a standard linear iterative solver, which is a limitation to our current method since our model must be built on top of an existing linear solver to ensure correctness. We consider the extension to different PDEs as future work. ",
+        "bbox": [
+            174,
+            308,
+            825,
+            445
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            465,
+            318,
+            483
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We presented a method to learn an iterative solver for PDEs that improves on an existing standard solver. The correct solution is theoretically guaranteed to be the fixed point of our iterator. We show that our model, trained on simple domains, can generalize to different grid sizes, geometries and boundary conditions. It converges correctly and achieves significant speedups compared to standard solvers, including highly optimized ones implemented in FEniCS. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            568
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Martin S Alnæs, Jan Blechta, Johan Hake, August Johansson, Benjamin Kehlet, Anders Logg, Chris Richardson, Johannes Ring, Marie E Rognes, and Garth N Wells. The fenics project version 1.5. Archive of Numerical Software, 3(100):9–23, 2015. ",
+        "bbox": [
+            176,
+            126,
+            823,
+            169
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, Brendan Shillingford, and Nando De Freitas. Learning to learn by gradient descent by gradient descent. In Advances in Neural Information Processing Systems, 2016. ",
+        "bbox": [
+            176,
+            178,
+            823,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sanjeev Arora, Nadav Cohen, and Elad Hazan. On the optimization of deep networks: Implicit acceleration by overparameterization. arXiv preprint arXiv:1802.06509, 2018. ",
+        "bbox": [
+            173,
+            229,
+            823,
+            258
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "William L Briggs, Steve F McCormick, et al. A multigrid tutorial, volume 72. Siam, 2000. ",
+        "bbox": [
+            173,
+            267,
+            772,
+            284
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mengyu Chu and Nils Thuerey. Data-driven synthesis of smoke flows with cnn-based feature descriptors. ACM Transactions on Graphics (TOG), 36(4):69, 2017. ",
+        "bbox": [
+            171,
+            291,
+            823,
+            321
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephan Eismann, Daniel Levy, Rui Shu, Stefan Bartzsch, and Stefano Ermon. Bayesian optimization and attribute adjustment. In Proc. 34th Conference on Uncertainty in Artificial Intelligence, 2018. ",
+        "bbox": [
+            176,
+            329,
+            823,
+            372
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Amir Barati Farimani, Joseph Gomes, and Vijay S Pande. Deep learning the physics of transport phenomena. arXiv preprint arXiv:1709.02432, 2017. ",
+        "bbox": [
+            173,
+            382,
+            821,
+            411
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stanley P Frankel. Convergence rates of iterative treatments of partial differential equations. Mathematical Tables and Other Aids to Computation, 4(30):65–75, 1950. ",
+        "bbox": [
+            173,
+            420,
+            823,
+            449
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiaoxiao Guo, Wei Li, and Francesco Iorio. Convolutional neural networks for steady flow approximation. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 481–490, 2016. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            502
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tim Kraska, Alex Beutel, Ed H Chi, Jeffrey Dean, and Neoklis Polyzotis. The case for learned index structures. In Proceedings of the 2018 International Conference on Management of Data, pp. 489–504. ACM, 2018. ",
+        "bbox": [
+            174,
+            510,
+            825,
+            554
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "J Nathan Kutz. Deep learning in fluid dynamics. Journal of Fluid Mechanics, 814:1–4, 2017. ",
+        "bbox": [
+            173,
+            561,
+            785,
+            578
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Randall J LeVeque. Finite difference methods for ordinary and partial differential equations: steadystate and time-dependent problems, volume 98. Siam, 2007. ",
+        "bbox": [
+            173,
+            587,
+            821,
+            616
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Levy, Matthew D Hoffman, and Jascha Sohl-Dickstein. Generalizing hamiltonian monte carlo with neural networks. arXiv preprint arXiv:1711.09268, 2017. ",
+        "bbox": [
+            173,
+            625,
+            823,
+            655
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anders Logg, Kent-Andre Mardal, and Garth Wells. Automated solution of differential equations by the finite element method: The FEniCS book. Springer, 2012. ISBN 978-3-642-23098-1. doi: 10.1007/978-3-642-23099-8. ",
+        "bbox": [
+            173,
+            662,
+            823,
+            705
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kyle Mills, Michael Spanner, and Isaac Tamblyn. Deep learning and the schrodinger equation.¨ Physical Review A, 96(4):042113, 2017. ",
+        "bbox": [
+            168,
+            714,
+            823,
+            744
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peter J Olver. Numerical solution of ordinary differential equations. Numerical Analysis Lecture Notes, 2008. ",
+        "bbox": [
+            169,
+            752,
+            823,
+            782
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In International Conference on Medical image computing and computerassisted intervention, pp. 234–241. Springer, 2015. ",
+        "bbox": [
+            174,
+            790,
+            823,
+            834
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rishi Sharma, Amir Barati Farimani, Joe Gomes, Peter Eastman, and Vijay Pande. Weaklysupervised deep learning of heat transport via physics informed loss. arXiv preprint arXiv:1807.11374, 2018. ",
+        "bbox": [
+            173,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anand Pratap Singh, Shivaji Medida, and Karthik Duraisamy. Machine-learning-augmented predictive modeling of turbulent separated flows over airfoils. AIAA Journal, pp. 2215–2227, 2017. ",
+        "bbox": [
+            173,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Sirignano and Konstantinos Spiliopoulos. Dgm: A deep learning algorithm for solving partial differential equations. Journal of Computational Physics, 375:1339–1364, 2018. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jiaming Song, Shengjia Zhao, and Stefano Ermon. A-nice-mc: Adversarial training for mcmc. In Advances in Neural Information Processing Systems, 2017. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Wei Tang, Tao Shan, Xunwang Dang, Maokun Li, Fan Yang, Shenheng Xu, and Ji Wu. Study on a poisson’s equation solver based on deep learning technique. In IEEE Electrical Design of Advanced Packaging and Systems Symposium (EDAPS). IEEE, 2017. ",
+        "bbox": [
+            178,
+            178,
+            823,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Tompson, Kristofer Schlachter, Pablo Sprechmann, and Ken Perlin. Accelerating eulerian fluid simulation with convolutional networks. In International Conference on Machine Learning, 2017. ",
+        "bbox": [
+            174,
+            229,
+            823,
+            272
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Cheng Yang, Xubo Yang, and Xiangyun Xiao. Data-driven projection method in fluid simulation. Computer Animation and Virtual Worlds, 27(3-4):415–424, 2016. ",
+        "bbox": [
+            174,
+            281,
+            821,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhongyang Zhang, Ling Zhang, Ze Sun, Nicholas Erickson, Ryan From, and Jun Fan. Solving poisson’s equation using deep learning in particle simulation of pn junction. arXiv preprint arXiv:1810.10192, 2018. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            362
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A PROOFS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            277,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. For a linear iterator $\\Psi ( u ) = T u + c , \\Psi$ $\\Psi$ converges to a unique stable fixed point from any initialization if and only if the spectral radius $\\rho ( T ) < 1$ . ",
+        "bbox": [
+            171,
+            133,
+            823,
+            162
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof. Suppose $\\rho ( T ) < 1$ , then $( I { - } T ) ^ { - 1 }$ must exist because all eigenvalues of $I { - } T$ must be strictly positive. Let $u ^ { * } = ( I - T ) ^ { - 1 } c ;$ ; this $u ^ { * }$ is a stationary point of the iterator $\\Psi$ , i.e. $u ^ { * } = T u ^ { * } + c$ . For any initialization $u ^ { 0 }$ , let $\\boldsymbol { u } ^ { \\hat { k } } = \\boldsymbol { \\Psi } ^ { k } ( \\boldsymbol { u } ^ { 0 } )$ . The error $e ^ { k } = u ^ { * } - u ^ { k }$ satisfies ",
+        "bbox": [
+            173,
+            176,
+            825,
+            219
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2f9ad1ee64744c835b3a4640cda933a276d155d270e396b2fee4a67ed0d543dc.jpg",
+        "text": "$$\nT e ^ { k } = ( T u ^ { * } + c ) - ( T u ^ { k } + c ) = u ^ { * } - u ^ { k + 1 } = e ^ { k + 1 } \\Rightarrow e ^ { k } = T ^ { k } e ^ { 0 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            271,
+            237,
+            725,
+            256
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Since $\\rho ( T ) < 1$ , we know $T ^ { k }  0$ as $k  \\infty$ (LeVeque, 2007), which means the error $e ^ { k } \\to 0$ Therefore, $\\Psi$ converges to $u ^ { * }$ from any $u ^ { 0 }$ . ",
+        "bbox": [
+            174,
+            266,
+            821,
+            295
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Now suppose $\\rho ( T ) \\geq 1$ . Let $\\lambda _ { 1 }$ be the largest absolute eigenvalue where $\\rho ( T ) = | \\lambda _ { 1 } | \\geq 1$ , and $v _ { 1 }$ be its corresponding eigenvector. We select initialization $u ^ { 0 } = u ^ { * } + v _ { 1 }$ , then $e ^ { 0 } = v _ { 1 }$ . Because $| \\lambda _ { 1 } | \\ge 1$ , we have $| \\lambda _ { 1 } ^ { k } | \\geq \\bar { 1 }$ , then ",
+        "bbox": [
+            174,
+            301,
+            823,
+            343
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/52a49c4d9a7347b21121c703db45d44df09cdb76e436520a604859f3037158ba.jpg",
+        "text": "$$\nT ^ { k } e ^ { 0 } = \\lambda _ { 1 } ^ { k } v _ { 1 } \\triangleleft _ { k \\to \\infty } 0\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            342,
+            575,
+            361
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "However we know that under a different initialization $\\hat { u } ^ { 0 } = u ^ { * }$ , we have $\\hat { e } ^ { 0 } = 0$ , so $T ^ { k } \\hat { e } ^ { 0 } = 0$ . Therefore the iteration cannot converge to the same fixed point from different initializations $u ^ { 0 }$ and $\\hat { u } ^ { 0 }$ . ",
+        "bbox": [
+            173,
+            363,
+            825,
+            405
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1 If $M$ is a full rank diagonal matrix, and $u ^ { * } \\in \\mathbb { R } ^ { n ^ { 2 } \\times n ^ { 2 } }$ satisfies Eq. $( 7 )$ , then $u ^ { * }$ satisfies Eq. (4). ",
+        "bbox": [
+            169,
+            439,
+            823,
+            473
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof of Proposition $^ { l }$ . Let $u ^ { * }$ be a fixed point of Eq. (7) then ",
+        "bbox": [
+            173,
+            486,
+            583,
+            502
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/debbd84e9e23f608cb1cb343ef14bd17918edddf8884a6b1649084021d702989.jpg",
+        "text": "$$\nG u ^ { * } + ( I - G ) u ^ { * } = G ( M ^ { - 1 } N u ^ { * } + M ^ { - 1 } f ) + ( I - G ) b\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            507,
+            691,
+            525
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "This is equivalent to ",
+        "bbox": [
+            174,
+            531,
+            308,
+            546
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dca87171221d246e9200cb4ae82730285b7fdb438c11a67c7509f9622db4162a.jpg",
+        "text": "$$\n\\begin{array} { c } { { ( I - G ) u ^ { * } = ( I - G ) b } } \\\\ { { \\nonumber } } \\\\ { { G ( u ^ { * } - M ^ { - 1 } N u ^ { * } - M ^ { - 1 } f ) = 0 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            542,
+            640,
+            582
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The latter equation is equivalent to $G M ^ { - 1 } ( A u ^ { * } - f ) = 0$ . If $M$ is a full rank diagonal matrix, this implies $G ( A u ^ { * } - f ) = 0$ , which is $G A u ^ { * } = G f$ . Therefore, $u ^ { * }$ satisfies Eq.(4). □ ",
+        "bbox": [
+            171,
+            584,
+            825,
+            614
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2. For fixed $G , f , b , n$ , the spectral norm of $\\Phi _ { H } ( u ; G , f , b , n )$ is a convex function of $H$ , and the set of $H$ such that the spectral norm of $\\Phi _ { H } ( u ; G , f , b , n ) < 1$ is a convex open set. ",
+        "bbox": [
+            171,
+            628,
+            823,
+            659
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof. As before, denote $\\Psi ( u ) = T u + c$ . Observe that ",
+        "bbox": [
+            173,
+            672,
+            542,
+            689
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7217d437cd821de439d6acd61d64c18cd7041c59155f6f1cc167835d92a4c574.jpg",
+        "text": "$$\n\\Phi _ { H } ( u ; G , f , b , n ) = T u + c + G H ( T u + c - u ) = ( T + G H T - G H ) u + G H c + c T ( T + G H T - G H ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            200,
+            694,
+            771,
+            712
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The spectral norm $\\lVert \\cdot \\rVert _ { 2 }$ is convex with respect to its argument, and $( T + G H T - G H )$ is linear in $H$ . Thus, $\\| T + G H T - G H \\| _ { 2 }$ is convex in $H$ as well. Thus, under the condition that $\\| T +$ $G H T - G H \\vert _ { 2 } < 1$ , the set of $H$ must be convex because it is a sub-level set of the convex function $\\| T + G H T - G H \\| _ { 2 }$ . ",
+        "bbox": [
+            173,
+            724,
+            825,
+            782
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "To prove that it is open, observe that $\\lVert \\cdot \\rVert _ { 2 }$ is a continuous function, so $\\| T + G H T - G H \\| _ { 2 }$ is a continuous map from $H$ to the spectral radius of $\\Phi _ { H }$ . If we consider the set of $H$ such that $\\| T + G H T - G H \\| _ { 2 } < 1$ , this set is the preimage of $( - \\epsilon , 1 )$ for any $\\epsilon > 0$ . As $( - \\epsilon , 1 )$ is open, its preimage must be open. ",
+        "bbox": [
+            173,
+            787,
+            825,
+            844
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proposition 2. For fixed $A , G , n$ and fixed $H$ , if for some $f _ { 0 } , b _ { 0 } , \\Phi _ { H } ( u ; G , f _ { 0 } , b _ { 0 } , n )$ is valid for the PDE problem $( A , G , f _ { 0 } , b _ { 0 } , n )$ , then for all $f$ and $b$ , the iterator $\\Phi _ { H } ( u ; G , f , b , n )$ is valid for the PDE problem $( A , G , f , b , n )$ . ",
+        "bbox": [
+            174,
+            881,
+            825,
+            925
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof. From Theorem 1 and Lemma 1, our iterator is valid if and only if $\\rho ( T + G H T - G H ) < 1$ . The iterator $T + G H T - G H$ only depends on $A , G$ , and is independent of the constant $c$ in Eq. (18). Thus, the validity of the iterator is independent with $f$ and $b$ . Thus, if the iterator is valid for some $f _ { 0 }$ and $b _ { 0 }$ , then it is valid for any choice of $f$ and $b$ . ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B PROOF OF CONVERGENCE OF JACOBI METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            202,
+            601,
+            218
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In Section 2.4.1, we show that for Poisson equation, the update matrix $T = G ( I - A )$ . We now formally prove that $\\rho ( G ( I - A ) ) < 1$ for any $G$ . ",
+        "bbox": [
+            174,
+            232,
+            821,
+            262
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For any matrix $T$ , the spectral radius is bounded by the spectral norm: $\\rho ( T ) \\ \\leq \\ \\| T \\| _ { 2 }$ , and the equality holds if $T$ is symmetric. Since $( I - A )$ is a symmetric matrix, $\\rho ( I - A ) = \\| I - A \\| _ { 2 }$ . It has been proven that $\\rho ( I - A ) < 1$ (Frankel, 1950). Moreover, $\\| G \\| _ { 2 } = 1$ . Finally, matrix norms are sub-multiplicative, so ",
+        "bbox": [
+            173,
+            267,
+            825,
+            324
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fb5ac886c716724cbdfbcbae540585c1b07c76d8e36d340bc44463601270ee40.jpg",
+        "text": "$$\n\\rho ( T ) \\leq \\| G ( I - A ) \\| _ { 2 } \\leq \\| G \\| _ { 2 } \\| I - A \\| _ { 2 } < 1\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            330,
+            648,
+            348
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "$\\rho ( T ) < 1$ is true for any $G$ . Thus, the standard Jacobi method is valid for the Poisson equation under any geometry. ",
+        "bbox": [
+            174,
+            354,
+            823,
+            383
+        ],
+        "page_idx": 13
+    }
+]