Datasets:

zai-org
/

RPC-Bench

+# SPARSE NETWORKS FROM SCRATCH: FASTER TRAINING WITHOUT LOSING PERFORMANCE
+Anonymous authors Paper under double-blind review
+# ABSTRACT
+We demonstrate the possibility of what we call sparse learning: accelerated training of deep neural networks that maintain sparse weights throughout training while achieving dense performance levels. We accomplish this by developing sparse momentum, an algorithm which uses exponentially smoothed gradients (momentum) to identify layers and weights which reduce the error efficiently. Sparse momentum redistributes pruned weights across layers according to the mean momentum magnitude of each layer. Within a layer, sparse momentum grows weights according to the momentum magnitude of zero-valued weights. We demonstrate state-of-the-art sparse performance on MNIST, CIFAR-10, and ImageNet, decreasing the mean error by a relative $8 \%$ , $15 \%$ , and $6 \%$ compared to other sparse algorithms. Furthermore, we show that sparse momentum reliably reproduces dense performance levels while providing up to $5 . 6 1 \mathrm { x }$ faster training. In our analysis, ablations show that the benefits of momentum redistribution and growth increase with the depth and size of the network.
+# 1 INTRODUCTION
+Current state-of-the-art neural networks need extensive computational resources to be trained and can have capacities of close to one billion connections between neurons (Vaswani et al., 2017; Devlin et al., 2018; Child et al., 2019). One solution that nature found to improve neural network scaling is to use sparsity: the more neurons a brain has, the fewer connections neurons make with each other (Herculano-Houzel et al., 2010). Similarly, for deep neural networks, it has been shown that sparse weight configurations exist which train faster and achieve the same errors as dense networks (Frankle and Carbin, 2019). However, currently, these sparse configurations are found by starting from a dense network, which is pruned and re-trained repeatedly – an expensive procedure.
+In this work, we demonstrate the possibility of training sparse networks that rival the performance of their dense counterparts with a single training run – no re-training is required. We start with random initializations and maintain sparse weights throughout training while also speeding up the overall training time. We achieve this by developing sparse momentum, an algorithm which uses the exponentially smoothed gradient of network weights (momentum) as a measure of persistent errors to identify which layers are most efficient at reducing the error and which missing connections between neurons would reduce the error the most. Sparse momentum follows a cycle of (1) pruning weights with small magnitude, (2) redistributing weights across layers according to the mean momentum magnitude of existing weights, and (3) growing new weights to fill in missing connections which have the highest momentum magnitude.
+We compare the performance of sparse momentum to compression algorithms and recent methods that maintain sparse weights throughout training. We demonstrate state-of-the-art sparse performance on MNIST, CIFAR-10, and ImageNet-1k. For CIFAR-10, we determine the percentage of weights needed to reach dense performance levels and find that AlexNet, VGG16, and Wide Residual Networks need between $3 5 . 5 0 \%$ , $5 . 1 0 \%$ , and $20 \%$ weights to reach dense performance levels. We also estimate the overall speedups of training our sparse convolutional networks to dense performance levels on CIFAR-10 for optimal sparse convolution algorithms and naive dense convolution algorithms compared to dense baselines. For sparse convolution, we estimate speedups between $2 . 7 4 \mathrm { x }$ and $5 . 6 1 \mathrm { x }$ and for dense convolution speedups between $1 . 0 7 \mathrm { x }$ and $1 . 3 6 \mathrm { x }$ . In your analysis, ablations demonstrate that the momentum redistribution and growth components are increasingly important as networks get deeper and larger in size – both are critical for good ImageNet performance.
+# 2 RELATED WORK
+From Dense to Sparse Neural Networks: Work that focuses on creating sparse from dense neural networks has an extensive history. Earlier work focused on pruning via second-order derivatives (LeCun et al., 1989; Karnin, 1990; Hassibi and Stork, 1992) and heuristics which ensure efficient training of networks after pruning (Chauvin, 1988; Mozer and Smolensky, 1988; Ishikawa, 1996). Recent work is often motivated by the memory and computational benefits of sparse models that enable the deployment of deep neural networks on mobile and low-energy devices. A very influential paradigm has been the iterative (1) train-dense, (2) prune, (3) re-train cycle introduced by Han et al. (2015). Extensions to this work include: Compressing recurrent neural networks and other models (Narang et al., 2017; Zhu and Gupta, 2018; Dai et al., 2018), continuous pruning and re-training (Guo et al., 2016), joint loss/pruning-cost optimization (Carreira-Perpinan and Idelbayev, 2018), ´ layer-by-layer pruning (Dong et al., 2017), fast-switching growth-pruning cycles (Dai et al., 2017), and soft weight-sharing (Ullrich et al., 2017). These approaches often involve re-training phases which increase the training time. However, since the main goal of this line of work is a compressed model for mobile devices, it is desirable but not an important main goal to reduce the run-time of these procedures. This is contrary to our motivation. Despite the difference in motivation, we include many of these dense-to-sparse compression methods in our comparisons. Other compression algorithms include $L _ { 0 }$ regularization (Louizos et al., 2018), and Bayesian methods (Louizos et al., 2017; Molchanov et al., 2017). For further details, see the survey of Gale et al. (2019).
+Interpretation and Analysis of Sparse Neural Networks: Frankle and Carbin (2019) show that “winning lottery tickets” exist for deep neural networks – sparse initializations which reach similar predictive performance as dense networks and train just as fast. However, finding these winning lottery tickets is computationally expensive and involves multiple prune and re-train cycles starting from a dense network. Followup work concentrated on finding these configurations faster (Frankle et al., 2019; Zhou et al., 2019). In contrast, we reach dense performance levels with a sparse network from random initialization with a single training run while accelerating training.
+Sparse Neural Networks Throughout Training: Methods that maintain sparse weights throughout training through a prune-redistribute-regrowth cycle are most closely related to our work. Bellec et al. (2018) introduce DEEP-R, which takes a Bayesian perspective and performs sampling for prune and regrowth decisions – sampling sparse network configurations from a posterior. While theoretically rigorous, this approach is computationally expensive and challenging to apply to large networks and datasets. Sparse evolutionary training (SET) (Mocanu et al., 2018) simplifies prune-regrowth cycles by using heuristics: (1) prune the smallest and most negative weights, (2) grow new weights in random locations. Unlike our work, where many convolutional channels are empty and can be excluded from computation, growing weights randomly fills most convolutional channels and makes it challenging to harness computational speedups during training without specialized sparse algorithms. SET also does not include the cross-layer redistribution of weights which we find to be critical for good performance, as shown in our ablation study. The most closely related work to ours is Dynamic Sparse Reparameterization (DSR) by Mostafa and Wang (2019), which includes the full prune-redistribute-regrowth cycle. However, DSR requires some specific layers to be dense. Our method works in a fully sparse setting and is thus more generally applicable. More distantly related is Single-shot Network Pruning (SNIP) (Lee et al., 2019), which aims to find the best sparse network from a single pruning decision. The goal of SNIP is simplicity, while our goal is maximizing predictive and run-time performance. In our experiments, we compare against all four methods: DEEP-R, SET, DSR, and SNIP.
+# 3 SPARSE LEARNING
+We define sparse learning to be the training of deep neural networks which maintain sparsity throughout training while matching the predictive performance of dense neural networks. To achieve this, intuitively, we want to find the weights that reduce the error most effectively. This is challenging since most deep neural network can hold trillions of different combinations of sparse weights. Additionally, during training, as feature hierarchies are learned, efficient weights might change gradually from shallow to deep layers. How can we find good sparse configurations? In this work, we follow a divide-and-conquer strategy that is guided by computationally efficient heuristics. We divide sparse learning into the following sub-problems which can be tackled independently: (1) pruning weights, (2) redistribution of weights across layers, and (3) regrowing weights, as defined in more detail below.
+![](images/975651e113bf641bb08fd14d8ca3b02bff573688fd39a93af9523d766b61ae3c.jpg)
+Figure 1: Sparse Momentum is applied at the end of each epoch: (1) take the magnitude of the exponentially smoothed gradient (momentum) of each layer and normalize to 1; (2) for each layer, remove $p = 2 0 \%$ of the weights with the smallest magnitude; (3) across layers, redistribute the removed weights by adding weights to each layer proportionate to the momentum of each layer; within a layer, add weights starting from those with the largest momentum magnitude. Decay $p$ .
+# 3.1 SPARSE MOMENTUM
+We use the mean magnitude of momentum $\mathbf { M } _ { i }$ of existing weights $\mathbf { W } _ { i }$ in each layer $i$ to estimate how efficient the average weight in each layer is at reducing the overall error. Intuitively, we want to take weights from less efficient layers and redistribute them to weight-efficient layers. The sparse momentum algorithm is depicted in Figure 1. In this section, we first describe the intuition behind sparse momentum and then present a more detailed description of the algorithm.
+The gradient of the error with respect to a weight $\textstyle \frac { \partial \mathbf { E } } { \partial \mathbf { W } }$ yields the directions which reduce the error at the highest rate. However, if we use stochastic gradient descent, most weights of $\frac { \partial \mathbf { E } } { \partial \mathbf { W } }$ oscillate between small/large and negative/positive gradients with each mini-batch (Qian, 1999) – a good change for one mini-batch might be a bad change for another. We can reduce oscillations if we take the average gradient over time, thereby finding weights which reduce the error consistently. However, we want to value recent gradients, which are closer to the local minimum, more highly than the distant past. This can be achieved by exponentially smoothing $\frac { \partial \mathbf { E } } { \partial \mathbf { W } }$ – the momentum $\mathbf { M } _ { i }$ :
+$$
+\mathbf { M } _ { i } ^ { t + 1 } = \alpha \mathbf { M } _ { i } ^ { t } + ( 1 - \alpha ) \frac { \partial \mathbf { E } } { \partial \mathbf { W } _ { i } } ^ { t } ,
+$$
+where $\alpha$ is a smoothing factor, $\mathbf { M } _ { i }$ is the momentum for the weight $\mathbf { W } _ { i }$ in layer $i$ ; $\mathbf { M } _ { i }$ is initialized at $t = 0$ with 0.
+Momentum is efficient at accelerating the optimization of deep neural networks by identifying weights which reduce the error consistently. Similarly, the aggregated momentum of weights in each layer should reflect how good each layer is at reducing the error consistently. Additionally, the momentum of zero-valued weights – equivalent to missing weights in sparse networks – can be used to estimate how quickly the error would change if these weights would be included in a sparse network.
+The details of the full training procedure of our algorithm are shown in Algorithm 1. See Algorithm 2 in the Appendix for a more detailed, source-code-like description of sparse momentum.
+Algorithm 1: Sparse momentum algorithm.
+<table><tr><td colspan="2">Data: Layer i to k with: Momentum Mi,Weight Wi, binary Maski prune rate pi, density d 1 fori←O to k do</td></tr><tr><td colspan="2">Wi ← xavierInit(Wi)</td></tr><tr><td>2 3</td><td>Maski ← createMaskForWeight(Wi,d)</td></tr><tr><td>4</td><td>applyMask(Wi,Maski)</td></tr><tr><td>5 end</td><td></td></tr><tr><td colspan="2"></td></tr><tr><td colspan="2">6 for epoch ← O to numEpochs do</td></tr><tr><td>7</td><td>for j←O to numBatches do</td></tr><tr><td>8</td><td>batch ← getBatch(j) E</td></tr><tr><td>9</td><td>W = computeGradients(W, batch)</td></tr><tr><td>10</td><td>UpdateMomentum( 器）</td></tr><tr><td>11</td><td>UpdateWeights(M)</td></tr><tr><td>12</td><td>fori←O to k do</td></tr><tr><td>13</td><td>applyMask(Wi,Maski) end</td></tr><tr><td>14</td><td>end</td></tr><tr><td>15</td><td></td></tr><tr><td>16</td><td>totalMomentum ← getTotalMomentum(M)</td></tr><tr><td>17</td><td>totalPruned ← getTotalPrunedWeights(W, p)</td></tr><tr><td>18</td><td>fori←O to k do</td></tr><tr><td>19</td><td>mi ← getMomentumContribution(Mi,Maski,totalMomentum)</td></tr><tr><td>20</td><td>magnitudePruneWeight(Wi,Maski, Pi)</td></tr><tr><td>21</td><td>regrowWeights(Wi,Maski,mi · totalPruned)</td></tr><tr><td>22</td><td>Pi←decayPrunerate(pi)</td></tr><tr><td>23</td><td>applyMask(Wi,Maski)</td></tr><tr><td>24</td><td>end</td></tr><tr><td colspan="2">25 end</td></tr></table>
+Before training, we initialize the network with a certain sparsity $s$ : we initialize the network as usual and then remove a fraction of $s$ weights for each layer. We train the network normally and mask the weights after each gradient update to enforce sparsity. We apply sparse momentum after each epoch. We can break the sparse momentum into three major parts: (a) redistribution of weights, (b) pruning weights, (c) regrowing weights. In step (a), we we take the mean of the element-wise momentum momentum $m _ { i }$ agnitude of all layers . The resulting pr $i$ ortion is the momentum magnitude $\scriptstyle \sum _ { i = 0 } ^ { k } m _ { i }$
+removed weights multiplied by each layers momentum contribution: $\mathrm { R e g r o w } _ { i } =$ Total Removed · $m _ { i }$ . In step (b), we prune a proportion of $p$ (prune rate) of the weights with the lowest magnitude for each layer. In step (c), we regrow weights by enabling the gradient flow of zero-valued (missing) weights which have the largest momentum magnitude.
+Additionally, there are two edge-cases which we did not include in Algorithm 1 for clarity. (1) If we allocate more weights to be regrown than is possible for a specific layer, for example regrowing 100 weights for a layer of maximum 10 weights, we redistribute the excess number of weights equally among all other layers. (2) For some layers, our algorithm will converge in that the average weight in layer $i$ has much larger momentum magnitude than weights in other layers, but at the same time, this layer is dense and cannot grow further. We do not want to prune weights from such important layers. Thus, for these layers, we reduce the prune rate $p _ { i }$ proportional to the sparsity: $p _ { i } = \mathrm { { m i n } } ( p , \mathrm { { s p a r s i t y } } _ { i } )$ .
+After each epoch, we decay the prune rate in Algorithm 1 in the same way learning rates are decayed. We use a cosine decay schedule that anneals the prune rate to zero on the last epoch. See Appendix A.1 for an analysis on how decay schedule and starting prune rate affects training.
+# 4 EXPERIMENTAL SETUP
+For comparison, we follow three different experimental settings, one from Lee et al. (2019) and two settings follow Mostafa and Wang (2019): For MNIST (LeCun, 1998), we use a batch size of 100, decay the learning rate by a factor of 0.1 every 25000 mini-batches. For CIFAR-10 (Krizhevsky and Hinton, 2009), we use standard data augmentations (horizontal flip, and random crop with reflective padding), a batch size of 128, and decay the learning rate every 30000 mini-batches. We train for 100 and 250 epochs on MNIST and CIFAR-10, use a learning rate of 0.1, stochastic gradient descent with Nesterov momentum of $\alpha = 0 . 9$ , and we use a weight decay of 0.0005. We use a fixed $10 \%$ of the training data as the validation set and train on the remaining $90 \%$ . We evaluate the test set performance of our models on the last epoch. For all experiments on MNIST and CIFAR-10, we report the standard errors. Our sample size is generally between 10 and 12 experiments per method/architecture/sparsity level with different random seeds for each experiment.
+We use the modified network architectures of AlexNet, VGG16, and LeNet-5 as introduced by Lee et al. (2019). We consider two different variations of the experimental setup of Mostafa and Wang (2019) for ImageNet and CIFAR-10. The first follows their procedure closely, in that we run the networks in a partially dense setting where the first convolutional layer and downsampling convolutional layers are dense. Additionally, for CIFAR-10 the last fully connected layer is dense. In the second setting, we compare in a fully sparse setting – no layer is dense at the beginning of training. For the fully sparse setting we increase overall number of weights according to the extra parameters in the dense layers and distribute them equally among the network. The parameters in the dense layers make up $5 . 6 3 \%$ weights of the ResNet-50 network. We refer to these two settings as the partially dense and fully sparse settings.
+On ImageNet (Deng et al., 2009), we use ResNet-50 (He et al., 2016) with a stride of 2 for the $3 \mathrm { x } 3$ convolution in the bottleneck layers. We use a batch size of 256, input size of 224, momentum of $\alpha = 0 . 9$ , and weight decay of $1 \dot { 0 } ^ { - 4 }$ . We train for 100 epochs and report validation set performance after the last epoch. We report results for the fully sparse and the partially dense setting.
+For all experiments, we keep biases and batch normalization weights dense. We tuned the prune rate $p$ and momentum rate $\alpha$ searching the parameter space $\{ 0 . 2 , 0 . 3 , \bar { 0 } . 4 , 0 . 5 , 0 . 6 , 0 . 7 \}$ and $\{ 0 . 5 , 0 . 6 , 0 . 7$ $0 . 8 , 0 . 9 , 0 . 9 5 , 0 . 9 9 \}$ on MNIST and CIFAR-10 and found that $p = 0 . 2$ and $\alpha = 0 . 9$ work well for most architectures. We use this prune and momentum rate throughout all experiments.
+ImageNet experiments were run on $4 \mathbf { x }$ RTX 2080 Ti and all other experiments on individual GPUs.
+Our software builds on PyTorch (Paszke et al., 2017) and is a wrapper for PyTorch neural networks with a modular architecture for growth, redistribution, and pruning algorithms. Currently, no GPUaccelerated libraries that utilize sparse tensors exist, and as such we use masked weights to simulate sparse neural networks. Using our software, any PyTorch neural network can be adapted to be a sparse momentum network with less than 10 lines of code. We will open-source our software along with trained models and individual experimental results.1
+# 5 RESULTS
+Results in Figure 2 and Table 1 show a comparison with model compression methods. On MNIST, sparse momentum is the only method that provides consistent strong performance across both LeNet 300-100 and LeNet-5 Caffe models. Soft-weight sharing (Ullrich et al., 2017) and Layer-wise Brain Damage (Dong et al., 2017) are competitive with sparse momentum for one model, but underperforms for the other model. For $1 \%$ of weights, variational dropout is more effective – but this method also uses dropout for further regularization while we only use weight decay. We can see that sparse momentum achieves equal performance to the LeNet-5 Caffe dense baseline with $8 \%$ weights.
+On CIFAR-10 in Table 1, we can see that sparse momentum outperforms Single-shot Network Pruning (SNIP) for all models and can achieve the same performance level as a dense model for VGG16-D with just $5 \%$ of weights.
+![](images/9e005205b0e6994a85124aca20160b59043af33e15e75edf770b4775ce008edb.jpg)
+Figure 2: Comparisons against compression methods on MNIST with $9 5 \%$ confidence intervals.
+Figure 3 and Table 2 show comparisons of sparse learning methods on MNIST and CIFAR that follows the experimental procedure of Mostafa and Wang (2019) where some selected layers are dense. For LeNet 300-100 on MNIST, we can see that sparse momentum outperforms all other methods. For CIFAR-10, sparse momentum is better than dynamic sparse in 4 out of 5 cases. However, in general, the confidence intervals for most methods overlap – this particular setup for CIFAR-10 with specifically selected dense layers seems to be too easy to determine difference in performance between methods and we do not recommend this setup for future work. Table 2 shows that sparse momentum outperforms all other methods on ImageNet (ILSVRC2012) for the Top-1 accuracy measure. Dynamic sparse is better for the Top-5 accuracy with $20 \%$ weights. In the fully sparse setting, sparse momentum remains competitive and seems to find a weight distribution which works equally well for the $10 \%$ weights case. For $20 \%$ weights, the performance decreases slightly.
+![](images/9dd88284b32d232481d4be4d6a060b725bbcbf77df1fa6d28d3b3fe0b839a50c.jpg)
+Figure 3: Test set accuracy with $9 5 \%$ confidence intervals on MNIST and CIFAR at varying sparsity levels for LeNet 300-100 and WRN 28-2.
+# 5.1 SPEEDUPS AND WEIGHTS NEEDED FOR DENSE PERFORMANCE LEVELS
+We analyzed how many weights are needed to achieve dense performance for our networks on CIFAR-10 and how much faster would we able to train such a sparse network compared to a dense one. We do this analysis by increasing the number of weights by $5 \%$ until the sparse network trained with sparse momentum reaches a performance level that overlaps with a $9 5 \%$ confidence interval of the dense performance. We then measure the speedup of the model. For each network-density combination we perform ten training runs with different random seeds to calculate the mean test error and its standard error.
+To estimated the speedups that could be obtained using sparse momentum for these dense networks we follow two approaches: Theoretical speedups for sparse convolution algorithms which are proportional to reductions in FLOPS and practical speedups using dense convolutional algorithms which are proportional to empty convolutional channels. For our sparse convolution estimates, we calculate the FLOPS saved for each convolution operation throughout training as well as the runtime for each convolution. To receive the maximum speedups for sparse convolution, we then scale the runtime for each convolution operation by the FLOPS saved. While a fast sparse convolution algorithm for coarse block structures exist for GPUs (Gray et al., 2017), optimal sparse convolution algorithms for fine-grained patterns do not and need to be developed to enable these speedups.
+Table 1: CIFAR-10 test set error ( $\pm$ standard error) for dense baselines, Sparse Momentum and SNIP.
+<table><tr><td rowspan="2"></td><td colspan="3">Sparse Error (%)</td><td rowspan="2">Weights (%)</td></tr><tr><td>Dense Error (%)</td><td>SNIP</td><td>Momentum</td></tr><tr><td>Model AlexNet-s</td><td>12.95±0.056</td><td>14.99</td><td>14.27±0.123</td><td>10</td></tr><tr><td>AlexNet-b</td><td>12.85±0.068</td><td>14.50</td><td>13.56±0.094</td><td>10</td></tr><tr><td>VGG16-C</td><td>6.49±0.038</td><td>7.27</td><td>7.00±0.054</td><td>5</td></tr><tr><td>VGG16-D</td><td>6.59±0.050</td><td>7.09</td><td>6.69±0.049*</td><td>5</td></tr><tr><td>VGG16-like</td><td>6.50±0.054</td><td>8.00</td><td>7.00±0.077</td><td>3</td></tr><tr><td>WRN-16-8</td><td>4.57±0.022</td><td>6.63</td><td>5.62±0.056</td><td>5</td></tr><tr><td>WRN-16-10</td><td>4.45±0.040</td><td>6.43</td><td>5.24±0.052</td><td>5</td></tr><tr><td>WRN-22-8</td><td>4.26±0.032</td><td>5.85</td><td>4.93±0.056</td><td>5</td></tr></table>
+\* $9 5 \%$ confidence intervals overlap with dense model. Table 2: Results for ResNet-50 on ImageNet.
+<table><tr><td colspan="3"></td><td colspan="3">Accuracy (%)</td></tr><tr><td colspan="2">Model</td><td>Top-1</td><td>Top-5</td><td>Top-1</td><td>Top-5</td></tr><tr><td colspan="2">Dense ResNet-50 (He et al., 2016)</td><td>74.9</td><td>92.4</td><td>74.9</td><td>92.4</td></tr><tr><td colspan="2">Fully Sparse</td><td>10%</td><td>weights</td><td>20%</td><td>Weights</td></tr><tr><td rowspan="3">DeepR (Bellec et al., 2018) SET (Mocanu et al., 2018)</td><td>X</td><td>70.2</td><td>90.0</td><td>71.7</td><td>90.6</td></tr><tr><td>X</td><td>70.4</td><td>90.1</td><td>72.6</td><td>91.2</td></tr><tr><td>Dynamic Sparse (Mostafa and Wang,2019) X</td><td>71.6</td><td>90.5</td><td>73.3</td><td>92.4</td></tr><tr><td rowspan="2">Sparse momentum</td><td></td><td>72.3</td><td>91.0</td><td>74.2</td><td>91.9</td></tr><tr><td>×</td><td>72.3</td><td>91.0</td><td>73.8</td><td>91.8</td></tr></table>
+The second method measures practical speedups that can be obtained with naive, dense convolution algorithms which are available today. Dense convolution is unsuitable for the training of sparse networks but we include this measurement to highlight the algorithmic gap that exists to efficiently train sparse networks. For dense convolution algorithms, we estimate speedups as follows: If a convolutional channel consists entirely of zero-valued weights we can remove these channels from the computation without changing the outputs and obtain speedups. To receive the speedups for dense convolution we scale each convolution operation by the proportion of empty channels. Using these measures, we estimated the speedups for our models on CIFAR-10. The resulting speedups and dense performance levels can be seen in Table 3.
+We see that VGG16 networks can achieve dense performance with relatively few weights while AlexNet requires the most weights. Wide Residual Networks need an intermediate level of weights. Despite the large number of weights for AlexNet, sparse momentum still yields large speedups around $3 . 0 \mathbf { x }$ for sparse convolution. Sparse convolution speedups are particularly pronounced for Wide Residual Networks (WRN) with speedups as high as $5 . 6 1 \mathrm { x }$ . Dense convolution speedups are much lower and are mostly dependent on width, with wider networks receiving larger speedups. These results highlight the importance to develop optimized algorithms for sparse convolution.
+Beyond speedups, we also measured the overhead of our sparse momentum procedure to be equivalent of a slowdown to $0 . 9 7 3 \mathrm { x } \pm 0 . 0 2 9 \mathrm { x }$ compared to a dense baseline.
+Table 3: Dense performance equivalents and speedups for sparse networks on CIFAR-10.
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Weights (%)</td><td rowspan="2">Error(%)</td><td colspan="2"> Speedups</td></tr><tr><td>Dense Convolution (Empty Channels)</td><td>Sparse Convolution (FLOPS Reduction)</td></tr><tr><td>AlexNet-s</td><td>50</td><td>13.15±0.065</td><td>1.31x</td><td>3.01x</td></tr><tr><td>AlexNet-b</td><td>35</td><td>13.00±0.065</td><td>1.21x</td><td>2.74x</td></tr><tr><td>VGG16-C</td><td>10</td><td>6.64±0.040</td><td>1.32x</td><td>3.85x</td></tr><tr><td>VGG16-D</td><td>5</td><td>6.49±0.045</td><td>1.36x</td><td>3.51x</td></tr><tr><td>VGG16-like</td><td>5</td><td>6.46±0.036</td><td>1.32x</td><td>3.48x</td></tr><tr><td>WRN 16-8</td><td>30</td><td>4.72±0.051</td><td>1.07x</td><td>4.59x</td></tr><tr><td>WRN 16-10</td><td>25</td><td>4.56±0.037</td><td>1.07x</td><td>4.41x</td></tr><tr><td>WRN 22-8</td><td>20</td><td>4.40±0.037</td><td>1.21x</td><td>5.61x</td></tr></table>
+# 6 ANALYSIS
+# 6.1 ABLATION ANALYSIS
+Our method differs from previous methods like SET and Dynamic Sparse Reparameterization in two ways: (1) redistribution of weights and (2) growth of weights. To understand the performance contribution of these components, we perform ablations on CIFAR-10 for VGG16-D with $5 \%$ weights, MNIST for LeNet 300-100 and LeNet-5 Caffe with $5 \%$ weights, and ImageNet for ResNet-50 with $10 \%$ weights in the fully sparse setting. The results can be seen in Table 4.
+Redistribution: Redistributing weights according to the momentum magnitude becomes increasingly important the larger a network is as can be seen from the steady increases in error from the small LeNet 300-100 to the large ResNet-50 when no momentum redistribution is used. Increased test error is particularly pronounced for ImageNet where the Top-1 error increases by $3 . 4 2 \%$ to $9 . 7 1 \%$ if no redistribution is used.
+Momentum growth: Momentum growth improves performance over random growth by a large margin for ResNet-50 on ImageNet, but for smaller networks the combination of redistribution and random growth seems to be sufficient to find good weights. Random growth without redistribution, however, cannot find good weights. These results suggest that with increasing network size a random search strategy becomes inefficient and smarter growth algorithms are required for good performance.
+Table 4: Ablation analysis for different growth and redistribution algorithm combinations for LeNet 300-100 and LeNet-5 Caffe on MNIST, VGG16-D on CIFAR-10, and ResNet-50 on ImageNet.
+<table><tr><td rowspan="2">Redistribution</td><td rowspan="2">Growth</td><td colspan="4">Test error in %</td></tr><tr><td>LeNet 300-100</td><td>LeNet-5 Caffe</td><td>VGG16-D</td><td>ResNet-50</td></tr><tr><td>momentum</td><td>momentum</td><td>1.53±0.020</td><td>0.69±0.021</td><td>6.69±0.049</td><td>27.07</td></tr><tr><td>momentum</td><td>random</td><td>+0.07±0.022</td><td>-0.05±0.011</td><td>-0.19±0.040</td><td>+7.29</td></tr><tr><td>None</td><td> momentum</td><td>+0.01±0.018</td><td>+0.32±0.071</td><td>+1.54±0.101</td><td>+3.42</td></tr><tr><td>None</td><td>random</td><td>+0.11±0.020</td><td>+0.13±0.013</td><td>+1.49±0.147</td><td>+9.71</td></tr></table>
+# 7 CONCLUSION AND FUTURE WORK
+We presented our sparse learning algorithm, sparse momentum, which uses the mean magnitude of momentum to grow and redistribute weights. We showed that sparse momentum outperforms other sparse algorithms on MNIST, CIFAR-10, and ImageNet. Additionally, sparse momentum can rival dense neural network performance while accelerating training. Our analysis of speedups highlights the need for research into specialized sparse convolution and sparse matrix multiplication algorithms to enable the benefits of sparse networks.
+# REFERENCES
+Bellec, G., Kappel, D., Maass, W., and Legenstein, R. A. (2018). Deep rewiring: Training very sparse deep networks. CoRR, abs/1711.05136.
+Carreira-Perpinan, M. A. and Idelbayev, Y. (2018). learning-compression algorithms for neural net ´ pruning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 8532–8541.
+Chauvin, Y. (1988). A back-propagation algorithm with optimal use of hidden units. In NIPS.
+Child, R., Gray, S., Radford, A., and Sutskever, I. (2019). Generating long sequences with sparse transformers. CoRR, abs/1904.10509.
+Dai, X., Yin, H., and Jha, N. K. (2017). Nest: A neural network synthesis tool based on a grow-andprune paradigm. CoRR, abs/1711.02017.
+Dai, X., Yin, H., and Jha, N. K. (2018). Grow and prune compact, fast, and accurate lstms. CoRR, abs/1805.11797.
+Deng, J., Dong, W., Socher, R., Li, L.-J., Li, K., and Fei-Fei, L. (2009). Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pages 248–255. Ieee.
+Devlin, J., Chang, M.-W., Lee, K., and Toutanova, K. (2018). Bert: Pre-training of deep bidirectional transformers for language understanding. CoRR, abs/1810.04805.
+Dong, X., Chen, S., and Pan, S. J. (2017). Learning to prune deep neural networks via layer-wise optimal brain surgeon. In NIPS.
+Frankle, J. and Carbin, M. (2019). The lottery ticket hypothesis: Finding sparse, trainable neural networks. In ICLR 2019.
+Frankle, J., Dziugaite, G. K., Roy, D. M., and Carbin, M. (2019). The lottery ticket hypothesis at scale. CoRR, abs/1903.01611.
+Gale, T., Elsen, E., and Hooker, S. (2019). The state of sparsity in deep neural networks. CoRR, abs/1902.09574.
+Gray, S., Radford, A., and Kingma, D. P. (2017). Gpu kernels for block-sparse weights.
+Guo, Y., Yao, A., and Chen, Y. (2016). Dynamic network surgery for efficient dnns. In Advances In Neural Information Processing Systems, pages 1379–1387.
+Han, S., Pool, J., Tran, J., and Dally, W. (2015). Learning both weights and connections for efficient neural network. In Advances in neural information processing systems, pages 1135–1143.
+Hassibi, B. and Stork, D. G. (1992). Second order derivatives for network pruning: Optimal brain surgeon. In NIPS.
+He, K., Zhang, X., Ren, S., and Sun, J. (2016). Deep residual learning for image recognition. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 770–778.
+Herculano-Houzel, S., Mota, B., Wong, P., and Kaas, J. H. (2010). Connectivity-driven white matter scaling and folding in primate cerebral cortex. Proceedings of the National Academy of Sciences of the United States of America, 107 44:19008–13.
+Ishikawa, M. (1996). Structural learning with forgetting. Neural Networks, 9:509–521.
+Karnin, E. D. (1990). A simple procedure for pruning back-propagation trained neural networks. IEEE transactions on neural networks, 1 2:239–42.
+Krizhevsky, A. and Hinton, G. (2009). Learning multiple layers of features from tiny images. Technical report, Citeseer.
+LeCun, Y. (1998). Gradient-based learning applied to document recognition.
+LeCun, Y., Denker, J. S., and Solla, S. A. (1989). Optimal brain damage. In NIPS.
+Lee, N., Ajanthan, T., and Torr, P. H. S. (2019). Snip: Single-shot network pruning based on connection sensitivity. In ICLR 2019.
+Louizos, C., Ullrich, K., and Welling, M. (2017). Bayesian compression for deep learning. In Advances in Neural Information Processing Systems, pages 3288–3298.
+Louizos, C., Welling, M., and Kingma, D. P. (2018). Learning sparse neural networks through $l _ { 0 }$ regularization. CoRR, abs/1712.01312.
+Mocanu, D. C., Mocanu, E., Stone, P., Nguyen, P. H., Gibescu, M., and Liotta, A. (2018). Scalable training of artificial neural networks with adaptive sparse connectivity inspired by network science. Nature communications, 9(1):2383.
+Molchanov, D., Ashukha, A., and Vetrov, D. P. (2017). Variational dropout sparsifies deep neural networks. In International Conference on MachineLearning (ICML).
+Mostafa, H. and Wang, X. (2019). Parameter efficient training of deep convolutional neural networks by dynamic sparse reparameterization. In International Conference on Machine Learning (ICML).
+Mozer, M. C. and Smolensky, P. (1988). Skeletonization: A technique for trimming the fat from a network via relevance assessment. In NIPS.
+Narang, S., Diamos, G. F., Sengupta, S., and Elsen, E. (2017). Exploring sparsity in recurrent neural networks. CoRR, abs/1704.05119.
+Paszke, A., Gross, S., Chintala, S., Chanan, G., Yang, E., DeVito, Z., Lin, Z., Desmaison, A., Antiga, L., and Lerer, A. (2017). Automatic differentiation in pytorch.
+Qian, N. (1999). On the momentum term in gradient descent learning algorithms. Neural networks : the official journal of the International Neural Network Society, 12 1:145–151.
+Simonyan, K., Vedaldi, A., and Zisserman, A. (2013). Deep inside convolutional networks: Visualising image classification models and saliency maps. CoRR, abs/1312.6034.
+Springenberg, J. T., Dosovitskiy, A., Brox, T., and Riedmiller, M. A. (2014). Striving for simplicity: The all convolutional net. CoRR, abs/1412.6806.
+Ullrich, K., Meeds, E., and Welling, M. (2017). Soft weight-sharing for neural network compression. CoRR, abs/1702.04008.
+Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł., and Polosukhin, I. (2017). Attention is all you need. In Advances in neural information processing systems, pages 5998–6008.
+Zeiler, M. D. and Fergus, R. (2014). Visualizing and understanding convolutional networks. In ECCV.
+Zhou, H., Lan, J., Liu, R., and Yosinski, J. (2019). Deconstructing lottery tickets: Zeros, signs, and the supermask. arXiv preprint arXiv:1905.01067.
+Zhu, M. and Gupta, S. (2018). To prune, or not to prune: Exploring the efficacy of pruning for model compression. CoRR, abs/1710.01878.
+# A APPENDIX
+# A.1 SENSITIVITY ANALYSIS
+Sparse momentum depends on two hyperparameters: Prune rate and momentum. In this section, we study the sensitivity of the accuracy of our models as we vary the prune rate and momentum. Since momentum parameter has an additional effect on the optimization procedure, we run control experiments for fully dense networks thus disentangling the difference in accuracy accounted by our sparse momentum procedure.
+We run experiments for VGG-D and AlexNet-s with $5 \%$ and $10 \%$ weights on CIFAR-10. Results can be seen in Figure 4. We see that sparse momentum is highly robust to the choice of prune rate with results barely deviating when the prune rate is in the interval between 0.2 to 0.4. However, we can see a gradual linear trend that indicates that smaller prune rates work slightly better than larger ones. Cosine and linear prune rate annealing schedules do equally well. For momentum, confidence intervals for values between 0.7 and 0.9 overlap indicating that our procedure is robust to the choice of the momentum parameter. Sparse momentum is more sensitive to low momentum values $( \le 0 . 6 )$ while it is less sensitive for large momentum values (0.95) compared to a dense control. Additionally, we test the null hypothesis that sparse momentum is equally sensitive to deviations from a momentum parameter value of 0.9 as a dense control. The normality assumption was violated and data transformations did not help. Thus we use the non-parametric Wilcoxon Signed-rank Test. We find no evidence that sparse momentum is more sensitive to the momentum parameter than a dense control, $W ( 1 6 ) = 2 2 . 0 , p = 0 . 5 8$ . Overall, we conclude that sparse momentum is highly robust to deviations of the pruning schedule and the momentum and prune rate parameters.
+![](images/7117fc64f9af6e4603deca5ce68e941dd833601ab85ffdf8166fe5180fae3c84.jpg)
+Figure 4: Parameter sensitivity analysis for prune rate and momentum with $9 5 \%$ confidence intervals.
+B ADDITIONAL ANALYSIS
+# B.1 DENSE VS SPARSE FEATURES
+Are there differences between feature representations learned by dense and sparse networks? The answer to this question can help with the design of sparse learning algorithms and sparse architectures. In this section, we look at the features of dense and sparse networks and how specialized these features are for certain classes. We test difference between sparse and dense network features statistically.
+For feature visualization, it is common to backpropagate activity to the inputs to be able to visualize what these activities represent (Simonyan et al., 2013; Zeiler and Fergus, 2014; Springenberg et al., 2014). However, in our case, we are more interested in the overall distribution of features for each layer within our network, and as such we want to look at the magnitude of the activity in a channel since – unlike feature visualization – we are not just interested in feature detectors but also discriminators. For example, a face detector would induce positive activity for a ‘person’ class but might produce negative activity for a ‘mushroom’ class. Both kinds of activity are useful.
+With this reasoning, we develop the following convolutional channel-activation analysis: (1) pass the entire training set through the network and aggregate the magnitude of the activation in each convolutional channel separately for each class; (2) normalize across classes to receive for each channel the proportion of activation which is due to each class; (3) look at the maximum proportion of each channel as a measure of class specialization: a maximum proportion of $1 / N _ { c }$ where $N _ { c }$ is the number of classes indicates that the channel is equally active for all classes in the training set. The higher the proportion deviates from this value, the more is a channel specialized for a particular class.
+We obtain results for AlexNet-s, VGG16-D, and WRN 28-2 on CIFAR-10 and use as many weights as needed to reach dense performance levels. We then test the null hypothesis, that there are no differences in class specialization between features from sparse networks and dense networks. Equal variance assumptions was violated for VGG-D and normality was violated for WRN-28-2, while all assumptions hold for AlexNet-s. For consistency reasons we perform non-parametric Kruskal-Wallis one-way analysis of variance tests for all networks. For AlexNet-s, we find some evidence that features of sparse networks have lower class specialization compared to dense networks $\chi ^ { 2 } ( 5 ) = 4 . 4 3 , p = 0 . 0 3 \bar { 5 }$ , for VGG-D and WRN-28-2 we find strong evidence that features of sparse networks have lower class specialization than dense networks $\bar { \chi } ^ { 2 } ( 1 3 ) = 2 8 . 1 , p < 0 . 0 0 1$ , $\bar { \chi ^ { 2 } } ( 1 2 ) = 3 6 . 2 , p < 0 . 0 0 1$ . Thus we reject the null hypothesis. These results increase our confidence that sparse networks learn features which have lower class specialization than dense networks.
+Plots of the distributions of sparse vs. dense features for AlexNet-s, VGG16-D, and WRN 28-2 on CIFAR-10 in Figure 5. These plots were selected to highlight the difference in distribution in the first layers and last layers of each network. We see the convolutional channels in sparse networks have lower class-specialization indicating they learn features which are useful for a broader range of classes compared to dense networks. This trend intensifies with depth.
+Overall, we conclude that sparse networks might be able to rival dense networks by learning more general features that have lower class specialization.
+# C FURTHER RESULTS
+# C.1 TUNED RESNET-50 ON IMAGENET
+We also tried a better version of the ResNet-50 in the fully sparse setting for which we use a cosine learning rate schedule, label smoothing of 0.9, and we warmup the learning rate. The results can be seen in Table 5.
+Table 5: Fully sparse ImageNet results.
+<table><tr><td rowspan="2">Model</td><td colspan="2">Accuracy (%)</td></tr><tr><td>Weights (%) Top-1</td><td>Top-5</td></tr><tr><td>Tuned ResNet-50</td><td>100</td><td>77.0 93.5</td></tr><tr><td rowspan="3">Sparse momentum</td><td>10</td><td>72.9 91.5</td></tr><tr><td>20</td><td>74.9 92.5</td></tr><tr><td>30</td><td>75.9 92.9</td></tr></table>
+# D DETAILED SPARSE MOMENTUM ALGORITHM
+For a detailed NumPy-style algorithmic description of sparse momentum see Algorithm 2.
+![](images/3f901c2978fb2659c764fa4bb466027b202c3cf82103c11c60169e22f18339dd.jpg)
+Figure 5: Dense vs sparse histograms of class-specialization for convolutional channels on CIFAR-10. A class-specialization of 0.5 indicates that $50 \%$ of the overall activity comes from a single class.
+Algorithm 2: Sparse momentum algorithm in NumPy notation. Data: Layer i to k with: Momentum $\mathbf { M } _ { i }$ , Weight $\overline { { \mathbf { W } _ { \mathbf { i } } } }$ , binary $\mathbf { M a s k } _ { i }$ ; prune rate $p$ 1 TotalMomentum $\gets 0$ , TotalNonzero $ 0$ $/ \star$ (a) Calculate mean momentum contributions of all layers. \*/ 2 for $i \gets 0$ to $k$ do 3 MeanMomentum $_ i $ mean(a $\mathbf { b s } ( \mathbf { M } _ { i } \left[ \mathbf { W } _ { i } \neq 0 \right] ) _ { . }$ ) 4 TotalMomentum $\gets$ TotalMomentum $^ +$ MeanMomentumi 5 $\mathrm { N o n } Z \mathrm { e r o } _ { i } = \mathrm { s u m } ( \mathbf { W } _ { i } \neq 0 )$ 6 TotalNonzero TotalNonzero + NonZeroi 7 end 8 for $i \gets 0$ to $k$ do 9 LayerContribution $_ { \cdot i } \gets$ MeanMomentumi/TotalMomentum 10 $p _ { i } \gets$ getPruneRate $( \mathbf { W } _ { i } , p )$ 11 weights by finding the NumRemoveth smallest weight. 12 end 13 for $i \gets 0$ to $k$ do 14 NumRemove $\mathbf { \Sigma } _ { i }  \mathrm { N o n Z e r o } _ { i } \cdot p$ 15 PruneThreshold $ \mathrm { s o r t } ( \mathrm { a b s } ( \mathbf W _ { i } [ \mathbf W _ { i } \neq 0 ] )$ ) [NumRemovei] 16 $\mathbf { M a s k } _ { i }$ $[ \mathbf { W } _ { i } <$ PruneThreshold] $ 0$ // Stop gradient flow. 17 $\mathbf { W } _ { i }$ $[ \mathbf { W } _ { i } <$ PruneThreshold] $\gets 0$ 18 end /\* (c) Enable gradient flow of weights with largest momentum magnitude. \*/ 19 for $i \gets 0$ to $k$ do 20 RegrowthThresh $\mathrm { \mathbf { \tau } _ { \mathrm { 1 } } } \mathbf { d } _ { i } \gets \mathrm { \mathbf { \mathrm { s o r t } } } ( \mathbf { \mathrm { a b s } } ( \mathbf { M } _ { i } \left[ \mathbf { W } _ { i } = = 0 \right] )$ ) [NumRegrowthi] 21 $\mathbf { Z } _ { i } = \mathbf { M } _ { i }$ · $\mathbf { W } _ { i } = = 0$ ) // Only consider the momentum of missing weights. 22 $\mathbf { M } \mathbf { a s } \mathbf { k } _ { i } \gets \mathbf { M } \mathbf { a s } \mathbf { k } _ { i }$ | ( $\mathbf { Z } _ { i } >$ RegrowthThreshold ) // | is the boolean OR operator 23 end 24 $p $ decayPruneRate(p) 25 applyMask()

parse/train/ByeSYa4KPS/ByeSYa4KPS_content_list.json ADDED Viewed

	@@ -0,0 +1,1206 @@

+[
+    {
+        "type": "text",
+        "text": "SPARSE NETWORKS FROM SCRATCH: FASTER TRAINING WITHOUT LOSING PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            815,
+            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": "We demonstrate the possibility of what we call sparse learning: accelerated training of deep neural networks that maintain sparse weights throughout training while achieving dense performance levels. We accomplish this by developing sparse momentum, an algorithm which uses exponentially smoothed gradients (momentum) to identify layers and weights which reduce the error efficiently. Sparse momentum redistributes pruned weights across layers according to the mean momentum magnitude of each layer. Within a layer, sparse momentum grows weights according to the momentum magnitude of zero-valued weights. We demonstrate state-of-the-art sparse performance on MNIST, CIFAR-10, and ImageNet, decreasing the mean error by a relative $8 \\%$ , $15 \\%$ , and $6 \\%$ compared to other sparse algorithms. Furthermore, we show that sparse momentum reliably reproduces dense performance levels while providing up to $5 . 6 1 \\mathrm { x }$ faster training. In our analysis, ablations show that the benefits of momentum redistribution and growth increase with the depth and size of the network. ",
+        "bbox": [
+            233,
+            267,
+            766,
+            460
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            487,
+            336,
+            502
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Current state-of-the-art neural networks need extensive computational resources to be trained and can have capacities of close to one billion connections between neurons (Vaswani et al., 2017; Devlin et al., 2018; Child et al., 2019). One solution that nature found to improve neural network scaling is to use sparsity: the more neurons a brain has, the fewer connections neurons make with each other (Herculano-Houzel et al., 2010). Similarly, for deep neural networks, it has been shown that sparse weight configurations exist which train faster and achieve the same errors as dense networks (Frankle and Carbin, 2019). However, currently, these sparse configurations are found by starting from a dense network, which is pruned and re-trained repeatedly – an expensive procedure. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            631
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we demonstrate the possibility of training sparse networks that rival the performance of their dense counterparts with a single training run – no re-training is required. We start with random initializations and maintain sparse weights throughout training while also speeding up the overall training time. We achieve this by developing sparse momentum, an algorithm which uses the exponentially smoothed gradient of network weights (momentum) as a measure of persistent errors to identify which layers are most efficient at reducing the error and which missing connections between neurons would reduce the error the most. Sparse momentum follows a cycle of (1) pruning weights with small magnitude, (2) redistributing weights across layers according to the mean momentum magnitude of existing weights, and (3) growing new weights to fill in missing connections which have the highest momentum magnitude. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            776
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We compare the performance of sparse momentum to compression algorithms and recent methods that maintain sparse weights throughout training. We demonstrate state-of-the-art sparse performance on MNIST, CIFAR-10, and ImageNet-1k. For CIFAR-10, we determine the percentage of weights needed to reach dense performance levels and find that AlexNet, VGG16, and Wide Residual Networks need between $3 5 . 5 0 \\%$ , $5 . 1 0 \\%$ , and $20 \\%$ weights to reach dense performance levels. We also estimate the overall speedups of training our sparse convolutional networks to dense performance levels on CIFAR-10 for optimal sparse convolution algorithms and naive dense convolution algorithms compared to dense baselines. For sparse convolution, we estimate speedups between $2 . 7 4 \\mathrm { x }$ and $5 . 6 1 \\mathrm { x }$ and for dense convolution speedups between $1 . 0 7 \\mathrm { x }$ and $1 . 3 6 \\mathrm { x }$ . In your analysis, ablations demonstrate that the momentum redistribution and growth components are increasingly important as networks get deeper and larger in size – both are critical for good ImageNet performance. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            909
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            151,
+            344,
+            167
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "From Dense to Sparse Neural Networks: Work that focuses on creating sparse from dense neural networks has an extensive history. Earlier work focused on pruning via second-order derivatives (LeCun et al., 1989; Karnin, 1990; Hassibi and Stork, 1992) and heuristics which ensure efficient training of networks after pruning (Chauvin, 1988; Mozer and Smolensky, 1988; Ishikawa, 1996). Recent work is often motivated by the memory and computational benefits of sparse models that enable the deployment of deep neural networks on mobile and low-energy devices. A very influential paradigm has been the iterative (1) train-dense, (2) prune, (3) re-train cycle introduced by Han et al. (2015). Extensions to this work include: Compressing recurrent neural networks and other models (Narang et al., 2017; Zhu and Gupta, 2018; Dai et al., 2018), continuous pruning and re-training (Guo et al., 2016), joint loss/pruning-cost optimization (Carreira-Perpinan and Idelbayev, 2018), ´ layer-by-layer pruning (Dong et al., 2017), fast-switching growth-pruning cycles (Dai et al., 2017), and soft weight-sharing (Ullrich et al., 2017). These approaches often involve re-training phases which increase the training time. However, since the main goal of this line of work is a compressed model for mobile devices, it is desirable but not an important main goal to reduce the run-time of these procedures. This is contrary to our motivation. Despite the difference in motivation, we include many of these dense-to-sparse compression methods in our comparisons. Other compression algorithms include $L _ { 0 }$ regularization (Louizos et al., 2018), and Bayesian methods (Louizos et al., 2017; Molchanov et al., 2017). For further details, see the survey of Gale et al. (2019). ",
+        "bbox": [
+            174,
+            184,
+            825,
+            434
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Interpretation and Analysis of Sparse Neural Networks: Frankle and Carbin (2019) show that “winning lottery tickets” exist for deep neural networks – sparse initializations which reach similar predictive performance as dense networks and train just as fast. However, finding these winning lottery tickets is computationally expensive and involves multiple prune and re-train cycles starting from a dense network. Followup work concentrated on finding these configurations faster (Frankle et al., 2019; Zhou et al., 2019). In contrast, we reach dense performance levels with a sparse network from random initialization with a single training run while accelerating training. ",
+        "bbox": [
+            173,
+            440,
+            825,
+            539
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Sparse Neural Networks Throughout Training: Methods that maintain sparse weights throughout training through a prune-redistribute-regrowth cycle are most closely related to our work. Bellec et al. (2018) introduce DEEP-R, which takes a Bayesian perspective and performs sampling for prune and regrowth decisions – sampling sparse network configurations from a posterior. While theoretically rigorous, this approach is computationally expensive and challenging to apply to large networks and datasets. Sparse evolutionary training (SET) (Mocanu et al., 2018) simplifies prune-regrowth cycles by using heuristics: (1) prune the smallest and most negative weights, (2) grow new weights in random locations. Unlike our work, where many convolutional channels are empty and can be excluded from computation, growing weights randomly fills most convolutional channels and makes it challenging to harness computational speedups during training without specialized sparse algorithms. SET also does not include the cross-layer redistribution of weights which we find to be critical for good performance, as shown in our ablation study. The most closely related work to ours is Dynamic Sparse Reparameterization (DSR) by Mostafa and Wang (2019), which includes the full prune-redistribute-regrowth cycle. However, DSR requires some specific layers to be dense. Our method works in a fully sparse setting and is thus more generally applicable. More distantly related is Single-shot Network Pruning (SNIP) (Lee et al., 2019), which aims to find the best sparse network from a single pruning decision. The goal of SNIP is simplicity, while our goal is maximizing predictive and run-time performance. In our experiments, we compare against all four methods: DEEP-R, SET, DSR, and SNIP. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            808
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 SPARSE LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            829,
+            364,
+            844
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We define sparse learning to be the training of deep neural networks which maintain sparsity throughout training while matching the predictive performance of dense neural networks. To achieve this, intuitively, we want to find the weights that reduce the error most effectively. This is challenging since most deep neural network can hold trillions of different combinations of sparse weights. Additionally, during training, as feature hierarchies are learned, efficient weights might change gradually from shallow to deep layers. How can we find good sparse configurations? In this work, we follow a divide-and-conquer strategy that is guided by computationally efficient heuristics. We divide sparse learning into the following sub-problems which can be tackled independently: (1) pruning weights, (2) redistribution of weights across layers, and (3) regrowing weights, as defined in more detail below. ",
+        "bbox": [
+            176,
+            861,
+            825,
+            916
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            826,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/975651e113bf641bb08fd14d8ca3b02bff573688fd39a93af9523d766b61ae3c.jpg",
+        "image_caption": [
+            "Figure 1: Sparse Momentum is applied at the end of each epoch: (1) take the magnitude of the exponentially smoothed gradient (momentum) of each layer and normalize to 1; (2) for each layer, remove $p = 2 0 \\%$ of the weights with the smallest magnitude; (3) across layers, redistribute the removed weights by adding weights to each layer proportionate to the momentum of each layer; within a layer, add weights starting from those with the largest momentum magnitude. Decay $p$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            185,
+            825,
+            425
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 SPARSE MOMENTUM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            534,
+            361,
+            547
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use the mean magnitude of momentum $\\mathbf { M } _ { i }$ of existing weights $\\mathbf { W } _ { i }$ in each layer $i$ to estimate how efficient the average weight in each layer is at reducing the overall error. Intuitively, we want to take weights from less efficient layers and redistribute them to weight-efficient layers. The sparse momentum algorithm is depicted in Figure 1. In this section, we first describe the intuition behind sparse momentum and then present a more detailed description of the algorithm. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            630
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The gradient of the error with respect to a weight $\\textstyle \\frac { \\partial \\mathbf { E } } { \\partial \\mathbf { W } }$ yields the directions which reduce the error at the highest rate. However, if we use stochastic gradient descent, most weights of $\\frac { \\partial \\mathbf { E } } { \\partial \\mathbf { W } }$ oscillate between small/large and negative/positive gradients with each mini-batch (Qian, 1999) – a good change for one mini-batch might be a bad change for another. We can reduce oscillations if we take the average gradient over time, thereby finding weights which reduce the error consistently. However, we want to value recent gradients, which are closer to the local minimum, more highly than the distant past. This can be achieved by exponentially smoothing $\\frac { \\partial \\mathbf { E } } { \\partial \\mathbf { W } }$ – the momentum $\\mathbf { M } _ { i }$ : ",
+        "bbox": [
+            173,
+            635,
+            825,
+            738
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d923773238639546dedfb8e6c264a2b9b155e9f488a4eab15c8f1553719b7454.jpg",
+        "text": "$$\n\\mathbf { M } _ { i } ^ { t + 1 } = \\alpha \\mathbf { M } _ { i } ^ { t } + ( 1 - \\alpha ) \\frac { \\partial \\mathbf { E } } { \\partial \\mathbf { W } _ { i } } ^ { t } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            744,
+            607,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha$ is a smoothing factor, $\\mathbf { M } _ { i }$ is the momentum for the weight $\\mathbf { W } _ { i }$ in layer $i$ ; $\\mathbf { M } _ { i }$ is initialized at $t = 0$ with 0. ",
+        "bbox": [
+            176,
+            784,
+            821,
+            811
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Momentum is efficient at accelerating the optimization of deep neural networks by identifying weights which reduce the error consistently. Similarly, the aggregated momentum of weights in each layer should reflect how good each layer is at reducing the error consistently. Additionally, the momentum of zero-valued weights – equivalent to missing weights in sparse networks – can be used to estimate how quickly the error would change if these weights would be included in a sparse network. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The details of the full training procedure of our algorithm are shown in Algorithm 1. See Algorithm 2 in the Appendix for a more detailed, source-code-like description of sparse momentum. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/84ea8419585d7953fa11f50dca69c2e13baed68f21aebe0b8e7a2e93df19b44f.jpg",
+        "table_caption": [
+            "Algorithm 1: Sparse momentum algorithm. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Data: Layer i to k with: Momentum Mi,Weight Wi, binary Maski prune rate pi, density d 1 fori←O to k do</td></tr><tr><td colspan=\"2\">Wi ← xavierInit(Wi)</td></tr><tr><td>2 3</td><td>Maski ← createMaskForWeight(Wi,d)</td></tr><tr><td>4</td><td>applyMask(Wi,Maski)</td></tr><tr><td>5 end</td><td></td></tr><tr><td colspan=\"2\"></td></tr><tr><td colspan=\"2\">6 for epoch ← O to numEpochs do</td></tr><tr><td>7</td><td>for j←O to numBatches do</td></tr><tr><td>8</td><td>batch ← getBatch(j) E</td></tr><tr><td>9</td><td>W = computeGradients(W, batch)</td></tr><tr><td>10</td><td>UpdateMomentum( 器）</td></tr><tr><td>11</td><td>UpdateWeights(M)</td></tr><tr><td>12</td><td>fori←O to k do</td></tr><tr><td>13</td><td>applyMask(Wi,Maski) end</td></tr><tr><td>14</td><td>end</td></tr><tr><td>15</td><td></td></tr><tr><td>16</td><td>totalMomentum ← getTotalMomentum(M)</td></tr><tr><td>17</td><td>totalPruned ← getTotalPrunedWeights(W, p)</td></tr><tr><td>18</td><td>fori←O to k do</td></tr><tr><td>19</td><td>mi ← getMomentumContribution(Mi,Maski,totalMomentum)</td></tr><tr><td>20</td><td>magnitudePruneWeight(Wi,Maski, Pi)</td></tr><tr><td>21</td><td>regrowWeights(Wi,Maski,mi · totalPruned)</td></tr><tr><td>22</td><td>Pi←decayPrunerate(pi)</td></tr><tr><td>23</td><td>applyMask(Wi,Maski)</td></tr><tr><td>24</td><td>end</td></tr><tr><td colspan=\"2\">25 end</td></tr></table>",
+        "bbox": [
+            155,
+            123,
+            805,
+            501
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Before training, we initialize the network with a certain sparsity $s$ : we initialize the network as usual and then remove a fraction of $s$ weights for each layer. We train the network normally and mask the weights after each gradient update to enforce sparsity. We apply sparse momentum after each epoch. We can break the sparse momentum into three major parts: (a) redistribution of weights, (b) pruning weights, (c) regrowing weights. In step (a), we we take the mean of the element-wise momentum momentum $m _ { i }$ agnitude of all layers . The resulting pr $i$ ortion is the momentum magnitude $\\scriptstyle \\sum _ { i = 0 } ^ { k } m _ { i }$   \nremoved weights multiplied by each layers momentum contribution: $\\mathrm { R e g r o w } _ { i } =$ Total Removed · $m _ { i }$ . In step (b), we prune a proportion of $p$ (prune rate) of the weights with the lowest magnitude for each layer. In step (c), we regrow weights by enabling the gradient flow of zero-valued (missing) weights which have the largest momentum magnitude. ",
+        "bbox": [
+            173,
+            531,
+            826,
+            700
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Additionally, there are two edge-cases which we did not include in Algorithm 1 for clarity. (1) If we allocate more weights to be regrown than is possible for a specific layer, for example regrowing 100 weights for a layer of maximum 10 weights, we redistribute the excess number of weights equally among all other layers. (2) For some layers, our algorithm will converge in that the average weight in layer $i$ has much larger momentum magnitude than weights in other layers, but at the same time, this layer is dense and cannot grow further. We do not want to prune weights from such important layers. Thus, for these layers, we reduce the prune rate $p _ { i }$ proportional to the sparsity: $p _ { i } = \\mathrm { { m i n } } ( p , \\mathrm { { s p a r s i t y } } _ { i } )$ . ",
+        "bbox": [
+            174,
+            707,
+            825,
+            806
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "After each epoch, we decay the prune rate in Algorithm 1 in the same way learning rates are decayed. We use a cosine decay schedule that anneals the prune rate to zero on the last epoch. See Appendix A.1 for an analysis on how decay schedule and starting prune rate affects training. ",
+        "bbox": [
+            176,
+            813,
+            825,
+            854
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            398,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For comparison, we follow three different experimental settings, one from Lee et al. (2019) and two settings follow Mostafa and Wang (2019): For MNIST (LeCun, 1998), we use a batch size of 100, decay the learning rate by a factor of 0.1 every 25000 mini-batches. For CIFAR-10 (Krizhevsky and Hinton, 2009), we use standard data augmentations (horizontal flip, and random crop with reflective padding), a batch size of 128, and decay the learning rate every 30000 mini-batches. We train for 100 and 250 epochs on MNIST and CIFAR-10, use a learning rate of 0.1, stochastic gradient descent with Nesterov momentum of $\\alpha = 0 . 9$ , and we use a weight decay of 0.0005. We use a fixed $10 \\%$ of the training data as the validation set and train on the remaining $90 \\%$ . We evaluate the test set performance of our models on the last epoch. For all experiments on MNIST and CIFAR-10, we report the standard errors. Our sample size is generally between 10 and 12 experiments per method/architecture/sparsity level with different random seeds for each experiment. ",
+        "bbox": [
+            174,
+            135,
+            825,
+            287
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use the modified network architectures of AlexNet, VGG16, and LeNet-5 as introduced by Lee et al. (2019). We consider two different variations of the experimental setup of Mostafa and Wang (2019) for ImageNet and CIFAR-10. The first follows their procedure closely, in that we run the networks in a partially dense setting where the first convolutional layer and downsampling convolutional layers are dense. Additionally, for CIFAR-10 the last fully connected layer is dense. In the second setting, we compare in a fully sparse setting – no layer is dense at the beginning of training. For the fully sparse setting we increase overall number of weights according to the extra parameters in the dense layers and distribute them equally among the network. The parameters in the dense layers make up $5 . 6 3 \\%$ weights of the ResNet-50 network. We refer to these two settings as the partially dense and fully sparse settings. ",
+        "bbox": [
+            174,
+            294,
+            825,
+            433
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "On ImageNet (Deng et al., 2009), we use ResNet-50 (He et al., 2016) with a stride of 2 for the $3 \\mathrm { x } 3$ convolution in the bottleneck layers. We use a batch size of 256, input size of 224, momentum of $\\alpha = 0 . 9$ , and weight decay of $1 \\dot { 0 } ^ { - 4 }$ . We train for 100 epochs and report validation set performance after the last epoch. We report results for the fully sparse and the partially dense setting. ",
+        "bbox": [
+            174,
+            439,
+            825,
+            496
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For all experiments, we keep biases and batch normalization weights dense. We tuned the prune rate $p$ and momentum rate $\\alpha$ searching the parameter space $\\{ 0 . 2 , 0 . 3 , \\bar { 0 } . 4 , 0 . 5 , 0 . 6 , 0 . 7 \\}$ and $\\{ 0 . 5 , 0 . 6 , 0 . 7$ $0 . 8 , 0 . 9 , 0 . 9 5 , 0 . 9 9 \\}$ on MNIST and CIFAR-10 and found that $p = 0 . 2$ and $\\alpha = 0 . 9$ work well for most architectures. We use this prune and momentum rate throughout all experiments. ",
+        "bbox": [
+            174,
+            503,
+            825,
+            559
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "ImageNet experiments were run on $4 \\mathbf { x }$ RTX 2080 Ti and all other experiments on individual GPUs. ",
+        "bbox": [
+            173,
+            565,
+            823,
+            580
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our software builds on PyTorch (Paszke et al., 2017) and is a wrapper for PyTorch neural networks with a modular architecture for growth, redistribution, and pruning algorithms. Currently, no GPUaccelerated libraries that utilize sparse tensors exist, and as such we use masked weights to simulate sparse neural networks. Using our software, any PyTorch neural network can be adapted to be a sparse momentum network with less than 10 lines of code. We will open-source our software along with trained models and individual experimental results.1 ",
+        "bbox": [
+            174,
+            587,
+            825,
+            670
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            690,
+            281,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Results in Figure 2 and Table 1 show a comparison with model compression methods. On MNIST, sparse momentum is the only method that provides consistent strong performance across both LeNet 300-100 and LeNet-5 Caffe models. Soft-weight sharing (Ullrich et al., 2017) and Layer-wise Brain Damage (Dong et al., 2017) are competitive with sparse momentum for one model, but underperforms for the other model. For $1 \\%$ of weights, variational dropout is more effective – but this method also uses dropout for further regularization while we only use weight decay. We can see that sparse momentum achieves equal performance to the LeNet-5 Caffe dense baseline with $8 \\%$ weights. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            820
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "On CIFAR-10 in Table 1, we can see that sparse momentum outperforms Single-shot Network Pruning (SNIP) for all models and can achieve the same performance level as a dense model for VGG16-D with just $5 \\%$ of weights. ",
+        "bbox": [
+            176,
+            828,
+            823,
+            869
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/9e005205b0e6994a85124aca20160b59043af33e15e75edf770b4775ce008edb.jpg",
+        "image_caption": [
+            "Figure 2: Comparisons against compression methods on MNIST with $9 5 \\%$ confidence intervals. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            813,
+            290
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 and Table 2 show comparisons of sparse learning methods on MNIST and CIFAR that follows the experimental procedure of Mostafa and Wang (2019) where some selected layers are dense. For LeNet 300-100 on MNIST, we can see that sparse momentum outperforms all other methods. For CIFAR-10, sparse momentum is better than dynamic sparse in 4 out of 5 cases. However, in general, the confidence intervals for most methods overlap – this particular setup for CIFAR-10 with specifically selected dense layers seems to be too easy to determine difference in performance between methods and we do not recommend this setup for future work. Table 2 shows that sparse momentum outperforms all other methods on ImageNet (ILSVRC2012) for the Top-1 accuracy measure. Dynamic sparse is better for the Top-5 accuracy with $20 \\%$ weights. In the fully sparse setting, sparse momentum remains competitive and seems to find a weight distribution which works equally well for the $10 \\%$ weights case. For $20 \\%$ weights, the performance decreases slightly. ",
+        "bbox": [
+            173,
+            337,
+            825,
+            491
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/9dd88284b32d232481d4be4d6a060b725bbcbf77df1fa6d28d3b3fe0b839a50c.jpg",
+        "image_caption": [
+            "Figure 3: Test set accuracy with $9 5 \\%$ confidence intervals on MNIST and CIFAR at varying sparsity levels for LeNet 300-100 and WRN 28-2. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            502,
+            815,
+            691
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 SPEEDUPS AND WEIGHTS NEEDED FOR DENSE PERFORMANCE LEVELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            751,
+            712,
+            766
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We analyzed how many weights are needed to achieve dense performance for our networks on CIFAR-10 and how much faster would we able to train such a sparse network compared to a dense one. We do this analysis by increasing the number of weights by $5 \\%$ until the sparse network trained with sparse momentum reaches a performance level that overlaps with a $9 5 \\%$ confidence interval of the dense performance. We then measure the speedup of the model. For each network-density combination we perform ten training runs with different random seeds to calculate the mean test error and its standard error. ",
+        "bbox": [
+            173,
+            777,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To estimated the speedups that could be obtained using sparse momentum for these dense networks we follow two approaches: Theoretical speedups for sparse convolution algorithms which are proportional to reductions in FLOPS and practical speedups using dense convolutional algorithms which are proportional to empty convolutional channels. For our sparse convolution estimates, we calculate the FLOPS saved for each convolution operation throughout training as well as the runtime for each convolution. To receive the maximum speedups for sparse convolution, we then scale the runtime for each convolution operation by the FLOPS saved. While a fast sparse convolution algorithm for coarse block structures exist for GPUs (Gray et al., 2017), optimal sparse convolution algorithms for fine-grained patterns do not and need to be developed to enable these speedups. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/b7d4320ae9a6727fc4baf1e048755e25eb23692cb1889a49a1d9cc5ed4c96675.jpg",
+        "table_caption": [
+            "Table 1: CIFAR-10 test set error ( $\\pm$ standard error) for dense baselines, Sparse Momentum and SNIP. "
+        ],
+        "table_footnote": [
+            "\\* $9 5 \\%$ confidence intervals overlap with dense model. Table 2: Results for ResNet-50 on ImageNet. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"3\">Sparse Error (%)</td><td rowspan=\"2\">Weights (%)</td></tr><tr><td>Dense Error (%)</td><td>SNIP</td><td>Momentum</td></tr><tr><td>Model AlexNet-s</td><td>12.95±0.056</td><td>14.99</td><td>14.27±0.123</td><td>10</td></tr><tr><td>AlexNet-b</td><td>12.85±0.068</td><td>14.50</td><td>13.56±0.094</td><td>10</td></tr><tr><td>VGG16-C</td><td>6.49±0.038</td><td>7.27</td><td>7.00±0.054</td><td>5</td></tr><tr><td>VGG16-D</td><td>6.59±0.050</td><td>7.09</td><td>6.69±0.049*</td><td>5</td></tr><tr><td>VGG16-like</td><td>6.50±0.054</td><td>8.00</td><td>7.00±0.077</td><td>3</td></tr><tr><td>WRN-16-8</td><td>4.57±0.022</td><td>6.63</td><td>5.62±0.056</td><td>5</td></tr><tr><td>WRN-16-10</td><td>4.45±0.040</td><td>6.43</td><td>5.24±0.052</td><td>5</td></tr><tr><td>WRN-22-8</td><td>4.26±0.032</td><td>5.85</td><td>4.93±0.056</td><td>5</td></tr></table>",
+        "bbox": [
+            205,
+            127,
+            789,
+            299
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c521b62d081c9425ebf4cc3eeceddb8144a3f5dfc758ff229acb9e4e71aac298.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\"></td><td colspan=\"3\">Accuracy (%)</td></tr><tr><td colspan=\"2\">Model</td><td>Top-1</td><td>Top-5</td><td>Top-1</td><td>Top-5</td></tr><tr><td colspan=\"2\">Dense ResNet-50 (He et al., 2016)</td><td>74.9</td><td>92.4</td><td>74.9</td><td>92.4</td></tr><tr><td colspan=\"2\">Fully Sparse</td><td>10%</td><td>weights</td><td>20%</td><td>Weights</td></tr><tr><td rowspan=\"3\">DeepR (Bellec et al., 2018) SET (Mocanu et al., 2018)</td><td>X</td><td>70.2</td><td>90.0</td><td>71.7</td><td>90.6</td></tr><tr><td>X</td><td>70.4</td><td>90.1</td><td>72.6</td><td>91.2</td></tr><tr><td>Dynamic Sparse (Mostafa and Wang,2019) X</td><td>71.6</td><td>90.5</td><td>73.3</td><td>92.4</td></tr><tr><td rowspan=\"2\">Sparse momentum</td><td></td><td>72.3</td><td>91.0</td><td>74.2</td><td>91.9</td></tr><tr><td>×</td><td>72.3</td><td>91.0</td><td>73.8</td><td>91.8</td></tr></table>",
+        "bbox": [
+            176,
+            340,
+            818,
+            505
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            516,
+            825,
+            601
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The second method measures practical speedups that can be obtained with naive, dense convolution algorithms which are available today. Dense convolution is unsuitable for the training of sparse networks but we include this measurement to highlight the algorithmic gap that exists to efficiently train sparse networks. For dense convolution algorithms, we estimate speedups as follows: If a convolutional channel consists entirely of zero-valued weights we can remove these channels from the computation without changing the outputs and obtain speedups. To receive the speedups for dense convolution we scale each convolution operation by the proportion of empty channels. Using these measures, we estimated the speedups for our models on CIFAR-10. The resulting speedups and dense performance levels can be seen in Table 3. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            732
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We see that VGG16 networks can achieve dense performance with relatively few weights while AlexNet requires the most weights. Wide Residual Networks need an intermediate level of weights. Despite the large number of weights for AlexNet, sparse momentum still yields large speedups around $3 . 0 \\mathbf { x }$ for sparse convolution. Sparse convolution speedups are particularly pronounced for Wide Residual Networks (WRN) with speedups as high as $5 . 6 1 \\mathrm { x }$ . Dense convolution speedups are much lower and are mostly dependent on width, with wider networks receiving larger speedups. These results highlight the importance to develop optimized algorithms for sparse convolution. ",
+        "bbox": [
+            174,
+            739,
+            825,
+            837
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Beyond speedups, we also measured the overhead of our sparse momentum procedure to be equivalent of a slowdown to $0 . 9 7 3 \\mathrm { x } \\pm 0 . 0 2 9 \\mathrm { x }$ compared to a dense baseline. ",
+        "bbox": [
+            174,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/a16d5885c486f8ca528873edd7b590b9fa2c252a603b911bb72dfb9e5a45722f.jpg",
+        "table_caption": [
+            "Table 3: Dense performance equivalents and speedups for sparse networks on CIFAR-10. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">Weights (%)</td><td rowspan=\"2\">Error(%)</td><td colspan=\"2\"> Speedups</td></tr><tr><td>Dense Convolution (Empty Channels)</td><td>Sparse Convolution (FLOPS Reduction)</td></tr><tr><td>AlexNet-s</td><td>50</td><td>13.15±0.065</td><td>1.31x</td><td>3.01x</td></tr><tr><td>AlexNet-b</td><td>35</td><td>13.00±0.065</td><td>1.21x</td><td>2.74x</td></tr><tr><td>VGG16-C</td><td>10</td><td>6.64±0.040</td><td>1.32x</td><td>3.85x</td></tr><tr><td>VGG16-D</td><td>5</td><td>6.49±0.045</td><td>1.36x</td><td>3.51x</td></tr><tr><td>VGG16-like</td><td>5</td><td>6.46±0.036</td><td>1.32x</td><td>3.48x</td></tr><tr><td>WRN 16-8</td><td>30</td><td>4.72±0.051</td><td>1.07x</td><td>4.59x</td></tr><tr><td>WRN 16-10</td><td>25</td><td>4.56±0.037</td><td>1.07x</td><td>4.41x</td></tr><tr><td>WRN 22-8</td><td>20</td><td>4.40±0.037</td><td>1.21x</td><td>5.61x</td></tr></table>",
+        "bbox": [
+            196,
+            127,
+            802,
+            315
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            337,
+            292,
+            352
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.1 ABLATION ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            369,
+            364,
+            383
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our method differs from previous methods like SET and Dynamic Sparse Reparameterization in two ways: (1) redistribution of weights and (2) growth of weights. To understand the performance contribution of these components, we perform ablations on CIFAR-10 for VGG16-D with $5 \\%$ weights, MNIST for LeNet 300-100 and LeNet-5 Caffe with $5 \\%$ weights, and ImageNet for ResNet-50 with $10 \\%$ weights in the fully sparse setting. The results can be seen in Table 4. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            465
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Redistribution: Redistributing weights according to the momentum magnitude becomes increasingly important the larger a network is as can be seen from the steady increases in error from the small LeNet 300-100 to the large ResNet-50 when no momentum redistribution is used. Increased test error is particularly pronounced for ImageNet where the Top-1 error increases by $3 . 4 2 \\%$ to $9 . 7 1 \\%$ if no redistribution is used. ",
+        "bbox": [
+            173,
+            472,
+            825,
+            541
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Momentum growth: Momentum growth improves performance over random growth by a large margin for ResNet-50 on ImageNet, but for smaller networks the combination of redistribution and random growth seems to be sufficient to find good weights. Random growth without redistribution, however, cannot find good weights. These results suggest that with increasing network size a random search strategy becomes inefficient and smarter growth algorithms are required for good performance. ",
+        "bbox": [
+            174,
+            549,
+            825,
+            618
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/a7629ab5814884db42b5b021d5c2eb89b18d3b792f6a893b6bf56a4216ed1d94.jpg",
+        "table_caption": [
+            "Table 4: Ablation analysis for different growth and redistribution algorithm combinations for LeNet 300-100 and LeNet-5 Caffe on MNIST, VGG16-D on CIFAR-10, and ResNet-50 on ImageNet. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Redistribution</td><td rowspan=\"2\">Growth</td><td colspan=\"4\">Test error in %</td></tr><tr><td>LeNet 300-100</td><td>LeNet-5 Caffe</td><td>VGG16-D</td><td>ResNet-50</td></tr><tr><td>momentum</td><td>momentum</td><td>1.53±0.020</td><td>0.69±0.021</td><td>6.69±0.049</td><td>27.07</td></tr><tr><td>momentum</td><td>random</td><td>+0.07±0.022</td><td>-0.05±0.011</td><td>-0.19±0.040</td><td>+7.29</td></tr><tr><td>None</td><td> momentum</td><td>+0.01±0.018</td><td>+0.32±0.071</td><td>+1.54±0.101</td><td>+3.42</td></tr><tr><td>None</td><td>random</td><td>+0.11±0.020</td><td>+0.13±0.013</td><td>+1.49±0.147</td><td>+9.71</td></tr></table>",
+        "bbox": [
+            176,
+            670,
+            821,
+            784
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            808,
+            495,
+            824
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We presented our sparse learning algorithm, sparse momentum, which uses the mean magnitude of momentum to grow and redistribute weights. We showed that sparse momentum outperforms other sparse algorithms on MNIST, CIFAR-10, and ImageNet. Additionally, sparse momentum can rival dense neural network performance while accelerating training. Our analysis of speedups highlights the need for research into specialized sparse convolution and sparse matrix multiplication algorithms to enable the benefits of sparse networks. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            285,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bellec, G., Kappel, D., Maass, W., and Legenstein, R. A. (2018). Deep rewiring: Training very sparse deep networks. CoRR, abs/1711.05136. ",
+        "bbox": [
+            171,
+            133,
+            823,
+            162
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Carreira-Perpinan, M. A. and Idelbayev, Y. (2018). learning-compression algorithms for neural net ´ pruning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 8532–8541. ",
+        "bbox": [
+            173,
+            171,
+            823,
+            214
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chauvin, Y. (1988). A back-propagation algorithm with optimal use of hidden units. In NIPS. ",
+        "bbox": [
+            173,
+            223,
+            789,
+            239
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Child, R., Gray, S., Radford, A., and Sutskever, I. (2019). Generating long sequences with sparse transformers. CoRR, abs/1904.10509. ",
+        "bbox": [
+            174,
+            247,
+            823,
+            276
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dai, X., Yin, H., and Jha, N. K. (2017). Nest: A neural network synthesis tool based on a grow-andprune paradigm. CoRR, abs/1711.02017. ",
+        "bbox": [
+            173,
+            285,
+            825,
+            314
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dai, X., Yin, H., and Jha, N. K. (2018). Grow and prune compact, fast, and accurate lstms. CoRR, abs/1805.11797. ",
+        "bbox": [
+            173,
+            321,
+            825,
+            352
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Deng, J., Dong, W., Socher, R., Li, L.-J., Li, K., and Fei-Fei, L. (2009). Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pages 248–255. Ieee. ",
+        "bbox": [
+            171,
+            359,
+            825,
+            404
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Devlin, J., Chang, M.-W., Lee, K., and Toutanova, K. (2018). Bert: Pre-training of deep bidirectional transformers for language understanding. CoRR, abs/1810.04805. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            441
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dong, X., Chen, S., and Pan, S. J. (2017). Learning to prune deep neural networks via layer-wise optimal brain surgeon. In NIPS. ",
+        "bbox": [
+            174,
+            449,
+            823,
+            479
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Frankle, J. and Carbin, M. (2019). The lottery ticket hypothesis: Finding sparse, trainable neural networks. In ICLR 2019. ",
+        "bbox": [
+            173,
+            487,
+            825,
+            517
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Frankle, J., Dziugaite, G. K., Roy, D. M., and Carbin, M. (2019). The lottery ticket hypothesis at scale. CoRR, abs/1903.01611. ",
+        "bbox": [
+            173,
+            523,
+            825,
+            554
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gale, T., Elsen, E., and Hooker, S. (2019). The state of sparsity in deep neural networks. CoRR, abs/1902.09574. ",
+        "bbox": [
+            173,
+            563,
+            825,
+            592
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gray, S., Radford, A., and Kingma, D. P. (2017). Gpu kernels for block-sparse weights. ",
+        "bbox": [
+            171,
+            599,
+            748,
+            617
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Guo, Y., Yao, A., and Chen, Y. (2016). Dynamic network surgery for efficient dnns. In Advances In Neural Information Processing Systems, pages 1379–1387. ",
+        "bbox": [
+            176,
+            625,
+            826,
+            655
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Han, S., Pool, J., Tran, J., and Dally, W. (2015). Learning both weights and connections for efficient neural network. In Advances in neural information processing systems, pages 1135–1143. ",
+        "bbox": [
+            173,
+            661,
+            823,
+            693
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hassibi, B. and Stork, D. G. (1992). Second order derivatives for network pruning: Optimal brain surgeon. In NIPS. ",
+        "bbox": [
+            173,
+            699,
+            823,
+            729
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "He, K., Zhang, X., Ren, S., and Sun, J. (2016). Deep residual learning for image recognition. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 770–778. ",
+        "bbox": [
+            173,
+            737,
+            825,
+            767
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Herculano-Houzel, S., Mota, B., Wong, P., and Kaas, J. H. (2010). Connectivity-driven white matter scaling and folding in primate cerebral cortex. Proceedings of the National Academy of Sciences of the United States of America, 107 44:19008–13. ",
+        "bbox": [
+            174,
+            775,
+            825,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ishikawa, M. (1996). Structural learning with forgetting. Neural Networks, 9:509–521. ",
+        "bbox": [
+            173,
+            827,
+            743,
+            843
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Karnin, E. D. (1990). A simple procedure for pruning back-propagation trained neural networks. IEEE transactions on neural networks, 1 2:239–42. ",
+        "bbox": [
+            173,
+            851,
+            825,
+            881
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Krizhevsky, A. and Hinton, G. (2009). Learning multiple layers of features from tiny images. Technical report, Citeseer. ",
+        "bbox": [
+            171,
+            888,
+            825,
+            919
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "LeCun, Y. (1998). Gradient-based learning applied to document recognition.   \nLeCun, Y., Denker, J. S., and Solla, S. A. (1989). Optimal brain damage. In NIPS.   \nLee, N., Ajanthan, T., and Torr, P. H. S. (2019). Snip: Single-shot network pruning based on connection sensitivity. In ICLR 2019.   \nLouizos, C., Ullrich, K., and Welling, M. (2017). Bayesian compression for deep learning. In Advances in Neural Information Processing Systems, pages 3288–3298.   \nLouizos, C., Welling, M., and Kingma, D. P. (2018). Learning sparse neural networks through $l _ { 0 }$ regularization. CoRR, abs/1712.01312.   \nMocanu, D. C., Mocanu, E., Stone, P., Nguyen, P. H., Gibescu, M., and Liotta, A. (2018). Scalable training of artificial neural networks with adaptive sparse connectivity inspired by network science. Nature communications, 9(1):2383.   \nMolchanov, D., Ashukha, A., and Vetrov, D. P. (2017). Variational dropout sparsifies deep neural networks. In International Conference on MachineLearning (ICML).   \nMostafa, H. and Wang, X. (2019). Parameter efficient training of deep convolutional neural networks by dynamic sparse reparameterization. In International Conference on Machine Learning (ICML).   \nMozer, M. C. and Smolensky, P. (1988). Skeletonization: A technique for trimming the fat from a network via relevance assessment. In NIPS.   \nNarang, S., Diamos, G. F., Sengupta, S., and Elsen, E. (2017). Exploring sparsity in recurrent neural networks. CoRR, abs/1704.05119.   \nPaszke, A., Gross, S., Chintala, S., Chanan, G., Yang, E., DeVito, Z., Lin, Z., Desmaison, A., Antiga, L., and Lerer, A. (2017). Automatic differentiation in pytorch.   \nQian, N. (1999). On the momentum term in gradient descent learning algorithms. Neural networks : the official journal of the International Neural Network Society, 12 1:145–151.   \nSimonyan, K., Vedaldi, A., and Zisserman, A. (2013). Deep inside convolutional networks: Visualising image classification models and saliency maps. CoRR, abs/1312.6034.   \nSpringenberg, J. T., Dosovitskiy, A., Brox, T., and Riedmiller, M. A. (2014). Striving for simplicity: The all convolutional net. CoRR, abs/1412.6806.   \nUllrich, K., Meeds, E., and Welling, M. (2017). Soft weight-sharing for neural network compression. CoRR, abs/1702.04008.   \nVaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł., and Polosukhin, I. (2017). Attention is all you need. In Advances in neural information processing systems, pages 5998–6008.   \nZeiler, M. D. and Fergus, R. (2014). Visualizing and understanding convolutional networks. In ECCV.   \nZhou, H., Lan, J., Liu, R., and Yosinski, J. (2019). Deconstructing lottery tickets: Zeros, signs, and the supermask. arXiv preprint arXiv:1905.01067.   \nZhu, M. and Gupta, S. (2018). To prune, or not to prune: Exploring the efficacy of pruning for model compression. CoRR, abs/1710.01878. ",
+        "bbox": [
+            171,
+            92,
+            830,
+            818
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1 SENSITIVITY ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            136,
+            383,
+            150
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sparse momentum depends on two hyperparameters: Prune rate and momentum. In this section, we study the sensitivity of the accuracy of our models as we vary the prune rate and momentum. Since momentum parameter has an additional effect on the optimization procedure, we run control experiments for fully dense networks thus disentangling the difference in accuracy accounted by our sparse momentum procedure. ",
+        "bbox": [
+            174,
+            161,
+            825,
+            231
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We run experiments for VGG-D and AlexNet-s with $5 \\%$ and $10 \\%$ weights on CIFAR-10. Results can be seen in Figure 4. We see that sparse momentum is highly robust to the choice of prune rate with results barely deviating when the prune rate is in the interval between 0.2 to 0.4. However, we can see a gradual linear trend that indicates that smaller prune rates work slightly better than larger ones. Cosine and linear prune rate annealing schedules do equally well. For momentum, confidence intervals for values between 0.7 and 0.9 overlap indicating that our procedure is robust to the choice of the momentum parameter. Sparse momentum is more sensitive to low momentum values $( \\le 0 . 6 )$ while it is less sensitive for large momentum values (0.95) compared to a dense control. Additionally, we test the null hypothesis that sparse momentum is equally sensitive to deviations from a momentum parameter value of 0.9 as a dense control. The normality assumption was violated and data transformations did not help. Thus we use the non-parametric Wilcoxon Signed-rank Test. We find no evidence that sparse momentum is more sensitive to the momentum parameter than a dense control, $W ( 1 6 ) = 2 2 . 0 , p = 0 . 5 8$ . Overall, we conclude that sparse momentum is highly robust to deviations of the pruning schedule and the momentum and prune rate parameters. ",
+        "bbox": [
+            173,
+            238,
+            826,
+            433
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/7117fc64f9af6e4603deca5ce68e941dd833601ab85ffdf8166fe5180fae3c84.jpg",
+        "image_caption": [
+            "Figure 4: Parameter sensitivity analysis for prune rate and momentum with $9 5 \\%$ confidence intervals. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            445,
+            812,
+            633
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B ADDITIONAL ANALYSIS ",
+        "bbox": [
+            176,
+            693,
+            408,
+            708
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B.1 DENSE VS SPARSE FEATURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            726,
+            421,
+            741
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Are there differences between feature representations learned by dense and sparse networks? The answer to this question can help with the design of sparse learning algorithms and sparse architectures. In this section, we look at the features of dense and sparse networks and how specialized these features are for certain classes. We test difference between sparse and dense network features statistically. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            808
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For feature visualization, it is common to backpropagate activity to the inputs to be able to visualize what these activities represent (Simonyan et al., 2013; Zeiler and Fergus, 2014; Springenberg et al., 2014). However, in our case, we are more interested in the overall distribution of features for each layer within our network, and as such we want to look at the magnitude of the activity in a channel since – unlike feature visualization – we are not just interested in feature detectors but also discriminators. For example, a face detector would induce positive activity for a ‘person’ class but might produce negative activity for a ‘mushroom’ class. Both kinds of activity are useful. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            912
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "With this reasoning, we develop the following convolutional channel-activation analysis: (1) pass the entire training set through the network and aggregate the magnitude of the activation in each convolutional channel separately for each class; (2) normalize across classes to receive for each channel the proportion of activation which is due to each class; (3) look at the maximum proportion of each channel as a measure of class specialization: a maximum proportion of $1 / N _ { c }$ where $N _ { c }$ is the number of classes indicates that the channel is equally active for all classes in the training set. The higher the proportion deviates from this value, the more is a channel specialized for a particular class. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We obtain results for AlexNet-s, VGG16-D, and WRN 28-2 on CIFAR-10 and use as many weights as needed to reach dense performance levels. We then test the null hypothesis, that there are no differences in class specialization between features from sparse networks and dense networks. Equal variance assumptions was violated for VGG-D and normality was violated for WRN-28-2, while all assumptions hold for AlexNet-s. For consistency reasons we perform non-parametric Kruskal-Wallis one-way analysis of variance tests for all networks. For AlexNet-s, we find some evidence that features of sparse networks have lower class specialization compared to dense networks $\\chi ^ { 2 } ( 5 ) = 4 . 4 3 , p = 0 . 0 3 \\bar { 5 }$ , for VGG-D and WRN-28-2 we find strong evidence that features of sparse networks have lower class specialization than dense networks $\\bar { \\chi } ^ { 2 } ( 1 3 ) = 2 8 . 1 , p < 0 . 0 0 1$ , $\\bar { \\chi ^ { 2 } } ( 1 2 ) = 3 6 . 2 , p < 0 . 0 0 1$ . Thus we reject the null hypothesis. These results increase our confidence that sparse networks learn features which have lower class specialization than dense networks. ",
+        "bbox": [
+            174,
+            207,
+            825,
+            361
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Plots of the distributions of sparse vs. dense features for AlexNet-s, VGG16-D, and WRN 28-2 on CIFAR-10 in Figure 5. These plots were selected to highlight the difference in distribution in the first layers and last layers of each network. We see the convolutional channels in sparse networks have lower class-specialization indicating they learn features which are useful for a broader range of classes compared to dense networks. This trend intensifies with depth. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            438
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Overall, we conclude that sparse networks might be able to rival dense networks by learning more general features that have lower class specialization. ",
+        "bbox": [
+            174,
+            444,
+            821,
+            473
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C FURTHER RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            492,
+            369,
+            508
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C.1 TUNED RESNET-50 ON IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            526,
+            459,
+            540
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We also tried a better version of the ResNet-50 in the fully sparse setting for which we use a cosine learning rate schedule, label smoothing of 0.9, and we warmup the learning rate. The results can be seen in Table 5. ",
+        "bbox": [
+            174,
+            551,
+            825,
+            593
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/6b6c258922727fe066ff059fa1a51bac2c91b97e02d9d15f0955ed9165ff0d3a.jpg",
+        "table_caption": [
+            "Table 5: Fully sparse ImageNet results. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"2\">Accuracy (%)</td></tr><tr><td>Weights (%) Top-1</td><td>Top-5</td></tr><tr><td>Tuned ResNet-50</td><td>100</td><td>77.0 93.5</td></tr><tr><td rowspan=\"3\">Sparse momentum</td><td>10</td><td>72.9 91.5</td></tr><tr><td>20</td><td>74.9 92.5</td></tr><tr><td>30</td><td>75.9 92.9</td></tr></table>",
+        "bbox": [
+            315,
+            630,
+            678,
+            741
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D DETAILED SPARSE MOMENTUM ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            757,
+            588,
+            773
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For a detailed NumPy-style algorithmic description of sparse momentum see Algorithm 2. ",
+        "bbox": [
+            169,
+            789,
+            764,
+            804
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/3f901c2978fb2659c764fa4bb466027b202c3cf82103c11c60169e22f18339dd.jpg",
+        "image_caption": [
+            "Figure 5: Dense vs sparse histograms of class-specialization for convolutional channels on CIFAR-10. A class-specialization of 0.5 indicates that $50 \\%$ of the overall activity comes from a single class. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            237,
+            799,
+            747
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2: Sparse momentum algorithm in NumPy notation. Data: Layer i to k with: Momentum $\\mathbf { M } _ { i }$ , Weight $\\overline { { \\mathbf { W } _ { \\mathbf { i } } } }$ , binary $\\mathbf { M a s k } _ { i }$ ; prune rate $p$ 1 TotalMomentum $\\gets 0$ , TotalNonzero $ 0$ $/ \\star$ (a) Calculate mean momentum contributions of all layers. \\*/ 2 for $i \\gets 0$ to $k$ do 3 MeanMomentum $_ i $ mean(a $\\mathbf { b s } ( \\mathbf { M } _ { i } \\left[ \\mathbf { W } _ { i } \\neq 0 \\right] ) _ { . }$ ) 4 TotalMomentum $\\gets$ TotalMomentum $^ +$ MeanMomentumi 5 $\\mathrm { N o n } Z \\mathrm { e r o } _ { i } = \\mathrm { s u m } ( \\mathbf { W } _ { i } \\neq 0 )$ 6 TotalNonzero TotalNonzero + NonZeroi 7 end 8 for $i \\gets 0$ to $k$ do 9 LayerContribution $_ { \\cdot i } \\gets$ MeanMomentumi/TotalMomentum 10 $p _ { i } \\gets$ getPruneRate $( \\mathbf { W } _ { i } , p )$ 11 weights by finding the NumRemoveth smallest weight. 12 end 13 for $i \\gets 0$ to $k$ do 14 NumRemove $\\mathbf { \\Sigma } _ { i }  \\mathrm { N o n Z e r o } _ { i } \\cdot p$ 15 PruneThreshold $ \\mathrm { s o r t } ( \\mathrm { a b s } ( \\mathbf W _ { i } [ \\mathbf W _ { i } \\neq 0 ] )$ ) [NumRemovei] 16 $\\mathbf { M a s k } _ { i }$ $[ \\mathbf { W } _ { i } <$ PruneThreshold] $ 0$ // Stop gradient flow. 17 $\\mathbf { W } _ { i }$ $[ \\mathbf { W } _ { i } <$ PruneThreshold] $\\gets 0$ 18 end /\\* (c) Enable gradient flow of weights with largest momentum magnitude. \\*/ 19 for $i \\gets 0$ to $k$ do 20 RegrowthThresh $\\mathrm { \\mathbf { \\tau } _ { \\mathrm { 1 } } } \\mathbf { d } _ { i } \\gets \\mathrm { \\mathbf { \\mathrm { s o r t } } } ( \\mathbf { \\mathrm { a b s } } ( \\mathbf { M } _ { i } \\left[ \\mathbf { W } _ { i } = = 0 \\right] )$ ) [NumRegrowthi] 21 $\\mathbf { Z } _ { i } = \\mathbf { M } _ { i }$ · $\\mathbf { W } _ { i } = = 0$ ) // Only consider the momentum of missing weights. 22 $\\mathbf { M } \\mathbf { a s } \\mathbf { k } _ { i } \\gets \\mathbf { M } \\mathbf { a s } \\mathbf { k } _ { i }$ | ( $\\mathbf { Z } _ { i } >$ RegrowthThreshold ) // | is the boolean OR operator 23 end 24 $p $ decayPruneRate(p) 25 applyMask() ",
+        "bbox": [
+            151,
+            286,
+            831,
+            739
+        ],
+        "page_idx": 13
+    }
+]

parse/train/HJgVisRqtX/HJgVisRqtX_content_list.json ADDED Viewed

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

parse/train/HJgVisRqtX/HJgVisRqtX_model.json ADDED Viewed

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

parse/train/ToWi1RjuEr8/ToWi1RjuEr8.md ADDED Viewed

	@@ -0,0 +1,271 @@

+# ADVANTAGE-WEIGHTED REGRESSION: SIMPLE ANDSCALABLE OFF-POLICY REINFORCEMENT LEARNING
+Anonymous authors Paper under double-blind review
+# ABSTRACT
+In this work, we aim to develop a simple and scalable reinforcement learning algorithm that uses standard supervised learning methods as subroutines, while also being able to leverage off-policy data. Our proposed approach, which we refer to as advantage-weighted regression (AWR), consists of two standard supervised learning steps: one to regress onto target values for a value function, and another to regress onto weighted target actions for the policy. The method is simple and general, can accommodate continuous and discrete actions, and can be implemented in just a few lines of code on top of standard supervised learning methods. We provide a theoretical motivation for AWR and analyze its properties when incorporating off-policy data from experience replay. We evaluate AWR on a suite of standard OpenAI Gym benchmark tasks, and show that it achieves competitive performance compared to a number of well-established state-of-the-art RL algorithms. AWR is also able to acquire more effective policies than most off-policy algorithms when learning from purely static datasets with no additional environmental interactions. Furthermore, we demonstrate our algorithm on challenging continuous control tasks with highly complex simulated characters. (Video1)
+# 1 INTRODUCTION
+Model-free reinforcement learning can be a general and effective methodology for training agents to acquire sophisticated behaviors with minimal assumptions on the underlying task. However, RL algorithms can be substantially more complex to implement and tune than standard supervised learning methods. Arguably the simplest reinforcement learning methods are policy gradient algorithms (Sutton et al., 2000), which directly differentiate the expected return and perform gradient ascent. Unfortunately, these methods can be notoriously unstable and are typically on-policy, often requiring a substantial number of samples to learn effective behaviors. Our goal is to develop an RL algorithm that is simple, easy to implement, and can readily incorporate off-policy data.
+In this work, we propose advantage-weighted regression (AWR), a simple off-policy algorithm for model-free RL. Each iteration of the AWR algorithm simply consists of two supervised regression steps: one for training a value function baseline via regression onto cumulative rewards, and another for training the policy via weighted regression. The complete algorithm is shown in Algorithm 1. AWR can accommodate continuous and discrete actions, and can be implemented in just a few lines of code on top of standard supervised learning methods. Despite its simplicity, we find that AWR achieves competitive results when compared to commonly used on-policy and off-policy RL algorithms, and can effectively incorporate fully off-policy data, which has been a challenge for other RL algorithms. Our derivation presents an interpretation of AWR as a constrained policy optimization procedure, and provides a theoretical analysis of the use of off-policy data with experience replay.
+We first revisit the original formulation of reward-weighted regression (RWR) (Peters & Schaal, 2007), an on-policy RL method that utilizes supervised learning to perform policy updates, and then propose a number of new design decisions that significantly improve performance on a suite of standard control benchmark tasks. We then provide a theoretical analysis of AWR, including the capability to incorporate off-policy data with experience replay. Although the design of AWR involves only a few simple design decisions, we show experimentally that these additions provide for a large improvement over previous methods for regression-based policy search, such as RWR, while also being substantially simpler than more modern methods, such as MPO (Abdolmaleki et al., 2018b). We show that AWR achieves competitive performance when compared to several well-established state-of-the-art on-policy and off-policy algorithms.
+# 2 PRELIMINARIES
+In reinforcement learning, the objective is to learn a policy that maximizes an agent’s expected return. At each time step $t$ , the agent observes the state of the environment $\mathbf { s } _ { t }$ , and samples an action from a policy $\mathbf { a } _ { t } \sim \pi ( \mathbf { a } _ { t } | \mathbf { s } _ { t } )$ . The agent then applies that action, which results in a new state $\mathbf { s } _ { t + 1 }$ and a scalar reward $r _ { t } = r ( \mathbf { s } _ { t } , \mathbf { a } _ { t } )$ . The goal is to learn a policy that maximizes the expected return $J ( \pi )$ ,
+$$
+J ( \pi ) = \mathbb { E } _ { \tau \sim p _ { \pi } ( \tau ) } \left[ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } r _ { t } \right] = \mathbb { E } _ { \mathbf { s } \sim d _ { \pi } ( \mathbf { s } ) , a \sim \pi ( \mathbf { a } | \mathbf { s } ) } \left[ r ( \mathbf { s } , \mathbf { a } ) \right] ,
+$$
+where $p _ { \pi } ( \tau )$ represents the likelihood of a trajectory $\tau = \{ ( \mathbf { s } _ { 0 } , \mathbf { a } _ { 0 } , r _ { 0 } ) , ( \mathbf { s } _ { 1 } , \mathbf { a } _ { 1 } , r _ { 1 } ) , \ldots \}$ under a policy $\pi$ , and $\gamma \in \ [ 0 , 1 )$ is the discount factor. $\begin{array} { r } { d _ { \pi } ( \mathbf { s } ) \ = \ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } p ( \mathbf { s } _ { t } \ = \ \mathbf { s } | \pi ) } \end{array}$ represents the unnormalized discounted state distribution induced by the policy $\pi$ (Sutton & Barto, 1998), and $p ( \mathbf { s } _ { t } = \mathbf { s } | \boldsymbol { \pi } )$ is the likelihood of the agent being in state s after following $\pi$ for $t$ timesteps.
+Our proposed AWR algorithm builds on ideas from reward-weighted regression (RWR) (Peters & Schaal, 2007), a policy search algorithm based on an expectation-maximization framework. At each iteration, the E-step constructs an estimate of the optimal policy according to $\pi ^ { * } ( \mathbf { a } | \mathbf { s } ) \ \propto $ $\pi _ { k } ( \mathbf { a } | \mathbf { s } ) \mathrm { e x p } \left( \mathcal { R } _ { \mathbf { s } , \mathbf { a } } / \beta \right)$ , where $\pi _ { k }$ represents the policy at the $k$ th iteration, $\begin{array} { r } { \mathcal { R } _ { { \bf s } , { \bf a } } \stackrel { - } { = } \sum _ { t = 0 } ^ { \infty } \dot { \gamma } ^ { t } r _ { t } } \end{array}$ is the return, and $\beta > 0$ is a temperature parameter. Then the M-step projects $\pi ^ { * }$ onto the space of parameterized policies by solving a supervised regression problem:
+$$
+\pi _ { k + 1 } = \arg \operatorname* { m a x } _ { \pi } \mathbb { E } _ { \mathbf { s } \sim d _ { \pi _ { k } } ( \mathbf { s } ) } \mathbb { E } _ { \mathbf { a } \sim \pi _ { k } ( \mathbf { a } | \mathbf { s } ) } \left[ \log \pi ( \mathbf { a } | \mathbf { s } ) \exp \left( \frac { 1 } { \beta } \mathcal { R } _ { \mathbf { s } , \mathbf { a } } \right) \right] .
+$$
+The RWR update can be interpreted as fitting a new policy $\pi _ { k + 1 }$ to samples from the current policy $\pi _ { k }$ , where the likelihood of each action is weighted by the exponentiated return for that action.
+# 3 ADVANTAGE-WEIGHTED REGRESSION
+In this work, we present advantage-weighted regression (AWR), a simple off-policy RL algorithm based on reward-weighted regression. We first provide an overview of the AWR algorithm, and then describe its theoretical motivation and analyze its properties. The AWR algorithm is summarized in Algorithm 1. Each iteration $k$ of AWR consists of the following simple steps. First, the current policy $\pi _ { k } ( \mathbf { a } | \mathbf { s } )$ is used to sample a batch of trajectories $\{ \tau _ { i } \}$ that are then stored in the replay buffer $\mathcal { D }$ , which is structured as a first-in first-out (FIFO) queue (Mnih et al., 2015). Then, a value function $V _ { k } ^ { { \mathcal { D } } } ( { \mathbf s } )$ is fitted to all eturn estimates eplay buffer . Finally, the $\mathcal { D }$ , which can be done with simple Monteme buffer is used to fit a new policy using $\begin{array} { r } { \mathcal { R } _ { { \bf s } , { \bf a } } ^ { D } = \sum _ { t = 0 } ^ { T } \gamma ^ { t } r _ { t } } \end{array}$ advantage-weighted regreexponentiated advantage $\begin{array} { r } { \exp ( \frac { 1 } { \beta } A ^ { D } ( { \bf s } , { \bf a } ) ) } \end{array}$ state-action pair in the buffer , with the advantage given by $A ^ { \mathcal { D } } ( \mathbf { { s } } , \mathbf { { a } } ) = \mathcal { R } _ { { \mathbf { s } } , \mathbf { { a } } } ^ { \mathcal { D } } - \mathbf { \mathcal { V } } ^ { \mathcal { D } } ( \mathbf { { s } } )$ and $\beta$ is a hyperparameter. In the following subsections, we first motivate AWR as a constrained policy search problem, and then extend our analysis to incorporate experience replay.
+# 3.1 DERIVATION
+In this section, we derive the AWR algorithm as an approximate optimization of a constrained policy search problem. Our goal is to find a policy that maximizes the expected improvement $\mathsf { \bar { \eta } } ( \pi ) \mathsf { \bar { = } } J ( \pi ) \bar { - } J ( \mu )$ over a sampling policy $\mu ( \mathbf { a } | \mathbf { s } )$ . We first derive AWR for the setting where the sampling policy is a single Markovian policy. Then, in the next section, we extend our result to data from multiple policies, as in the case of experience replay. The expected improvement $\eta ( \pi )$ can be expressed in terms of the advantage ${ \mathbf { } } A ^ { \mu } ( \mathbf { { \bar { s } } } , \mathbf { { a } } ) = { \mathbf { } } { \mathcal { R } } _ { { \mathbf { s } } , \mathbf { { a } } } ^ { \mu } - { \mathbf { \bar { \psi } } } V ^ { \mu } ( \mathbf { s } )$ with respect to $\mu$ (Kakade & Langford, 2002; Schulman et al., 2015):
+$$
+\eta ( \pi ) = \mathbb { E } _ { \mathbf { s } \sim d _ { \pi } ( \mathbf { s } ) } \mathbb { E } _ { \mathbf { a } \sim \pi ( \mathbf { a } | \mathbf { s } ) } \left[ \mathcal { R } _ { \mathbf { s } , \mathbf { a } } ^ { \mu } - V ^ { \mu } ( \mathbf { s } ) \right] ,
+$$
+where $\mathcal { R } _ { \mathbf { s } , \mathbf { a } } ^ { \mu }$ denotes the return obtained by performing action a in state s and following $\mu$ for the following timesteps, and $\begin{array} { r } { V ^ { \mu } ( \mathbf { s } ) = \int _ { a . } \mu ( \mathbf { a } | \mathbf { s } ) \mathcal { R } _ { \mathbf { s } } ^ { \mathbf { a } } } \end{array}$ $d \mathbf { a }$ corresponds to the value function of $\mu$ . This objective differs from the ones used in the derivations of related algorithms, such as RWR and
+# Algorithm 1 Advantage-Weighted Regression
+<table><tr><td colspan="2">1:π1 ← random policy 2:D←0</td></tr><tr><td colspan="2">3: for iteration k =1,..., kmax do</td></tr><tr><td>4:</td><td>add trajectories {Ti} sampled via πk to D</td></tr><tr><td>5:</td><td>V ← arg minv Es,a~D [|IRa - V(s)ll2]</td></tr><tr><td>7: end for</td><td>6:πk+1 ←arg maxEs,a~D[ogπ(a|s)exp((a-V(s))]</td></tr></table>
+REPS (Peters & Schaal, 2007; Peters et al., 2010; Abdolmaleki et al., 2018b), which maximize the expected return $J ( \pi )$ instead of the expected improvement. The expected improvement directly gives rise to an objective that involves the advantage. We will see later that this yields a policy update that differ in a subtle but important way from standard RWR. As we show in our experiments, this difference results in a large empirical improvement.
+The objective in Equation 3 can be difficult to optimize due to the dependency between $d _ { \pi } ( \mathbf { s } )$ and $\pi$ , as well as the need to collect samples from $\pi$ . Following Schulman et al. (2015), we can instead optimize an approximation $\hat { \eta } ( \pi )$ of $\eta ( \pi )$ using the state distribution of $\mu$ :
+$$
+\hat { \eta } ( \pi ) = \mathbb { E } _ { \mathbf { s } \sim d _ { \mu } ( \mathbf { s } ) } \mathbb { E } _ { \mathbf { a } \sim \pi ( \mathbf { a } | \mathbf { s } ) } \left[ \mathcal { R } _ { \mathbf { s } , \mathbf { a } } ^ { \mu } - V ^ { \mu } ( \mathbf { s } ) \right] .
+$$
+Here, $\hat { \eta } ( \pi )$ matches $\eta ( \pi )$ to first order (Kakade & Langford, 2002), and provides a good estimate of $\eta$ if $\pi$ and $\mu$ are close in terms of the KL-divergence (Schulman et al., 2015). Using this objective, we can formulate the following constrained policy search problem:
+$$
+\begin{array} { r l } { \underset { \pi } { \arg \operatorname* { m a x } } } & { \displaystyle \int _ { \mathbf { s } } d _ { \mu } ( \mathbf { s } ) \int _ { \mathbf { a } } \pi ( \mathbf { a } | \mathbf { s } ) \left[ \mathcal { R } _ { \mathbf { s } , \mathbf { a } } ^ { \mu } - V ^ { \mu } ( \mathbf { s } ) \right] d \mathbf { a } d \mathbf { s } } \\ { \mathrm { s . t . } } & { \displaystyle \int _ { \mathbf { s } } d _ { \mu } ( \mathbf { s } ) \mathrm { D } _ { \mathrm { K L } } \left( \pi ( \cdot | \mathbf { s } ) | | \mu ( \cdot | \mathbf { s } ) \right) d \mathbf { s } \leq \epsilon . } \end{array}
+$$
+The constraint in Equation 6 ensures that the new policy $\pi$ is close to the data distribution of $\mu$ , and therefore the surrogate objective $\hat { \eta } ( \pi )$ remains a reasonable approximation to $\eta ( \pi )$ . We refer the reader to Schulman et al. (2015) for a detailed derivation and an error bound.
+We can derive AWR as an approximate solution to this constrained optimization. This derivation follows a similar procedure as Peters et al. (2010), and begins by forming the Lagrangian of the optimization problem presented above,
+$$
+\mathcal { L } ( \pi , \beta ) = \int _ { \mathbf { s } } d _ { \mu } ( \mathbf { s } ) \int _ { \mathbf { a } } \pi ( \mathbf { a } | \mathbf { s } ) \left[ \mathcal { R } _ { \mathbf { s } , \mathbf { a } } ^ { \mu } - V ^ { \mu } ( \mathbf { s } ) \right] d \mathbf { a } d \mathbf { s } + \beta \left( \epsilon - \int _ { \mathbf { s } } d _ { \mu } ( \mathbf { s } ) \mathrm { D } _ { \mathrm { K L } } \left( \pi ( \cdot | \mathbf { s } ) | | \mu ( \cdot | \mathbf { s } ) \right) d \mathbf { s } \right) ,
+$$
+where $\beta$ is a Lagrange multiplier. Differentiating ${ \mathcal { L } } ( \pi , \beta )$ with respect to $\pi ( \mathbf { a } | \mathbf { s } )$ and solving for the optimal policy $\pi ^ { * }$ results in the following expression for the optimal policy
+$$
+\pi ^ { * } ( \mathbf { a } | \mathbf { s } ) = \frac { 1 } { Z ( \mathbf { s } ) } \mu ( \mathbf { a } | \mathbf { s } ) \exp \left( \frac { 1 } { \beta } \left( \mathcal { R } _ { \mathbf { s } , \mathbf { a } } ^ { \mu } - V ^ { \mu } ( \mathbf { s } ) \right) \right) ,
+$$
+with $Z ( \mathbf { s } )$ being the partition function. A detailed derivation is available in Appendix A. If $\pi$ is represented by a function approximator (e.g., a neural network), a new policy can be obtained by projecting $\pi ^ { * }$ onto the manifold of parameterized policies,
+$$
+\begin{array} { r l } { \underset { \pi } { \mathrm { a r g \ m i n } } \ : \ : \ : \ : } & { \mathbb { E } _ { \mathbf { s } \sim \mathcal { D } } \left[ \mathrm { D } _ { \mathbf { K L } } \left( \pi ^ { * } ( \cdot | \mathbf { s } ) | | \pi ( \cdot | \mathbf { s } ) \right) \right] } \\ { = \underset { \pi } { \mathrm { a r g \ m a x } } \ : \ : \ : \ : } & { \mathbb { E } _ { \mathbf { s } \sim d _ { \mu } ( \mathbf { s } ) } \mathbb { E } _ { \mathbf { a } \sim \mu ( \mathbf { a } | \mathbf { s } ) } \left[ \log \pi ( \mathbf { a } | \mathbf { s } ) \mathrm { e x p } \left( \frac { 1 } { \beta } \left( \mathcal { R } _ { \mathbf { s } , \mathbf { a } } ^ { \mu } - V ^ { \mu } ( \mathbf { s } ) \right) \right) \right] . } \end{array}
+$$
+While this derivation for AWR largely follows the derivations used in prior work (Peters et al., 2010; Abdolmaleki et al., 2018b), our expected improvement objective introduces a baseline $V ^ { \mu } ( \mathbf { s } )$ to the policy update, which as we show in our experiments, is a crucial component for an effective algorithm. A similar advantage-weighting scheme has been previously used for fitted Q-iteration (Neumann & Peters, 2009), where the policy is given by $\begin{array} { r } { \pi ( \mathbf { a } | \mathbf { s } ) ^ { \cdot } = \frac { 1 } { Z ( \mathbf { s } ) } \mathrm { e x p } \left( \left( \mathcal { R } _ { \mathbf { s } , \mathbf { a } } ^ { \mu } - V ^ { \mu } ( \grave { \mathbf { s } } ) \right) / \beta \right) } \end{array}$ . In this definition, the likelihood of an action does not depend on the sampling distribution, and therefore does not enforce a trust region with respect to $\mu$ .
+# 3.2 EXPERIENCE REPLAY AND OFF-POLICY LEARNING
+A crucial design decision of AWR is the choice of sampling policy $\mu ( \mathbf { a } | \mathbf { s } )$ . Standard implementations of RWR are typically on-policy, where the sampling policy is selected to be the current policy $\mu ( \mathbf { a } | \mathbf { s } ) = \pi _ { k } ( \mathbf { a } | \mathbf { s } )$ at iteration $k$ . This can be sample inefficient, as data collected at each iteration are discarded after a single update iteration. Importance sampling can be incorporated into RWR to reuse data from previous iterations, but at the cost of larger variance (Kober & Peters, 2009). Instead, we can improve sample efficiency of AWR by incorporating experience replay and explicitly accounting for training data from a mixture of multiple past policies. As described in Algorithm 1, at each iteration, AWR collects a batch of data using the latest policy $\pi _ { k }$ , and then stores this data in a replay buffer $\mathcal { D }$ , which also contains data collected from previous policies $\{ \pi _ { 1 } , \cdots , \pi _ { k } \}$ . The value function and policy are then updated using samples drawn from $\mathcal { D }$ . This replay strategy is analogous to modeling the sampling policy as a mixture of policies from previous iterations $\begin{array} { r } { \mu _ { k } ( \tau ) = \sum _ { i = 1 } ^ { k } w _ { i } \pi _ { i } ( \tau ) } \end{array}$ , where $\pi _ { i } ( \tau ) = p ( \tau | \pi _ { i } )$ represents the likelihood of a trajectory $\tau$ under a policy $\pi _ { i }$ from the ith iteration, and the weight $w _ { i }$ specify the probability of selecting $\pi _ { i }$ .
+We now extend the derivation from the previous section to the off-policy setting with experience replay, and show that Algorithm 1 indeed optimizes the expected improvement over a sampling policy modeled by the replay buffer. Given a replay buffer consisting of trajectories from past policies, the joint state-action distribution of $\mu$ is given by $\begin{array} { r } { \mu ( \mathbf { s } , \mathbf { a } ) = \sum _ { i = 1 } ^ { k } w _ { i } d _ { \pi _ { i } } ( \mathbf { s } ) \pi _ { i } ( \mathbf { a } | \mathbf { s } ) } \end{array}$ , and similarly for the marginal state distribution $\begin{array} { r } { d _ { \mu } ( \mathbf { s } ) = \sum _ { i = 1 } ^ { k } w _ { i } d _ { \pi _ { i } } ( \mathbf { s } ) } \end{array}$ . The expected improvement can now be expressed with respect to the set of sampling policies in the replay buffer,
+$$
+\eta ( \pi ) = J ( \pi ) - \sum _ { i } w _ { i } J ( \pi _ { i } ) = \mathbb { E } _ { \mathbf { s } \sim d _ { \pi } ( \mathbf { s } ) } \mathbb { E } _ { \mathbf { a } \sim \pi ( \mathbf { a } | \mathbf { s } ) } \left[ \sum _ { i } w _ { i } A ^ { \pi _ { i } } ( \mathbf { s } , \mathbf { a } ) \right] ,
+$$
+where $A ^ { \pi _ { i } } ( \mathbf { s } , \mathbf { a } ) = \mathcal { R } _ { \mathbf { s } , \mathbf { a } } ^ { \pi _ { i } } - V ^ { \pi _ { i } } ( \mathbf { s } )$ is the advantage with respect to each sampling policy. In Appendix $\mathbf { B }$ , we show that the update procedure in Algorithm 1 optimizes the following objective:
+$$
+\begin{array} { r l } & { \underset { \pi } { \arg \operatorname* { m a x } } \sum _ { i = 1 } ^ { k } w _ { i } \left( \mathbb { E } _ { \mathbf { s } \sim d _ { \pi _ { i } } ( \mathbf { s } ) } \mathbb { E } _ { \mathbf { a } \sim \pi ( \mathbf { a } | \mathbf { s } ) } \left[ A ^ { \pi _ { i } } ( \mathbf { s } , \mathbf { a } ) \right] \right) } \\ & { \quad \mathbf { s } . \mathbf { t } . \quad \mathbb { E } _ { \mathbf { s } \sim d _ { \mu } ( \mathbf { s } ) } \left[ \operatorname { D } _ { \mathrm { K L } } \left( \pi ( \cdot | \mathbf { s } ) | | \mu ( \cdot | \mathbf { s } ) \right) \right] \leq \epsilon , } \end{array}
+$$
+where µ(a|s) = µ(s,a) = Pi widπi  (s)πi(a|s) represents the conditional action distribution defined by the replay buffer. This objective can be solved via the Lagrangian to yield the following update:
+$$
+\arg \operatorname* { m a x } _ { \pi } \sum _ { i = 1 } ^ { k } w _ { i } \mathbb { E } _ { \mathbf { s } \sim d _ { \pi _ { i } } ( \mathbf { s } ) } \mathbb { E } _ { \mathbf { a } \sim \pi _ { i } ( \mathbf { a } | \mathbf { s } ) } \left[ \log \pi ( \mathbf { a } | \mathbf { s } ) \mathrm { e x p } \left( \frac { 1 } { \beta } \left( \mathcal { R } _ { \mathbf { s } , \mathbf { a } } ^ { \pi _ { i } } - \frac { \sum _ { j } w _ { j } d _ { \pi _ { j } } ( \mathbf { s } ) V ^ { \pi _ { j } } ( \mathbf { s } ) } { \sum _ { j } w _ { j } d _ { \pi _ { j } } ( \mathbf { s } ) } \right) \right) \right] ,
+$$
+where the expectations can be approximated by simply sampling from $\mathcal { D }$ following Line 6 of Algorithm 1. A detailed derivation is available in Appendix B. Note, the baseline in the exponent now consists of an average of the value functions of the different policies. This mean value function $\bar { V } ( \mathbf { s } )$ can be fitted by simply sampling from the replay buffer following Line 5 of Algorithm 1,
+$$
+\bar { V } = \underset { V } { \arg \operatorname* { m i n } } \sum _ { i } w _ { i } \mathbb { E } _ { { \mathbf s } , \sim d _ { \pi _ { i } } ( { \mathbf s } ) , { \mathbf a } \sim \pi _ { i } ( { \mathbf a } | { \mathbf s } ) } \left[ | | \mathcal { R } _ { { \mathbf s } , { \mathbf a } } ^ { \pi _ { i } } - V ( { \mathbf s } ) | | ^ { 2 } \right] .
+$$
+The optimal solution $\begin{array} { r } { \bar { V } ( \mathbf { s } ) = \frac { \sum _ { i } w _ { i } d _ { \pi _ { i } } ( \mathbf { s } ) V ^ { \pi _ { i } } ( \mathbf { s } ) } { \sum _ { j } w _ { j } d _ { \pi _ { j } } ( \mathbf { s } ) } } \end{array}$ is exactly the baseline in Equation 14.
+# 3.3 IMPLEMENTATION DETAILS
+Finally, we discuss several important design decisions for a practical implementation of AWR. Monte Carlo estimates can be used to approximate the expected return $\mathcal { R } _ { \mathbf { s } , \mathbf { a } } ^ { \mathcal { D } }$ , but this can result in a highvariance estimate. Instead, we approximate $\mathcal { R } _ { \mathbf { s } , \mathbf { a } } ^ { \mathcal { D } }$ using $\mathrm { T D } ( \lambda )$ to obtain a lower-variance estimate (Sutton & Barto, 1998). $\mathrm { T D } ( \lambda )$ is applied by bootstrapping with the value function $V _ { k - 1 } ^ { \mathcal { D } }$ (s) from the previous iteration. To set the value of the Lagrange multiplier $\beta$ , we found that a simple adaptive heuristic of setting $\beta$ to the standard deviation of all advantage values $\sigma _ { A }$ in the replay buffer works well in practice. This is akin to the advantage normalization technique commonly used in implementations of algorithms such as PPO (Dhariwal et al., 2017). Details are available in Appendix C.
+![](images/7c0e471687ed55416395d8d259768717763e8d9157d805db1e6137351b93ea0e.jpg)
+Figure 1: Snapshots of AWR policies trained on OpenAI Gym and motion imitation tasks. Our simple algorithm learns effective policies for a diverse suite of control tasks.
+The weights $\begin{array} { r } { \omega _ { \mathbf { s } , \mathbf { a } } ^ { D } = \exp \Big ( \frac { 1 } { \beta } \left( \mathcal { R } _ { \mathbf { s } , \mathbf { a } } ^ { D } - V ^ { \mathcal { D } } ( \mathbf { s } ) \right) \Big ) } \end{array}$ used to update the policy can occasionally assume excessively large values, which causes gradients to explode. Therefore, we apply weight clipping $\hat { \omega } _ { \mathbf { s } , \mathbf { a } } ^ { \mathcal { D } } = \operatorname* { m i n } \left( \omega _ { \mathbf { s } , \mathbf { a } } ^ { \mathbf { \breve { D } } } , \omega _ { \operatorname* { m a x } } \right)$ with a threshold $\omega _ { \mathrm { m a x } }$ to prevent exploding weights.
+# 4 RELATED WORK
+Existing RL methods can be broadly categorized into on-policy and off-policy algorithms (Sutton & Barto, 1998). On-policy algorithms generally update the policy using data collected from the same policy. A popular class of on-policy algorithms is policy gradient methods (Williams, 1992; Sutton et al., 2000), which can be effective for a diverse array of complex tasks (Heess et al., 2017; Pathak et al., 2017; Peng et al., 2018; Rajeswaran et al., 2018). However, on-policy algorithms are typically data inefficient. Off-policy algorithms improve sample efficiency by enabling training using data from other sources, such as data from different agents or data from previous iterations of the algorithm. Importance sampling is a simple strategy for off-policy learning (Sutton & Barto, 1998; Meuleau et al., 2000; Hachiya et al., 2009), but can introduce optimization instabilities due to the large variance of the importance sampling estimator. Dynamic programming methods based on Q-function learning can also leverage off-policy data (Precup et al., 2001; Mnih et al., 2015; Lillicrap et al., 2016; Gu et al., 2016; Haarnoja et al., 2018b). But these methods can be notoriously unstable, and in practice, require a variety of stabilization techniques (Hasselt et al., 2016; Wang et al., 2016; Munos et al., 2016; Hessel et al., 2017; Fujimoto et al., 2018; Fu et al., 2019). Furthermore, it can be difficult to apply these methods to fully off-policy data, where an agent is unable to collect additional environmental interactions (Fujimoto et al., 2019; Kumar et al., 2019).
+Policy search can also be formulated under an expectation-maximization framework (Peters et al., 2010; Neumann, 2011; Abdolmaleki et al., 2018b), an early example of which is reward-weighted regression (RWR) (Peters & Schaal, 2007). RWR presents a simple on-policy RL algorithm that casts policy search as a supervised regression problem. A similar algorithm, relative entropy policy search (REPS) (Peters et al., 2010), can also be derived from the dual formulation of a constrained policy search problem. RWR has a number appealing properties: it has a very simple update rule, and since each iteration corresponds to supervised learning, it can be more stable and easier to implement than many of the previously mentioned RL methods. Despite these advantages, RWR has not been shown to be an effective when combined with neural networks (Schulman et al., 2015; Duan et al., 2016). In this work, we propose a number of modifications to the formulation of RWR to produce an effective off-policy deep RL algorithm, while still retaining much of the simplicity of RWR.
+The optimization problem being solved in AWR is similar to REPS (Peters et al., 2010), but REPS optimizes the expected return instead of the expected improvement. The weights in REPS also contains a Bellman error term that resembles advantages, but are computed using a linear value function derived from a feature matching constraint. Learning the REPS value function involves minimization of a dual function, which is a complex function of the Bellman error, while the value function in AWR can be learned with simple supervised regression. More recently, Abdolmaleki et al. (2018b) proposed MPO, a deep RL variant of REPS, which applies a partial EM algorithm for policy optimization. The method first fits a Q-function of the current policy via bootstrapping, and then performs a policy improvement step with respect to this Q-function. MPO uses off-policy data for training a Q-function and employs Retrace(λ) for off-policy correction (Munos et al., 2016). In
+![](images/f4d7a3e7fde0cb6b789cbd4e6862d6eb15cff251382b73b9b8ec553ea60a54eb.jpg)
+Figure 2: Learning curves of the various algorithms when applied to OpenAI Gym tasks. Results are averaged across 10 random seeds. AWR is generally competitive with the best current methods.
+<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>TRPO</td><td rowspan=1 colspan=1>PPO</td><td rowspan=1 colspan=1>DDPG</td><td rowspan=1 colspan=1>TD3</td><td rowspan=1 colspan=1>SAC</td><td rowspan=1 colspan=1>LAWER</td><td rowspan=1 colspan=1>RWR</td><td rowspan=1 colspan=1>AWR (Ours)</td></tr><tr><td rowspan=1 colspan=1>Ant-v2</td><td rowspan=1 colspan=1>2901 ± 85</td><td rowspan=1 colspan=1>4884± 1249</td><td rowspan=1 colspan=1>72 ± 1550</td><td rowspan=1 colspan=1>5997 ± 765</td><td rowspan=1 colspan=1>7500±353</td><td rowspan=1 colspan=1>2240± 497</td><td rowspan=1 colspan=1>1183± 176</td><td rowspan=1 colspan=1>5372± 163</td></tr><tr><td rowspan=1 colspan=1>HalfCheetah-v2</td><td rowspan=1 colspan=1>3302 ± 428</td><td rowspan=1 colspan=1>7617 ± 185</td><td rowspan=1 colspan=1>10563 ± 382</td><td rowspan=1 colspan=1>12324 ± 1549</td><td rowspan=1 colspan=1>16223 ± 964</td><td rowspan=1 colspan=1>4596± 2331</td><td rowspan=1 colspan=1>2075±370</td><td rowspan=1 colspan=1>9192 ± 157</td></tr><tr><td rowspan=1 colspan=1>Hopper-v2</td><td rowspan=1 colspan=1>1880±337</td><td rowspan=1 colspan=1>2514± 726</td><td rowspan=1 colspan=1>855±282</td><td rowspan=1 colspan=1>2794± 15</td><td rowspan=1 colspan=1>2757±658</td><td rowspan=1 colspan=1>1830± 553</td><td rowspan=1 colspan=1>605± 114</td><td rowspan=1 colspan=1>3498±167</td></tr><tr><td rowspan=1 colspan=1>Humanoid-v2</td><td rowspan=1 colspan=1>552±9</td><td rowspan=1 colspan=1>4668 ± 1153</td><td rowspan=1 colspan=1>4382 ± 423</td><td rowspan=1 colspan=1>4738±93</td><td rowspan=1 colspan=1>6296±332</td><td rowspan=1 colspan=1>108±386</td><td rowspan=1 colspan=1>509±18</td><td rowspan=1 colspan=1>6159 ± 274</td></tr><tr><td rowspan=1 colspan=1>LunarLander-v2</td><td rowspan=1 colspan=1>104± 94</td><td rowspan=1 colspan=1>121 ± 49</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>185±23</td><td rowspan=1 colspan=1>229±2</td></tr><tr><td rowspan=1 colspan=1>Walker2d-v2</td><td rowspan=1 colspan=1>2765±168</td><td rowspan=1 colspan=1>5036± 934</td><td rowspan=1 colspan=1>401± 470</td><td rowspan=1 colspan=1>4779± 803</td><td rowspan=1 colspan=1>6210±511</td><td rowspan=1 colspan=1>2502±388</td><td rowspan=1 colspan=1>406±64</td><td rowspan=1 colspan=1>5813± 483</td></tr></table>
+Table 1: Final returns for different algorithms on the OpenAI Gym tasks, with $\pm$ corresponding to one standard deviation of the average return across 10 random seeds. In terms of final performance, AWR is generally competitive with prior methods.
+contrast, AWR is simpler, as it can simply fit a value function to the observed returns in a replay buffer, and performs weighted supervised regression on the actions to fit the policy. Oh et al. (2018) proposed self-imitation learning (SIL), which augments policy gradient algorithms with an auxiliary behaviour cloning loss to reuse samples from past experiences. Unlike SIL, AWR is a standalone algorithm, and does not need to be combined with an auxiliary RL algorithm. Neumann & Peters (2009) proposed LAWER, a kernel-based fitted Q-iteration algorithm where the Bellman error is weighted by the normalized advantage of each state-action pair. This was then followed by a soft-policy improvement step. Similar to Neumann & Peters (2009), AWR also uses exponentiated advantages, but LAWER’s definition of the policy is different from the one in AWR and does not enforce a trust region constraint. Furthermore, AWR does not perform fitted Q-iteration, and instead utilizes off-policy data in a simple constrained policy search procedure. Wang et al. (2018) applied a similar advantage-weighting scheme for imitation learning, but the method was not demonstrated for the RL setting. In this work, we propose several design decisions that are vital for an effective RL algorithm. We also provide a theoretical analysis of AWR when combined with experience replay, and show that the algorithm optimizes the expected improvement with respect to a mixture of policies modeled by a replay buffer.
+# 5 EXPERIMENTS
+Our experiments aim to comparatively evaluate the performance of AWR with commonly used on-policy and off-policy deep RL algorithms. We evaluate our method on the OpenAI Gym benchmarks (Brockman et al., 2016), consisting of discrete and continuous control tasks. We also evaluate our method on complex motion imitation tasks with high-dimensional simulated characters. We then demonstrate the effectiveness of AWR on fully off-policy learning, by training on static datasets of demonstrations from demo policies. Behaviors learned by the policies are best seen in the supplementary video1. Code for our implementation of AWR is available at sites.google.com/view/awr-supp/. Detailed hyperparameter settings are provided in Appendix C.
+# 5.1 BENCHMARKS
+We compare AWR to a number of state-of-the-art RL algorithms, including on-policy algorithms, such as TRPO (Schulman et al., 2015) and PPO (Schulman et al., 2017), off-policy algorithms, such as DDPG (Lillicrap et al., 2016), TD3 (Fujimoto et al., 2018), and SAC (Haarnoja et al., 2018a), as well as RWR (Peters & Schaal, 2007) and LAWER (Neumann & Peters, 2009).2 TRPO, PPO, and DDPG use the implementations from OpenAI baselines (Dhariwal et al., 2017). TD3 and SAC use the implementations from Fujimoto et al. (2018) and Haarnoja et al. (2018a). RWR and LAWER are implemented following the descriptions in Peters & Schaal (2007) and Neumann & Peters (2009), but neural networks are used instead of kernel-based approximators.
+![](images/939e4b97196a5ea1baaf38ced3bafa63057a2596192d893c1385f6fc296d2543.jpg)
+Figure 3: Left: Learning curves comparing AWR with various components removed. Each component contributes to performance improvements. Right: Learning curves comparing AWR with different capacity replay buffers. AWR remains stable with large buffers containing primarily off-policy data from past iterations.
+Snapshots of the AWR policies are shown in Figure 1. Figure 2 shows learning curves comparing the different algorithms, and Table 1 summarizes the average returns of the final policies across 10 training runs initialized with different random seeds. Due to the slow wall-clock times of TD3 and SAC, some training runs did not have sufficient time to collect as many samples as other algorithms. Overall, AWR shows competitive performance with the state-of-the-art deep RL algorithms. It is competitive with on-policy methods, such as TRPO and PPO, in both sample efficiency and asymptotic performance. While it is not yet as sample efficient as current state-of-the-art off-policy methods, such SAC and TD3, it is able to achieve a comparable asymptotic performance on most tasks. RWR tends to perform poorly on these tasks, which suggests that, the particular modifications from AWR are critical. AWR also significantly outperforms LAWER across the various tasks. Though both methods use a similar advantaged-weighting scheme, our design decisions for AWR produce a simpler and more effective algorithm.
+# 5.2 ABLATION EXPERIMENTS
+To determine the effects of various design decisions, we evaluate the performance of AWR when key components have been removed. The experiments include: an on-policy version of AWR (On-Policy), where updates use only data from the latest policy, a version of AWR without the baseline $V ( \mathbf { s } )$ (No Baseline), and a version that uses Monte Carlo return estimates instead of $\mathrm { T D } ( \lambda )$ (No $\mathrm { T D } ( \lambda ) ,$ ). The effects of these components are illustrated in Figure 3. Overall, these design decisions appear to be vital for an effective algorithm, with the most crucial components being the use of experience replay and a baseline. Updates using only on-policy data can lead to instabilities and noticeable degradation in performance, which may be due to overfitting on a smaller dataset. Removing the baseline also noticeably hampers performance. Using simple Monte Carlo return estimates instead of $\mathrm { T D } ( \lambda )$ seems to be a viable alternative, and the algorithm still achieves competitive performance on some tasks. When combined, these different components yield substantial performance gains over standard RWR.
+To further evaluate the effect of experience replay, we compare policies trained using replay buffer with different capacities. Figure 3 illustrates the learning curves for buffers of size 5k, 20k, 50k, 100k, and $5 0 0 \mathrm { k }$ , with 50k being the default buffer size in our experiments. The size of the replay buffer appears to have a significant impact on overall performance. Smaller buffer sizes can result in instabilities during training, which again may be an effect of overfitting to a smaller dataset. As the buffer size increases, AWR remains stable even when the dataset is dominated by off-policy data from previous iterations. In fact, AWR appears more stable with larger replay buffers, but progress can also become slower. Since the sampling policy $\mu ( \mathbf { a } | \mathbf { s } )$ is modeled by the replay buffer, a larger buffer can limit the rate at which $\mu$ changes by maintaining older data for more iterations.
+# 5.3 MOTION IMITATION
+In this section, we show that AWR can also solve high-dimensional tasks with complex simulated characters, including a $3 4 \mathrm { D o F }$ humanoid and 64 DoF dog. The objective of the tasks is to imitate reference motion clips recorded using mocap. The experimental setup follows the framework proposed by Peng et al. (2018). The motions include walking and running (e.g. canter), as well as acrobatic skills, such as cartwheels and spinkicks. Figure 1 shows snapshots of the behaviors learned by the AWR. Table 2 and Figure 4 compare the performance of AWR to RWR and PPO. AWR performs well across the set of challenging skills, consistently achieving comparable or better performance than PPO. RWR struggles with controlling the humanoid, but exhibits stronger performance on the dog. This difference may be due to the more dynamic and acrobatic skills of the humanoid.
+Table 2: Performance of algorithms on the motion imitation tasks. Returns are normalized between the minimum and maximum possible returns.
+<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>PPO</td><td rowspan=1 colspan=1>RWR</td><td rowspan=1 colspan=1>AWR (Ours)</td></tr><tr><td rowspan=1 colspan=1>Humanoid:Cartwheel</td><td rowspan=1 colspan=1>0.76 ±0.02</td><td rowspan=1 colspan=1>0.03±0.01</td><td rowspan=1 colspan=1>0.78±0.07</td></tr><tr><td rowspan=1 colspan=1>Humanoid:Spinkick</td><td rowspan=1 colspan=1>0.70±0.02</td><td rowspan=1 colspan=1>0.05± 0.03</td><td rowspan=1 colspan=1>0.77± 0.04</td></tr><tr><td rowspan=1 colspan=1>Dog:Canter</td><td rowspan=1 colspan=1>0.76±0.03</td><td rowspan=1 colspan=1>0.78±0.04</td><td rowspan=1 colspan=1>0.86± 0.01</td></tr><tr><td rowspan=1 colspan=1>Dog:Trot</td><td rowspan=1 colspan=1>0.86±0.01</td><td rowspan=1 colspan=1>0.86±0.01</td><td rowspan=1 colspan=1>0.86±0.03</td></tr><tr><td rowspan=1 colspan=1>Dog:Turn</td><td rowspan=1 colspan=1>0.75±0.02</td><td rowspan=1 colspan=1>0.75±0.03</td><td rowspan=1 colspan=1>0.82±0.03</td></tr></table>
+![](images/87d4ca4512b6c8070d7476d2fc3bf8e68347c115c9db6cc02518ecfc41d72dbf.jpg)
+Figure 4: Learning curves on motion imitation tasks. On these challenging tasks, AWR generally learns faster than PPO and RWR.
+![](images/0a480916b5b94b57a18bb7423ee598c2c7ee342d2dff7ecf2edff2777aed5a76.jpg)
+Figure 5: Performance of various algorithms on off-policy learning tasks with static datasets. AWR is able to learn policies that are comparable or better than the original demo policies.
+# 5.4 OFF-POLICY LEARNING WITH STATIC DATASETS
+Next, we evaluate AWR in a fully off-policy setting, where the algorithm is provided with a static dataset of experiences, and then tasked with learning the best possible policy without collecting any additional data. To evaluate our method, we use the off-policy tasks proposed by Kumar et al. (2019). The dataset consists of trajectories $\tau = \{ ( \mathbf { s } _ { 0 } , \mathbf { a } _ { 0 } , r _ { 0 } ) , ( \mathbf { s } _ { 1 } , \mathbf { a } _ { 1 } , r _ { 1 } ) , \ldots \}$ from rollouts of a demo policy. Unlike standard imitation learning tasks, which only observes the states and actions from the demo policy, the dataset also records the reward at each step. The demo policies are trained using SAC on various OpenAI Gym tasks. A dataset of 1 million timesteps is collected for each task.
+For AWR, we simply treat the dataset as the replay buffer $\mathcal { D }$ and directly apply the algorithm without any modifications. Figure 5 compares AWR to the original demo policy (Demo) and a behavioral cloning policy (BC). We also include comparisons to recent off-policy methods: batch-constrained Q-learning (BCQ) (Fujimoto et al., 2019) and bootstrapping error accumulation reduction (BEAR) (Kumar et al., 2019), which have shown strong performance on off-policy learning with static datasets. Note that both of these prior methods are modifications to existing off-policy RL methods, such as TD3 and SAC, which are already quite complex. In contrast, AWR is simple and requires no modifications for the fully off-policy setting. Despite not collecting any additional data, AWR is able to learn effective policies from these fully off-policy datasets, achieving comparable or better performance than the original demo policies. On-policy methods, such as PPO performs poorly in this off-policy setting. Q-function based methods, such as TD3 and SAC, can in principle handle off-policy data but tend to struggle in practice (Fujimoto et al., 2019; Kumar et al., 2019). Unlike Q-function based methods, AWR is less susceptible to issues from out-of-distribution actions as the policy is always trained on observed actions from the behaviour data (Kumar et al., 2019). AWR also shows comparable performance to BEAR and BCQ, which are specifically designed for this off-policy setting and introduce considerable algorithmic overhead.
+# 6 DISCUSSION AND FUTURE WORK
+We presented advantage-weighted regression, a simple off-policy reinforcement learning algorithm, where policy updates are performed using standard supervised learning methods. Despite its simplicity, our algorithm is able to solve challenging control tasks with complex simulated agents, and achieve competitive performance on standard benchmarks compared to a number of well-established RL algorithms. Our derivation introduces several new design decisions, and our experiments verify the importance of these components. AWR is also able to learn from fully off-policy datasets, demonstrating comparable performance to state-of-the-art off-policy methods. While AWR is effective for a diverse suite of tasks, it is not yet as sample efficient as the most efficient off-policy algorithms. We believe that exploring techniques for improving sample efficiency and performance on fully off-policy learning can open opportunities to deploy these methods in real world domains. A better theoretical understanding of the convergence properties of these algorithms, especially when combined with experience replay, could also be valuable for the development of future algorithms.
+# REFERENCES
+Abbas Abdolmaleki, Jost Tobias Springenberg, Jonas Degrave, Steven Bohez, Yuval Tassa, Dan Belov, Nicolas Manfred Otto Heess, and Martin A. Riedmiller. Relative entropy regularized policy iteration. ArXiv, abs/1812.02256, 2018a.
+Abbas Abdolmaleki, Jost Tobias Springenberg, Yuval Tassa, Remi Munos, Nicolas Heess, and Martin Riedmiller. Maximum a posteriori policy optimisation. In International Conference on Learning Representations, 2018b. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ S1ANxQW0b.
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016.
+Prafulla Dhariwal, Christopher Hesse, Oleg Klimov, Alex Nichol, Matthias Plappert, Alec Radford, John Schulman, Szymon Sidor, Yuhuai Wu, and Peter Zhokhov. Openai baselines. https: //github.com/openai/baselines, 2017.
+Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continuous control. In ICML, pp. 1329–1338, 2016. URL http: //proceedings.mlr.press/v48/duan16.html.
+Justin Fu, Aviral Kumar, Matthew Soh, and Sergey Levine. Diagnosing bottlenecks in deep qlearning algorithms. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 2021–2030, Long Beach, California, USA, 09–15 Jun 2019. PMLR. URL http://proceedings.mlr.press/v97/fu19a.html.
+Scott Fujimoto, Herke van Hoof, and David Meger. Addressing function approximation error in actor-critic methods. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 1587–1596, Stockholmsmassan, Stockholm Sweden, 10–15 Jul 2018. PMLR. URL¨ http://proceedings.mlr.press/ $\mathtt { v 8 0 }$ /fujimoto18a.html.
+Scott Fujimoto, David Meger, and Doina Precup. Off-policy deep reinforcement learning without exploration. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 2052–2062, Long Beach, California, USA, 09–15 Jun 2019. PMLR. URL http: //proceedings.mlr.press/v97/fujimoto19a.html.
+Shixiang Gu, Timothy Lillicrap, Ilya Sutskever, and Sergey Levine. Continuous deep q-learning with model-based acceleration. 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. 2829–2838, New York, New York, USA, 20–22 Jun 2016. PMLR. URL http://proceedings.mlr.press/v48/gu16.html.
+Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 1861–1870, Stockholmsmassan, ¨ Stockholm Sweden, 10–15 Jul 2018a. PMLR. URL http://proceedings.mlr.press/ v80/haarnoja18b.html.
+Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 1861–1870, Stockholmsmassan, ¨ Stockholm Sweden, 10–15 Jul 2018b. PMLR. URL http://proceedings.mlr.press/ v80/haarnoja18b.html.
+Hirotaka Hachiya, Takayuki Akiyama, Masashi Sugiayma, and Jan Peters. Adaptive importance sampling for value function approximation in off-policy reinforcement learning. Neural Netw., 22(10):1399–1410, December 2009. ISSN 0893-6080. doi: 10.1016/j.neunet.2009.01.002. URL http://dx.doi.org/10.1016/j.neunet.2009.01.002.
+Danijar Hafner, James Davidson, and Vincent Vanhoucke. Tensorflow agents: Efficient batched reinforcement learning in tensorflow. CoRR, abs/1709.02878, 2017. URL http://arxiv. org/abs/1709.02878.
+Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double q-learning. In Proceedings of the Thirtieth AAAI Conference on Artificial Intelligence, AAAI’16, pp. 2094– 2100. AAAI Press, 2016. URL http://dl.acm.org/citation.cfm?id=3016100. 3016191.
+Nicolas Heess, Dhruva TB, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, S. M. Ali Eslami, Martin A. Riedmiller, and David Silver. Emergence of locomotion behaviours in rich environments. CoRR, abs/1707.02286, 2017. URL http: //arxiv.org/abs/1707.02286.
+Matteo Hessel, Joseph Modayil, Hado van Hasselt, Tom Schaul, Georg Ostrovski, Will Dabney, Daniel Horgan, Bilal Piot, Mohammad Gheshlaghi Azar, and David Silver. Rainbow: Combining improvements in deep reinforcement learning. CoRR, abs/1710.02298, 2017. URL http: //arxiv.org/abs/1710.02298.
+Sham Kakade and John Langford. Approximately optimal approximate reinforcement learning. In Proceedings of the Nineteenth International Conference on Machine Learning, ICML ’02, pp. 267–274, San Francisco, CA, USA, 2002. Morgan Kaufmann Publishers Inc. ISBN 1-55860-873-7. URL http://dl.acm.org/citation.cfm?id=645531.656005.
+Jens Kober and Jan R. Peters. Policy search for motor primitives in robotics. In D. Koller, D. Schuurmans, Y. Bengio, and L. Bottou (eds.), Advances in Neural Information Processing Systems 21, pp. 849–856. Curran Associates, Inc., 2009.
+Aviral Kumar, Justin Fu, George Tucker, and Sergey Levine. Stabilizing off-policy q-learning via bootstrapping error reduction. CoRR, abs/1906.00949, 2019. URL http://arxiv.org/abs/ 1906.00949.
+Timothy P. Lillicrap, Jonathan J. Hunt, Alexander Pritzel, Nicolas Manfred Otto Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. ICLR, 2016.
+Nicolas Meuleau, Leonid Peshkin, Leslie P. Kaelbling, and Kee eung Kim. Off-policy policy search. Technical report, 2000.
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, February 2015. ISSN 00280836. URL http://dx.doi.org/10.1038/nature14236.
+Remi Munos, Thomas Stepleton, Anna Harutyunyan, and Marc G. Bellemare. Safe and efficient ´ off-policy reinforcement learning. In Proceedings of the 30th International Conference on Neural Information Processing Systems, NIPS’16, pp. 1054–1062, USA, 2016. Curran Associates Inc. ISBN 978-1-5108-3881-9. URL http://dl.acm.org/citation.cfm?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ 3157096. 3157214.
+Vinod Nair and Geoffrey E. Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th International Conference on International Conference on Machine Learning, ICML’10, pp. 807–814, USA, 2010. Omnipress. ISBN 978-1-60558-907-7. URL http://dl.acm.org/citation.cfm?id $\equiv$ 3104322.3104425.
+Gerhard Neumann. Variational inference for policy search in changing situations. In Proceedings of the 28th International Conference on International Conference on Machine Learning, ICML’11, pp. 817–824, USA, 2011. Omnipress. ISBN 978-1-4503-0619-5. URL http://dl.acm.org/ citation.cfm?id=3104482.3104585.
+Gerhard Neumann and Jan R. Peters. Fitted q-iteration by advantage weighted regression. In D. Koller, D. Schuurmans, Y. Bengio, and L. Bottou (eds.), Advances in Neural Information Processing Systems 21, pp. 1177–1184. Curran Associates, Inc., 2009.
+Junhyuk Oh, Yijie Guo, Satinder Singh, and Honglak Lee. Self-imitation learning. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 3878–3887, Stockholmsmassan, ¨ Stockholm Sweden, 10–15 Jul 2018. PMLR. URL http://proceedings.mlr.press/ v80/oh18b.html.
+Deepak Pathak, Pulkit Agrawal, Alexei A. Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR) Workshops, July 2017.
+Xue Bin Peng, Pieter Abbeel, Sergey Levine, and Michiel van de Panne. Deepmimic: Exampleguided deep reinforcement learning of physics-based character skills. ACM Trans. Graph., 37 (4):143:1–143:14, July 2018. ISSN 0730-0301. doi: 10.1145/3197517.3201311. URL http: //doi.acm.org/10.1145/3197517.3201311.
+Jan Peters and Stefan Schaal. Reinforcement learning by reward-weighted regression for operational space control. In Proceedings of the 24th International Conference on Machine Learning, ICML ’07, pp. 745–750, New York, NY, USA, 2007. ACM. ISBN 978-1-59593-793-3. doi: 10.1145/ 1273496.1273590. URL http://doi.acm.org/10.1145/1273496.1273590.
+Jan Peters, Katharina Mulling, and Yasemin Alt ¨ un. Relative entropy policy search. In ¨ Proceedings of the Twenty-Fourth AAAI Conference on Artificial Intelligence, AAAI’10, pp. 1607–1612. AAAI Press, 2010. URL http://dl.acm.org/citation.cfm?id=2898607.2898863.
+Vitchyr Pong. Rlkit. https://github.com/vitchyr/rlkit, 2019.
+Doina Precup, Richard S. Sutton, and Sanjoy Dasgupta. Off-policy temporal difference learning with function approximation. In Proceedings of the Eighteenth International Conference on Machine Learning, ICML ’01, pp. 417–424, San Francisco, CA, USA, 2001. Morgan Kaufmann Publishers Inc. ISBN 1-55860-778-1. URL http://dl.acm.org/citation.cfm?id $=$ 645530.655817.
+Aravind Rajeswaran, Vikash Kumar, Abhishek Gupta, Giulia Vezzani, John Schulman, Emanuel Todorov, and Sergey Levine. Learning Complex Dexterous Manipulation with Deep Reinforcement Learning and Demonstrations. In Proceedings of Robotics: Science and Systems (RSS), 2018.
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In Francis Bach and David Blei (eds.), Proceedings of the 32nd International Conference on Machine Learning, volume 37 of Proceedings of Machine Learning Research, pp. 1889–1897, Lille, France, 07–09 Jul 2015. PMLR. URL http://proceedings.mlr. press/v37/schulman15.html.
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. CoRR, abs/1707.06347, 2017. URL http://arxiv.org/abs/ 1707.06347.
+Richard S. Sutton and Andrew G. Barto. Introduction to Reinforcement Learning. MIT Press, Cambridge, MA, USA, 1st edition, 1998. ISBN 0262193981.
+Richard S Sutton, David A. McAllester, Satinder P. Singh, and Yishay Mansour. Policy gradient methods for reinforcement learning with function approximation. In S. A. Solla, T. K. Leen, and K. Muller (eds.), ¨ Advances in Neural Information Processing Systems 12, pp. 1057–1063. MIT Press, 2000.
+Qing Wang, Jiechao Xiong, Lei Han, peng sun, Han Liu, and Tong Zhang. Exponentially weighted imitation learning for batched historical data. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 6288–6297. Curran Associates, Inc., 2018.
+Ziyu Wang, Victor Bapst, Nicolas Heess, Volodymyr Mnih, Remi Munos, Koray Kavukcuoglu, and ´ Nando de Freitas. Sample efficient actor-critic with experience replay. CoRR, abs/1611.01224, 2016. URL http://arxiv.org/abs/1611.01224.
+Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Mach. Learn., 8(3-4):229–256, May 1992. ISSN 0885-6125. doi: 10.1007/BF00992696. URL https://doi.org/10.1007/BF00992696.

parse/train/ToWi1RjuEr8/ToWi1RjuEr8_content_list.json ADDED Viewed

	@@ -0,0 +1,1405 @@

+[
+    {
+        "type": "text",
+        "text": "ADVANTAGE-WEIGHTED REGRESSION: SIMPLE ANDSCALABLE OFF-POLICY REINFORCEMENT LEARNING",
+        "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,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we aim to develop a simple and scalable reinforcement learning algorithm that uses standard supervised learning methods as subroutines, while also being able to leverage off-policy data. Our proposed approach, which we refer to as advantage-weighted regression (AWR), consists of two standard supervised learning steps: one to regress onto target values for a value function, and another to regress onto weighted target actions for the policy. The method is simple and general, can accommodate continuous and discrete actions, and can be implemented in just a few lines of code on top of standard supervised learning methods. We provide a theoretical motivation for AWR and analyze its properties when incorporating off-policy data from experience replay. We evaluate AWR on a suite of standard OpenAI Gym benchmark tasks, and show that it achieves competitive performance compared to a number of well-established state-of-the-art RL algorithms. AWR is also able to acquire more effective policies than most off-policy algorithms when learning from purely static datasets with no additional environmental interactions. Furthermore, we demonstrate our algorithm on challenging continuous control tasks with highly complex simulated characters. (Video1) ",
+        "bbox": [
+            233,
+            266,
+            766,
+            488
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            513,
+            336,
+            530
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Model-free reinforcement learning can be a general and effective methodology for training agents to acquire sophisticated behaviors with minimal assumptions on the underlying task. However, RL algorithms can be substantially more complex to implement and tune than standard supervised learning methods. Arguably the simplest reinforcement learning methods are policy gradient algorithms (Sutton et al., 2000), which directly differentiate the expected return and perform gradient ascent. Unfortunately, these methods can be notoriously unstable and are typically on-policy, often requiring a substantial number of samples to learn effective behaviors. Our goal is to develop an RL algorithm that is simple, easy to implement, and can readily incorporate off-policy data. ",
+        "bbox": [
+            174,
+            539,
+            825,
+            650
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose advantage-weighted regression (AWR), a simple off-policy algorithm for model-free RL. Each iteration of the AWR algorithm simply consists of two supervised regression steps: one for training a value function baseline via regression onto cumulative rewards, and another for training the policy via weighted regression. The complete algorithm is shown in Algorithm 1. AWR can accommodate continuous and discrete actions, and can be implemented in just a few lines of code on top of standard supervised learning methods. Despite its simplicity, we find that AWR achieves competitive results when compared to commonly used on-policy and off-policy RL algorithms, and can effectively incorporate fully off-policy data, which has been a challenge for other RL algorithms. Our derivation presents an interpretation of AWR as a constrained policy optimization procedure, and provides a theoretical analysis of the use of off-policy data with experience replay. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            796
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We first revisit the original formulation of reward-weighted regression (RWR) (Peters & Schaal, 2007), an on-policy RL method that utilizes supervised learning to perform policy updates, and then propose a number of new design decisions that significantly improve performance on a suite of standard control benchmark tasks. We then provide a theoretical analysis of AWR, including the capability to incorporate off-policy data with experience replay. Although the design of AWR involves only a few simple design decisions, we show experimentally that these additions provide for a large improvement over previous methods for regression-based policy search, such as RWR, while also being substantially simpler than more modern methods, such as MPO (Abdolmaleki et al., 2018b). We show that AWR achieves competitive performance when compared to several well-established state-of-the-art on-policy and off-policy algorithms. ",
+        "bbox": [
+            174,
+            803,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            159,
+            339,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In reinforcement learning, the objective is to learn a policy that maximizes an agent’s expected return. At each time step $t$ , the agent observes the state of the environment $\\mathbf { s } _ { t }$ , and samples an action from a policy $\\mathbf { a } _ { t } \\sim \\pi ( \\mathbf { a } _ { t } | \\mathbf { s } _ { t } )$ . The agent then applies that action, which results in a new state $\\mathbf { s } _ { t + 1 }$ and a scalar reward $r _ { t } = r ( \\mathbf { s } _ { t } , \\mathbf { a } _ { t } )$ . The goal is to learn a policy that maximizes the expected return $J ( \\pi )$ , ",
+        "bbox": [
+            174,
+            183,
+            825,
+            239
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e0c503e036e5cfe84a153fe26cebd382e9154913230b839cb64507e89cd48539.jpg",
+        "text": "$$\nJ ( \\pi ) = \\mathbb { E } _ { \\tau \\sim p _ { \\pi } ( \\tau ) } \\left[ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } r _ { t } \\right] = \\mathbb { E } _ { \\mathbf { s } \\sim d _ { \\pi } ( \\mathbf { s } ) , a \\sim \\pi ( \\mathbf { a } | \\mathbf { s } ) } \\left[ r ( \\mathbf { s } , \\mathbf { a } ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            244,
+            696,
+            289
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $p _ { \\pi } ( \\tau )$ represents the likelihood of a trajectory $\\tau = \\{ ( \\mathbf { s } _ { 0 } , \\mathbf { a } _ { 0 } , r _ { 0 } ) , ( \\mathbf { s } _ { 1 } , \\mathbf { a } _ { 1 } , r _ { 1 } ) , \\ldots \\}$ under a policy $\\pi$ , and $\\gamma \\in \\ [ 0 , 1 )$ is the discount factor. $\\begin{array} { r } { d _ { \\pi } ( \\mathbf { s } ) \\ = \\ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } p ( \\mathbf { s } _ { t } \\ = \\ \\mathbf { s } | \\pi ) } \\end{array}$ represents the unnormalized discounted state distribution induced by the policy $\\pi$ (Sutton & Barto, 1998), and $p ( \\mathbf { s } _ { t } = \\mathbf { s } | \\boldsymbol { \\pi } )$ is the likelihood of the agent being in state s after following $\\pi$ for $t$ timesteps. ",
+        "bbox": [
+            173,
+            292,
+            825,
+            351
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our proposed AWR algorithm builds on ideas from reward-weighted regression (RWR) (Peters & Schaal, 2007), a policy search algorithm based on an expectation-maximization framework. At each iteration, the E-step constructs an estimate of the optimal policy according to $\\pi ^ { * } ( \\mathbf { a } | \\mathbf { s } ) \\ \\propto $ $\\pi _ { k } ( \\mathbf { a } | \\mathbf { s } ) \\mathrm { e x p } \\left( \\mathcal { R } _ { \\mathbf { s } , \\mathbf { a } } / \\beta \\right)$ , where $\\pi _ { k }$ represents the policy at the $k$ th iteration, $\\begin{array} { r } { \\mathcal { R } _ { { \\bf s } , { \\bf a } } \\stackrel { - } { = } \\sum _ { t = 0 } ^ { \\infty } \\dot { \\gamma } ^ { t } r _ { t } } \\end{array}$ is the return, and $\\beta > 0$ is a temperature parameter. Then the M-step projects $\\pi ^ { * }$ onto the space of parameterized policies by solving a supervised regression problem: ",
+        "bbox": [
+            173,
+            356,
+            825,
+            440
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/042de5afeb8fefbbe2b6066e7b46598060b80efd9d882f8fd1161f8a72c47db5.jpg",
+        "text": "$$\n\\pi _ { k + 1 } = \\arg \\operatorname* { m a x } _ { \\pi } \\mathbb { E } _ { \\mathbf { s } \\sim d _ { \\pi _ { k } } ( \\mathbf { s } ) } \\mathbb { E } _ { \\mathbf { a } \\sim \\pi _ { k } ( \\mathbf { a } | \\mathbf { s } ) } \\left[ \\log \\pi ( \\mathbf { a } | \\mathbf { s } ) \\exp \\left( \\frac { 1 } { \\beta } \\mathcal { R } _ { \\mathbf { s } , \\mathbf { a } } \\right) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            271,
+            439,
+            725,
+            474
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The RWR update can be interpreted as fitting a new policy $\\pi _ { k + 1 }$ to samples from the current policy $\\pi _ { k }$ , where the likelihood of each action is weighted by the exponentiated return for that action. ",
+        "bbox": [
+            173,
+            478,
+            823,
+            507
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 ADVANTAGE-WEIGHTED REGRESSION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            520,
+            527,
+            536
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we present advantage-weighted regression (AWR), a simple off-policy RL algorithm based on reward-weighted regression. We first provide an overview of the AWR algorithm, and then describe its theoretical motivation and analyze its properties. The AWR algorithm is summarized in Algorithm 1. Each iteration $k$ of AWR consists of the following simple steps. First, the current policy $\\pi _ { k } ( \\mathbf { a } | \\mathbf { s } )$ is used to sample a batch of trajectories $\\{ \\tau _ { i } \\}$ that are then stored in the replay buffer $\\mathcal { D }$ , which is structured as a first-in first-out (FIFO) queue (Mnih et al., 2015). Then, a value function $V _ { k } ^ { { \\mathcal { D } } } ( { \\mathbf s } )$ is fitted to all eturn estimates eplay buffer . Finally, the $\\mathcal { D }$ , which can be done with simple Monteme buffer is used to fit a new policy using $\\begin{array} { r } { \\mathcal { R } _ { { \\bf s } , { \\bf a } } ^ { D } = \\sum _ { t = 0 } ^ { T } \\gamma ^ { t } r _ { t } } \\end{array}$ advantage-weighted regreexponentiated advantage $\\begin{array} { r } { \\exp ( \\frac { 1 } { \\beta } A ^ { D } ( { \\bf s } , { \\bf a } ) ) } \\end{array}$ state-action pair in the buffer , with the advantage given by $A ^ { \\mathcal { D } } ( \\mathbf { { s } } , \\mathbf { { a } } ) = \\mathcal { R } _ { { \\mathbf { s } } , \\mathbf { { a } } } ^ { \\mathcal { D } } - \\mathbf { \\mathcal { V } } ^ { \\mathcal { D } } ( \\mathbf { { s } } )$ and $\\beta$ is a hyperparameter. In the following subsections, we first motivate AWR as a constrained policy search problem, and then extend our analysis to incorporate experience replay. ",
+        "bbox": [
+            173,
+            544,
+            826,
+            717
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 DERIVATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            733,
+            303,
+            747
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we derive the AWR algorithm as an approximate optimization of a constrained policy search problem. Our goal is to find a policy that maximizes the expected improvement $\\mathsf { \\bar { \\eta } } ( \\pi ) \\mathsf { \\bar { = } } J ( \\pi ) \\bar { - } J ( \\mu )$ over a sampling policy $\\mu ( \\mathbf { a } | \\mathbf { s } )$ . We first derive AWR for the setting where the sampling policy is a single Markovian policy. Then, in the next section, we extend our result to data from multiple policies, as in the case of experience replay. The expected improvement $\\eta ( \\pi )$ can be expressed in terms of the advantage ${ \\mathbf { } } A ^ { \\mu } ( \\mathbf { { \\bar { s } } } , \\mathbf { { a } } ) = { \\mathbf { } } { \\mathcal { R } } _ { { \\mathbf { s } } , \\mathbf { { a } } } ^ { \\mu } - { \\mathbf { \\bar { \\psi } } } V ^ { \\mu } ( \\mathbf { s } )$ with respect to $\\mu$ (Kakade & Langford, 2002; Schulman et al., 2015): ",
+        "bbox": [
+            173,
+            751,
+            825,
+            851
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f7e35c33a05ef422d5a1e5f469105454feba29623b920f07f1e6b186e60beec8.jpg",
+        "text": "$$\n\\eta ( \\pi ) = \\mathbb { E } _ { \\mathbf { s } \\sim d _ { \\pi } ( \\mathbf { s } ) } \\mathbb { E } _ { \\mathbf { a } \\sim \\pi ( \\mathbf { a } | \\mathbf { s } ) } \\left[ \\mathcal { R } _ { \\mathbf { s } , \\mathbf { a } } ^ { \\mu } - V ^ { \\mu } ( \\mathbf { s } ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            856,
+            647,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { R } _ { \\mathbf { s } , \\mathbf { a } } ^ { \\mu }$ denotes the return obtained by performing action a in state s and following $\\mu$ for the following timesteps, and $\\begin{array} { r } { V ^ { \\mu } ( \\mathbf { s } ) = \\int _ { a . } \\mu ( \\mathbf { a } | \\mathbf { s } ) \\mathcal { R } _ { \\mathbf { s } } ^ { \\mathbf { a } } } \\end{array}$ $d \\mathbf { a }$ corresponds to the value function of $\\mu$ . This objective differs from the ones used in the derivations of related algorithms, such as RWR and ",
+        "bbox": [
+            174,
+            878,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Advantage-Weighted Regression ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            478,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/bdc39497c9a0a297478fd2d1ef6a60dcb864570d02884892fb3dad5c5f7b1e90.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">1:π1 ← random policy 2:D←0</td></tr><tr><td colspan=\"2\">3: for iteration k =1,..., kmax do</td></tr><tr><td>4:</td><td>add trajectories {Ti} sampled via πk to D</td></tr><tr><td>5:</td><td>V ← arg minv Es,a~D [|IRa - V(s)ll2]</td></tr><tr><td>7: end for</td><td>6:πk+1 ←arg maxEs,a~D[ogπ(a|s)exp((a-V(s))]</td></tr></table>",
+        "bbox": [
+            178,
+            122,
+            658,
+            241
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "REPS (Peters & Schaal, 2007; Peters et al., 2010; Abdolmaleki et al., 2018b), which maximize the expected return $J ( \\pi )$ instead of the expected improvement. The expected improvement directly gives rise to an objective that involves the advantage. We will see later that this yields a policy update that differ in a subtle but important way from standard RWR. As we show in our experiments, this difference results in a large empirical improvement. ",
+        "bbox": [
+            173,
+            263,
+            825,
+            334
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The objective in Equation 3 can be difficult to optimize due to the dependency between $d _ { \\pi } ( \\mathbf { s } )$ and $\\pi$ , as well as the need to collect samples from $\\pi$ . Following Schulman et al. (2015), we can instead optimize an approximation $\\hat { \\eta } ( \\pi )$ of $\\eta ( \\pi )$ using the state distribution of $\\mu$ : ",
+        "bbox": [
+            174,
+            340,
+            823,
+            383
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/08b8271f01f80af82f816af998a184b66c5b6a1945b8c75aa1e0a258e9e94ca7.jpg",
+        "text": "$$\n\\hat { \\eta } ( \\pi ) = \\mathbb { E } _ { \\mathbf { s } \\sim d _ { \\mu } ( \\mathbf { s } ) } \\mathbb { E } _ { \\mathbf { a } \\sim \\pi ( \\mathbf { a } | \\mathbf { s } ) } \\left[ \\mathcal { R } _ { \\mathbf { s } , \\mathbf { a } } ^ { \\mu } - V ^ { \\mu } ( \\mathbf { s } ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            385,
+            647,
+            405
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\hat { \\eta } ( \\pi )$ matches $\\eta ( \\pi )$ to first order (Kakade & Langford, 2002), and provides a good estimate of $\\eta$ if $\\pi$ and $\\mu$ are close in terms of the KL-divergence (Schulman et al., 2015). Using this objective, we can formulate the following constrained policy search problem: ",
+        "bbox": [
+            176,
+            406,
+            825,
+            448
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/04de041cf143a8481a82e0313d2139f7c53dc50f98085490f1a1079208de9aba.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\underset { \\pi } { \\arg \\operatorname* { m a x } } } & { \\displaystyle \\int _ { \\mathbf { s } } d _ { \\mu } ( \\mathbf { s } ) \\int _ { \\mathbf { a } } \\pi ( \\mathbf { a } | \\mathbf { s } ) \\left[ \\mathcal { R } _ { \\mathbf { s } , \\mathbf { a } } ^ { \\mu } - V ^ { \\mu } ( \\mathbf { s } ) \\right] d \\mathbf { a } d \\mathbf { s } } \\\\ { \\mathrm { s . t . } } & { \\displaystyle \\int _ { \\mathbf { s } } d _ { \\mu } ( \\mathbf { s } ) \\mathrm { D } _ { \\mathrm { K L } } \\left( \\pi ( \\cdot | \\mathbf { s } ) | | \\mu ( \\cdot | \\mathbf { s } ) \\right) d \\mathbf { s } \\leq \\epsilon . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            449,
+            678,
+            516
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The constraint in Equation 6 ensures that the new policy $\\pi$ is close to the data distribution of $\\mu$ , and therefore the surrogate objective $\\hat { \\eta } ( \\pi )$ remains a reasonable approximation to $\\eta ( \\pi )$ . We refer the reader to Schulman et al. (2015) for a detailed derivation and an error bound. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            559
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We can derive AWR as an approximate solution to this constrained optimization. This derivation follows a similar procedure as Peters et al. (2010), and begins by forming the Lagrangian of the optimization problem presented above, ",
+        "bbox": [
+            176,
+            564,
+            821,
+            607
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d4a6614099fbc513a14d587a93217ba47a4ee38e9d7d621a4839a5420814bd5d.jpg",
+        "text": "$$\n\\mathcal { L } ( \\pi , \\beta ) = \\int _ { \\mathbf { s } } d _ { \\mu } ( \\mathbf { s } ) \\int _ { \\mathbf { a } } \\pi ( \\mathbf { a } | \\mathbf { s } ) \\left[ \\mathcal { R } _ { \\mathbf { s } , \\mathbf { a } } ^ { \\mu } - V ^ { \\mu } ( \\mathbf { s } ) \\right] d \\mathbf { a } d \\mathbf { s } + \\beta \\left( \\epsilon - \\int _ { \\mathbf { s } } d _ { \\mu } ( \\mathbf { s } ) \\mathrm { D } _ { \\mathrm { K L } } \\left( \\pi ( \\cdot | \\mathbf { s } ) | | \\mu ( \\cdot | \\mathbf { s } ) \\right) d \\mathbf { s } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            171,
+            608,
+            816,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\beta$ is a Lagrange multiplier. Differentiating ${ \\mathcal { L } } ( \\pi , \\beta )$ with respect to $\\pi ( \\mathbf { a } | \\mathbf { s } )$ and solving for the optimal policy $\\pi ^ { * }$ results in the following expression for the optimal policy ",
+        "bbox": [
+            173,
+            654,
+            821,
+            683
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/905045d9e99c6bdb0d3819a411e6251f58bb444bfc3a8221af9f4e8869d09b28.jpg",
+        "text": "$$\n\\pi ^ { * } ( \\mathbf { a } | \\mathbf { s } ) = \\frac { 1 } { Z ( \\mathbf { s } ) } \\mu ( \\mathbf { a } | \\mathbf { s } ) \\exp \\left( \\frac { 1 } { \\beta } \\left( \\mathcal { R } _ { \\mathbf { s } , \\mathbf { a } } ^ { \\mu } - V ^ { \\mu } ( \\mathbf { s } ) \\right) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            683,
+            673,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "with $Z ( \\mathbf { s } )$ being the partition function. A detailed derivation is available in Appendix A. If $\\pi$ is represented by a function approximator (e.g., a neural network), a new policy can be obtained by projecting $\\pi ^ { * }$ onto the manifold of parameterized policies, ",
+        "bbox": [
+            174,
+            719,
+            825,
+            761
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/36d24f7d4abf18fae96c1a5bff8fd636bd7cf9e8d34a1ea72617d74b9a9c14bf.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\underset { \\pi } { \\mathrm { a r g \\ m i n } } \\ : \\ : \\ : \\ : } & { \\mathbb { E } _ { \\mathbf { s } \\sim \\mathcal { D } } \\left[ \\mathrm { D } _ { \\mathbf { K L } } \\left( \\pi ^ { * } ( \\cdot | \\mathbf { s } ) | | \\pi ( \\cdot | \\mathbf { s } ) \\right) \\right] } \\\\ { = \\underset { \\pi } { \\mathrm { a r g \\ m a x } } \\ : \\ : \\ : \\ : } & { \\mathbb { E } _ { \\mathbf { s } \\sim d _ { \\mu } ( \\mathbf { s } ) } \\mathbb { E } _ { \\mathbf { a } \\sim \\mu ( \\mathbf { a } | \\mathbf { s } ) } \\left[ \\log \\pi ( \\mathbf { a } | \\mathbf { s } ) \\mathrm { e x p } \\left( \\frac { 1 } { \\beta } \\left( \\mathcal { R } _ { \\mathbf { s } , \\mathbf { a } } ^ { \\mu } - V ^ { \\mu } ( \\mathbf { s } ) \\right) \\right) \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            762,
+            767,
+            824
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While this derivation for AWR largely follows the derivations used in prior work (Peters et al., 2010; Abdolmaleki et al., 2018b), our expected improvement objective introduces a baseline $V ^ { \\mu } ( \\mathbf { s } )$ to the policy update, which as we show in our experiments, is a crucial component for an effective algorithm. A similar advantage-weighting scheme has been previously used for fitted Q-iteration (Neumann & Peters, 2009), where the policy is given by $\\begin{array} { r } { \\pi ( \\mathbf { a } | \\mathbf { s } ) ^ { \\cdot } = \\frac { 1 } { Z ( \\mathbf { s } ) } \\mathrm { e x p } \\left( \\left( \\mathcal { R } _ { \\mathbf { s } , \\mathbf { a } } ^ { \\mu } - V ^ { \\mu } ( \\grave { \\mathbf { s } } ) \\right) / \\beta \\right) } \\end{array}$ . In this definition, the likelihood of an action does not depend on the sampling distribution, and therefore does not enforce a trust region with respect to $\\mu$ . ",
+        "bbox": [
+            173,
+            824,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 EXPERIENCE REPLAY AND OFF-POLICY LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            570,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A crucial design decision of AWR is the choice of sampling policy $\\mu ( \\mathbf { a } | \\mathbf { s } )$ . Standard implementations of RWR are typically on-policy, where the sampling policy is selected to be the current policy $\\mu ( \\mathbf { a } | \\mathbf { s } ) = \\pi _ { k } ( \\mathbf { a } | \\mathbf { s } )$ at iteration $k$ . This can be sample inefficient, as data collected at each iteration are discarded after a single update iteration. Importance sampling can be incorporated into RWR to reuse data from previous iterations, but at the cost of larger variance (Kober & Peters, 2009). Instead, we can improve sample efficiency of AWR by incorporating experience replay and explicitly accounting for training data from a mixture of multiple past policies. As described in Algorithm 1, at each iteration, AWR collects a batch of data using the latest policy $\\pi _ { k }$ , and then stores this data in a replay buffer $\\mathcal { D }$ , which also contains data collected from previous policies $\\{ \\pi _ { 1 } , \\cdots , \\pi _ { k } \\}$ . The value function and policy are then updated using samples drawn from $\\mathcal { D }$ . This replay strategy is analogous to modeling the sampling policy as a mixture of policies from previous iterations $\\begin{array} { r } { \\mu _ { k } ( \\tau ) = \\sum _ { i = 1 } ^ { k } w _ { i } \\pi _ { i } ( \\tau ) } \\end{array}$ , where $\\pi _ { i } ( \\tau ) = p ( \\tau | \\pi _ { i } )$ represents the likelihood of a trajectory $\\tau$ under a policy $\\pi _ { i }$ from the ith iteration, and the weight $w _ { i }$ specify the probability of selecting $\\pi _ { i }$ . ",
+        "bbox": [
+            173,
+            128,
+            825,
+            314
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now extend the derivation from the previous section to the off-policy setting with experience replay, and show that Algorithm 1 indeed optimizes the expected improvement over a sampling policy modeled by the replay buffer. Given a replay buffer consisting of trajectories from past policies, the joint state-action distribution of $\\mu$ is given by $\\begin{array} { r } { \\mu ( \\mathbf { s } , \\mathbf { a } ) = \\sum _ { i = 1 } ^ { k } w _ { i } d _ { \\pi _ { i } } ( \\mathbf { s } ) \\pi _ { i } ( \\mathbf { a } | \\mathbf { s } ) } \\end{array}$ , and similarly for the marginal state distribution $\\begin{array} { r } { d _ { \\mu } ( \\mathbf { s } ) = \\sum _ { i = 1 } ^ { k } w _ { i } d _ { \\pi _ { i } } ( \\mathbf { s } ) } \\end{array}$ . The expected improvement can now be expressed with respect to the set of sampling policies in the replay buffer, ",
+        "bbox": [
+            173,
+            319,
+            826,
+            410
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dd7414402fec6108d138bf126c5e6d28947900f317c1d191d79d4af4e8d0705c.jpg",
+        "text": "$$\n\\eta ( \\pi ) = J ( \\pi ) - \\sum _ { i } w _ { i } J ( \\pi _ { i } ) = \\mathbb { E } _ { \\mathbf { s } \\sim d _ { \\pi } ( \\mathbf { s } ) } \\mathbb { E } _ { \\mathbf { a } \\sim \\pi ( \\mathbf { a } | \\mathbf { s } ) } \\left[ \\sum _ { i } w _ { i } A ^ { \\pi _ { i } } ( \\mathbf { s } , \\mathbf { a } ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            263,
+            407,
+            733,
+            449
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $A ^ { \\pi _ { i } } ( \\mathbf { s } , \\mathbf { a } ) = \\mathcal { R } _ { \\mathbf { s } , \\mathbf { a } } ^ { \\pi _ { i } } - V ^ { \\pi _ { i } } ( \\mathbf { s } )$ is the advantage with respect to each sampling policy. In Appendix $\\mathbf { B }$ , we show that the update procedure in Algorithm 1 optimizes the following objective: ",
+        "bbox": [
+            174,
+            454,
+            823,
+            483
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ca4b32e487d3f21916fa49a578b2cf61399ec2dbb60472981794e202bd5f722a.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\underset { \\pi } { \\arg \\operatorname* { m a x } } \\sum _ { i = 1 } ^ { k } w _ { i } \\left( \\mathbb { E } _ { \\mathbf { s } \\sim d _ { \\pi _ { i } } ( \\mathbf { s } ) } \\mathbb { E } _ { \\mathbf { a } \\sim \\pi ( \\mathbf { a } | \\mathbf { s } ) } \\left[ A ^ { \\pi _ { i } } ( \\mathbf { s } , \\mathbf { a } ) \\right] \\right) } \\\\ & { \\quad \\mathbf { s } . \\mathbf { t } . \\quad \\mathbb { E } _ { \\mathbf { s } \\sim d _ { \\mu } ( \\mathbf { s } ) } \\left[ \\operatorname { D } _ { \\mathrm { K L } } \\left( \\pi ( \\cdot | \\mathbf { s } ) | | \\mu ( \\cdot | \\mathbf { s } ) \\right) \\right] \\leq \\epsilon , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            483,
+            666,
+            547
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where µ(a|s) = µ(s,a) = Pi widπi  (s)πi(a|s) represents the conditional action distribution defined by the replay buffer. This objective can be solved via the Lagrangian to yield the following update: ",
+        "bbox": [
+            174,
+            551,
+            825,
+            589
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/610d83fb4461d7d6696dc6e5b454ef2e832925af2797f31aa9ab35c5feebe95a.jpg",
+        "text": "$$\n\\arg \\operatorname* { m a x } _ { \\pi } \\sum _ { i = 1 } ^ { k } w _ { i } \\mathbb { E } _ { \\mathbf { s } \\sim d _ { \\pi _ { i } } ( \\mathbf { s } ) } \\mathbb { E } _ { \\mathbf { a } \\sim \\pi _ { i } ( \\mathbf { a } | \\mathbf { s } ) } \\left[ \\log \\pi ( \\mathbf { a } | \\mathbf { s } ) \\mathrm { e x p } \\left( \\frac { 1 } { \\beta } \\left( \\mathcal { R } _ { \\mathbf { s } , \\mathbf { a } } ^ { \\pi _ { i } } - \\frac { \\sum _ { j } w _ { j } d _ { \\pi _ { j } } ( \\mathbf { s } ) V ^ { \\pi _ { j } } ( \\mathbf { s } ) } { \\sum _ { j } w _ { j } d _ { \\pi _ { j } } ( \\mathbf { s } ) } \\right) \\right) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            593,
+            815,
+            637
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the expectations can be approximated by simply sampling from $\\mathcal { D }$ following Line 6 of Algorithm 1. A detailed derivation is available in Appendix B. Note, the baseline in the exponent now consists of an average of the value functions of the different policies. This mean value function $\\bar { V } ( \\mathbf { s } )$ can be fitted by simply sampling from the replay buffer following Line 5 of Algorithm 1, ",
+        "bbox": [
+            174,
+            655,
+            825,
+            712
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4ed4c423d2a71d70f13729e0b9e92fc8318e582740877940e770278d02d1528c.jpg",
+        "text": "$$\n\\bar { V } = \\underset { V } { \\arg \\operatorname* { m i n } } \\sum _ { i } w _ { i } \\mathbb { E } _ { { \\mathbf s } , \\sim d _ { \\pi _ { i } } ( { \\mathbf s } ) , { \\mathbf a } \\sim \\pi _ { i } ( { \\mathbf a } | { \\mathbf s } ) } \\left[ | | \\mathcal { R } _ { { \\mathbf s } , { \\mathbf a } } ^ { \\pi _ { i } } - V ( { \\mathbf s } ) | | ^ { 2 } \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            717,
+            699,
+            750
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The optimal solution $\\begin{array} { r } { \\bar { V } ( \\mathbf { s } ) = \\frac { \\sum _ { i } w _ { i } d _ { \\pi _ { i } } ( \\mathbf { s } ) V ^ { \\pi _ { i } } ( \\mathbf { s } ) } { \\sum _ { j } w _ { j } d _ { \\pi _ { j } } ( \\mathbf { s } ) } } \\end{array}$ is exactly the baseline in Equation 14. ",
+        "bbox": [
+            174,
+            753,
+            736,
+            780
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            787,
+            406,
+            803
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally, we discuss several important design decisions for a practical implementation of AWR. Monte Carlo estimates can be used to approximate the expected return $\\mathcal { R } _ { \\mathbf { s } , \\mathbf { a } } ^ { \\mathcal { D } }$ , but this can result in a highvariance estimate. Instead, we approximate $\\mathcal { R } _ { \\mathbf { s } , \\mathbf { a } } ^ { \\mathcal { D } }$ using $\\mathrm { T D } ( \\lambda )$ to obtain a lower-variance estimate (Sutton & Barto, 1998). $\\mathrm { T D } ( \\lambda )$ is applied by bootstrapping with the value function $V _ { k - 1 } ^ { \\mathcal { D } }$ (s) from the previous iteration. To set the value of the Lagrange multiplier $\\beta$ , we found that a simple adaptive heuristic of setting $\\beta$ to the standard deviation of all advantage values $\\sigma _ { A }$ in the replay buffer works well in practice. This is akin to the advantage normalization technique commonly used in implementations of algorithms such as PPO (Dhariwal et al., 2017). Details are available in Appendix C. ",
+        "bbox": [
+            173,
+            806,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/7c0e471687ed55416395d8d259768717763e8d9157d805db1e6137351b93ea0e.jpg",
+        "image_caption": [
+            "Figure 1: Snapshots of AWR policies trained on OpenAI Gym and motion imitation tasks. Our simple algorithm learns effective policies for a diverse suite of control tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            107,
+            820,
+            260
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The weights $\\begin{array} { r } { \\omega _ { \\mathbf { s } , \\mathbf { a } } ^ { D } = \\exp \\Big ( \\frac { 1 } { \\beta } \\left( \\mathcal { R } _ { \\mathbf { s } , \\mathbf { a } } ^ { D } - V ^ { \\mathcal { D } } ( \\mathbf { s } ) \\right) \\Big ) } \\end{array}$ used to update the policy can occasionally assume excessively large values, which causes gradients to explode. Therefore, we apply weight clipping $\\hat { \\omega } _ { \\mathbf { s } , \\mathbf { a } } ^ { \\mathcal { D } } = \\operatorname* { m i n } \\left( \\omega _ { \\mathbf { s } , \\mathbf { a } } ^ { \\mathbf { \\breve { D } } } , \\omega _ { \\operatorname* { m a x } } \\right)$ with a threshold $\\omega _ { \\mathrm { m a x } }$ to prevent exploding weights. ",
+        "bbox": [
+            174,
+            303,
+            825,
+            354
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            369,
+            344,
+            386
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Existing RL methods can be broadly categorized into on-policy and off-policy algorithms (Sutton & Barto, 1998). On-policy algorithms generally update the policy using data collected from the same policy. A popular class of on-policy algorithms is policy gradient methods (Williams, 1992; Sutton et al., 2000), which can be effective for a diverse array of complex tasks (Heess et al., 2017; Pathak et al., 2017; Peng et al., 2018; Rajeswaran et al., 2018). However, on-policy algorithms are typically data inefficient. Off-policy algorithms improve sample efficiency by enabling training using data from other sources, such as data from different agents or data from previous iterations of the algorithm. Importance sampling is a simple strategy for off-policy learning (Sutton & Barto, 1998; Meuleau et al., 2000; Hachiya et al., 2009), but can introduce optimization instabilities due to the large variance of the importance sampling estimator. Dynamic programming methods based on Q-function learning can also leverage off-policy data (Precup et al., 2001; Mnih et al., 2015; Lillicrap et al., 2016; Gu et al., 2016; Haarnoja et al., 2018b). But these methods can be notoriously unstable, and in practice, require a variety of stabilization techniques (Hasselt et al., 2016; Wang et al., 2016; Munos et al., 2016; Hessel et al., 2017; Fujimoto et al., 2018; Fu et al., 2019). Furthermore, it can be difficult to apply these methods to fully off-policy data, where an agent is unable to collect additional environmental interactions (Fujimoto et al., 2019; Kumar et al., 2019). ",
+        "bbox": [
+            174,
+            395,
+            825,
+            618
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Policy search can also be formulated under an expectation-maximization framework (Peters et al., 2010; Neumann, 2011; Abdolmaleki et al., 2018b), an early example of which is reward-weighted regression (RWR) (Peters & Schaal, 2007). RWR presents a simple on-policy RL algorithm that casts policy search as a supervised regression problem. A similar algorithm, relative entropy policy search (REPS) (Peters et al., 2010), can also be derived from the dual formulation of a constrained policy search problem. RWR has a number appealing properties: it has a very simple update rule, and since each iteration corresponds to supervised learning, it can be more stable and easier to implement than many of the previously mentioned RL methods. Despite these advantages, RWR has not been shown to be an effective when combined with neural networks (Schulman et al., 2015; Duan et al., 2016). In this work, we propose a number of modifications to the formulation of RWR to produce an effective off-policy deep RL algorithm, while still retaining much of the simplicity of RWR. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            777
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The optimization problem being solved in AWR is similar to REPS (Peters et al., 2010), but REPS optimizes the expected return instead of the expected improvement. The weights in REPS also contains a Bellman error term that resembles advantages, but are computed using a linear value function derived from a feature matching constraint. Learning the REPS value function involves minimization of a dual function, which is a complex function of the Bellman error, while the value function in AWR can be learned with simple supervised regression. More recently, Abdolmaleki et al. (2018b) proposed MPO, a deep RL variant of REPS, which applies a partial EM algorithm for policy optimization. The method first fits a Q-function of the current policy via bootstrapping, and then performs a policy improvement step with respect to this Q-function. MPO uses off-policy data for training a Q-function and employs Retrace(λ) for off-policy correction (Munos et al., 2016). In ",
+        "bbox": [
+            174,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/f4d7a3e7fde0cb6b789cbd4e6862d6eb15cff251382b73b9b8ec553ea60a54eb.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/5dd21a85e5c4fe859e1c0e8bf61ebae24e92f3286659d0e77425a525cdcb6d1b.jpg",
+        "table_caption": [
+            "Figure 2: Learning curves of the various algorithms when applied to OpenAI Gym tasks. Results are averaged across 10 random seeds. AWR is generally competitive with the best current methods. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>TRPO</td><td rowspan=1 colspan=1>PPO</td><td rowspan=1 colspan=1>DDPG</td><td rowspan=1 colspan=1>TD3</td><td rowspan=1 colspan=1>SAC</td><td rowspan=1 colspan=1>LAWER</td><td rowspan=1 colspan=1>RWR</td><td rowspan=1 colspan=1>AWR (Ours)</td></tr><tr><td rowspan=1 colspan=1>Ant-v2</td><td rowspan=1 colspan=1>2901 ± 85</td><td rowspan=1 colspan=1>4884± 1249</td><td rowspan=1 colspan=1>72 ± 1550</td><td rowspan=1 colspan=1>5997 ± 765</td><td rowspan=1 colspan=1>7500±353</td><td rowspan=1 colspan=1>2240± 497</td><td rowspan=1 colspan=1>1183± 176</td><td rowspan=1 colspan=1>5372± 163</td></tr><tr><td rowspan=1 colspan=1>HalfCheetah-v2</td><td rowspan=1 colspan=1>3302 ± 428</td><td rowspan=1 colspan=1>7617 ± 185</td><td rowspan=1 colspan=1>10563 ± 382</td><td rowspan=1 colspan=1>12324 ± 1549</td><td rowspan=1 colspan=1>16223 ± 964</td><td rowspan=1 colspan=1>4596± 2331</td><td rowspan=1 colspan=1>2075±370</td><td rowspan=1 colspan=1>9192 ± 157</td></tr><tr><td rowspan=1 colspan=1>Hopper-v2</td><td rowspan=1 colspan=1>1880±337</td><td rowspan=1 colspan=1>2514± 726</td><td rowspan=1 colspan=1>855±282</td><td rowspan=1 colspan=1>2794± 15</td><td rowspan=1 colspan=1>2757±658</td><td rowspan=1 colspan=1>1830± 553</td><td rowspan=1 colspan=1>605± 114</td><td rowspan=1 colspan=1>3498±167</td></tr><tr><td rowspan=1 colspan=1>Humanoid-v2</td><td rowspan=1 colspan=1>552±9</td><td rowspan=1 colspan=1>4668 ± 1153</td><td rowspan=1 colspan=1>4382 ± 423</td><td rowspan=1 colspan=1>4738±93</td><td rowspan=1 colspan=1>6296±332</td><td rowspan=1 colspan=1>108±386</td><td rowspan=1 colspan=1>509±18</td><td rowspan=1 colspan=1>6159 ± 274</td></tr><tr><td rowspan=1 colspan=1>LunarLander-v2</td><td rowspan=1 colspan=1>104± 94</td><td rowspan=1 colspan=1>121 ± 49</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>185±23</td><td rowspan=1 colspan=1>229±2</td></tr><tr><td rowspan=1 colspan=1>Walker2d-v2</td><td rowspan=1 colspan=1>2765±168</td><td rowspan=1 colspan=1>5036± 934</td><td rowspan=1 colspan=1>401± 470</td><td rowspan=1 colspan=1>4779± 803</td><td rowspan=1 colspan=1>6210±511</td><td rowspan=1 colspan=1>2502±388</td><td rowspan=1 colspan=1>406±64</td><td rowspan=1 colspan=1>5813± 483</td></tr></table>",
+        "bbox": [
+            176,
+            255,
+            821,
+            324
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Final returns for different algorithms on the OpenAI Gym tasks, with $\\pm$ corresponding to one standard deviation of the average return across 10 random seeds. In terms of final performance, AWR is generally competitive with prior methods. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            373
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "contrast, AWR is simpler, as it can simply fit a value function to the observed returns in a replay buffer, and performs weighted supervised regression on the actions to fit the policy. Oh et al. (2018) proposed self-imitation learning (SIL), which augments policy gradient algorithms with an auxiliary behaviour cloning loss to reuse samples from past experiences. Unlike SIL, AWR is a standalone algorithm, and does not need to be combined with an auxiliary RL algorithm. Neumann & Peters (2009) proposed LAWER, a kernel-based fitted Q-iteration algorithm where the Bellman error is weighted by the normalized advantage of each state-action pair. This was then followed by a soft-policy improvement step. Similar to Neumann & Peters (2009), AWR also uses exponentiated advantages, but LAWER’s definition of the policy is different from the one in AWR and does not enforce a trust region constraint. Furthermore, AWR does not perform fitted Q-iteration, and instead utilizes off-policy data in a simple constrained policy search procedure. Wang et al. (2018) applied a similar advantage-weighting scheme for imitation learning, but the method was not demonstrated for the RL setting. In this work, we propose several design decisions that are vital for an effective RL algorithm. We also provide a theoretical analysis of AWR when combined with experience replay, and show that the algorithm optimizes the expected improvement with respect to a mixture of policies modeled by a replay buffer. ",
+        "bbox": [
+            173,
+            383,
+            825,
+            592
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            604,
+            326,
+            619
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our experiments aim to comparatively evaluate the performance of AWR with commonly used on-policy and off-policy deep RL algorithms. We evaluate our method on the OpenAI Gym benchmarks (Brockman et al., 2016), consisting of discrete and continuous control tasks. We also evaluate our method on complex motion imitation tasks with high-dimensional simulated characters. We then demonstrate the effectiveness of AWR on fully off-policy learning, by training on static datasets of demonstrations from demo policies. Behaviors learned by the policies are best seen in the supplementary video1. Code for our implementation of AWR is available at sites.google.com/view/awr-supp/. Detailed hyperparameter settings are provided in Appendix C. ",
+        "bbox": [
+            174,
+            628,
+            826,
+            739
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 BENCHMARKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            757,
+            315,
+            771
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare AWR to a number of state-of-the-art RL algorithms, including on-policy algorithms, such as TRPO (Schulman et al., 2015) and PPO (Schulman et al., 2017), off-policy algorithms, such as DDPG (Lillicrap et al., 2016), TD3 (Fujimoto et al., 2018), and SAC (Haarnoja et al., 2018a), as well as RWR (Peters & Schaal, 2007) and LAWER (Neumann & Peters, 2009).2 TRPO, PPO, and DDPG use the implementations from OpenAI baselines (Dhariwal et al., 2017). TD3 and SAC use the implementations from Fujimoto et al. (2018) and Haarnoja et al. (2018a). RWR and LAWER are implemented following the descriptions in Peters & Schaal (2007) and Neumann & Peters (2009), but neural networks are used instead of kernel-based approximators. ",
+        "bbox": [
+            174,
+            776,
+            826,
+            887
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/939e4b97196a5ea1baaf38ced3bafa63057a2596192d893c1385f6fc296d2543.jpg",
+        "image_caption": [
+            "Figure 3: Left: Learning curves comparing AWR with various components removed. Each component contributes to performance improvements. Right: Learning curves comparing AWR with different capacity replay buffers. AWR remains stable with large buffers containing primarily off-policy data from past iterations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            103,
+            821,
+            200
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Snapshots of the AWR policies are shown in Figure 1. Figure 2 shows learning curves comparing the different algorithms, and Table 1 summarizes the average returns of the final policies across 10 training runs initialized with different random seeds. Due to the slow wall-clock times of TD3 and SAC, some training runs did not have sufficient time to collect as many samples as other algorithms. Overall, AWR shows competitive performance with the state-of-the-art deep RL algorithms. It is competitive with on-policy methods, such as TRPO and PPO, in both sample efficiency and asymptotic performance. While it is not yet as sample efficient as current state-of-the-art off-policy methods, such SAC and TD3, it is able to achieve a comparable asymptotic performance on most tasks. RWR tends to perform poorly on these tasks, which suggests that, the particular modifications from AWR are critical. AWR also significantly outperforms LAWER across the various tasks. Though both methods use a similar advantaged-weighting scheme, our design decisions for AWR produce a simpler and more effective algorithm. ",
+        "bbox": [
+            174,
+            273,
+            825,
+            439
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 ABLATION EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            455,
+            393,
+            469
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To determine the effects of various design decisions, we evaluate the performance of AWR when key components have been removed. The experiments include: an on-policy version of AWR (On-Policy), where updates use only data from the latest policy, a version of AWR without the baseline $V ( \\mathbf { s } )$ (No Baseline), and a version that uses Monte Carlo return estimates instead of $\\mathrm { T D } ( \\lambda )$ (No $\\mathrm { T D } ( \\lambda ) ,$ ). The effects of these components are illustrated in Figure 3. Overall, these design decisions appear to be vital for an effective algorithm, with the most crucial components being the use of experience replay and a baseline. Updates using only on-policy data can lead to instabilities and noticeable degradation in performance, which may be due to overfitting on a smaller dataset. Removing the baseline also noticeably hampers performance. Using simple Monte Carlo return estimates instead of $\\mathrm { T D } ( \\lambda )$ seems to be a viable alternative, and the algorithm still achieves competitive performance on some tasks. When combined, these different components yield substantial performance gains over standard RWR. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            630
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To further evaluate the effect of experience replay, we compare policies trained using replay buffer with different capacities. Figure 3 illustrates the learning curves for buffers of size 5k, 20k, 50k, 100k, and $5 0 0 \\mathrm { k }$ , with 50k being the default buffer size in our experiments. The size of the replay buffer appears to have a significant impact on overall performance. Smaller buffer sizes can result in instabilities during training, which again may be an effect of overfitting to a smaller dataset. As the buffer size increases, AWR remains stable even when the dataset is dominated by off-policy data from previous iterations. In fact, AWR appears more stable with larger replay buffers, but progress can also become slower. Since the sampling policy $\\mu ( \\mathbf { a } | \\mathbf { s } )$ is modeled by the replay buffer, a larger buffer can limit the rate at which $\\mu$ changes by maintaining older data for more iterations. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            762
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 MOTION IMITATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            777,
+            352,
+            791
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we show that AWR can also solve high-dimensional tasks with complex simulated characters, including a $3 4 \\mathrm { D o F }$ humanoid and 64 DoF dog. The objective of the tasks is to imitate reference motion clips recorded using mocap. The experimental setup follows the framework proposed by Peng et al. (2018). The motions include walking and running (e.g. canter), as well as acrobatic skills, such as cartwheels and spinkicks. Figure 1 shows snapshots of the behaviors learned by the AWR. Table 2 and Figure 4 compare the performance of AWR to RWR and PPO. AWR performs well across the set of challenging skills, consistently achieving comparable or better performance than PPO. RWR struggles with controlling the humanoid, but exhibits stronger performance on the dog. This difference may be due to the more dynamic and acrobatic skills of the humanoid. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/5c391dbb9c92c96c6453612294ddb3c235e106dfe4f2c0e5931f5c4aeea4e18f.jpg",
+        "table_caption": [
+            "Table 2: Performance of algorithms on the motion imitation tasks. Returns are normalized between the minimum and maximum possible returns. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>PPO</td><td rowspan=1 colspan=1>RWR</td><td rowspan=1 colspan=1>AWR (Ours)</td></tr><tr><td rowspan=1 colspan=1>Humanoid:Cartwheel</td><td rowspan=1 colspan=1>0.76 ±0.02</td><td rowspan=1 colspan=1>0.03±0.01</td><td rowspan=1 colspan=1>0.78±0.07</td></tr><tr><td rowspan=1 colspan=1>Humanoid:Spinkick</td><td rowspan=1 colspan=1>0.70±0.02</td><td rowspan=1 colspan=1>0.05± 0.03</td><td rowspan=1 colspan=1>0.77± 0.04</td></tr><tr><td rowspan=1 colspan=1>Dog:Canter</td><td rowspan=1 colspan=1>0.76±0.03</td><td rowspan=1 colspan=1>0.78±0.04</td><td rowspan=1 colspan=1>0.86± 0.01</td></tr><tr><td rowspan=1 colspan=1>Dog:Trot</td><td rowspan=1 colspan=1>0.86±0.01</td><td rowspan=1 colspan=1>0.86±0.01</td><td rowspan=1 colspan=1>0.86±0.03</td></tr><tr><td rowspan=1 colspan=1>Dog:Turn</td><td rowspan=1 colspan=1>0.75±0.02</td><td rowspan=1 colspan=1>0.75±0.03</td><td rowspan=1 colspan=1>0.82±0.03</td></tr></table>",
+        "bbox": [
+            176,
+            101,
+            490,
+            188
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/87d4ca4512b6c8070d7476d2fc3bf8e68347c115c9db6cc02518ecfc41d72dbf.jpg",
+        "image_caption": [
+            "Figure 4: Learning curves on motion imitation tasks. On these challenging tasks, AWR generally learns faster than PPO and RWR. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            498,
+            94,
+            823,
+            190
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0a480916b5b94b57a18bb7423ee598c2c7ee342d2dff7ecf2edff2777aed5a76.jpg",
+        "image_caption": [
+            "Figure 5: Performance of various algorithms on off-policy learning tasks with static datasets. AWR is able to learn policies that are comparable or better than the original demo policies. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            242,
+            825,
+            334
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 OFF-POLICY LEARNING WITH STATIC DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            376,
+            553,
+            390
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Next, we evaluate AWR in a fully off-policy setting, where the algorithm is provided with a static dataset of experiences, and then tasked with learning the best possible policy without collecting any additional data. To evaluate our method, we use the off-policy tasks proposed by Kumar et al. (2019). The dataset consists of trajectories $\\tau = \\{ ( \\mathbf { s } _ { 0 } , \\mathbf { a } _ { 0 } , r _ { 0 } ) , ( \\mathbf { s } _ { 1 } , \\mathbf { a } _ { 1 } , r _ { 1 } ) , \\ldots \\}$ from rollouts of a demo policy. Unlike standard imitation learning tasks, which only observes the states and actions from the demo policy, the dataset also records the reward at each step. The demo policies are trained using SAC on various OpenAI Gym tasks. A dataset of 1 million timesteps is collected for each task. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            493
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For AWR, we simply treat the dataset as the replay buffer $\\mathcal { D }$ and directly apply the algorithm without any modifications. Figure 5 compares AWR to the original demo policy (Demo) and a behavioral cloning policy (BC). We also include comparisons to recent off-policy methods: batch-constrained Q-learning (BCQ) (Fujimoto et al., 2019) and bootstrapping error accumulation reduction (BEAR) (Kumar et al., 2019), which have shown strong performance on off-policy learning with static datasets. Note that both of these prior methods are modifications to existing off-policy RL methods, such as TD3 and SAC, which are already quite complex. In contrast, AWR is simple and requires no modifications for the fully off-policy setting. Despite not collecting any additional data, AWR is able to learn effective policies from these fully off-policy datasets, achieving comparable or better performance than the original demo policies. On-policy methods, such as PPO performs poorly in this off-policy setting. Q-function based methods, such as TD3 and SAC, can in principle handle off-policy data but tend to struggle in practice (Fujimoto et al., 2019; Kumar et al., 2019). Unlike Q-function based methods, AWR is less susceptible to issues from out-of-distribution actions as the policy is always trained on observed actions from the behaviour data (Kumar et al., 2019). AWR also shows comparable performance to BEAR and BCQ, which are specifically designed for this off-policy setting and introduce considerable algorithmic overhead. ",
+        "bbox": [
+            173,
+            500,
+            825,
+            722
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            736,
+            485,
+            751
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We presented advantage-weighted regression, a simple off-policy reinforcement learning algorithm, where policy updates are performed using standard supervised learning methods. Despite its simplicity, our algorithm is able to solve challenging control tasks with complex simulated agents, and achieve competitive performance on standard benchmarks compared to a number of well-established RL algorithms. Our derivation introduces several new design decisions, and our experiments verify the importance of these components. AWR is also able to learn from fully off-policy datasets, demonstrating comparable performance to state-of-the-art off-policy methods. While AWR is effective for a diverse suite of tasks, it is not yet as sample efficient as the most efficient off-policy algorithms. We believe that exploring techniques for improving sample efficiency and performance on fully off-policy learning can open opportunities to deploy these methods in real world domains. A better theoretical understanding of the convergence properties of these algorithms, especially when combined with experience replay, could also be valuable for the development of future algorithms. ",
+        "bbox": [
+            174,
+            757,
+            826,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Abbas Abdolmaleki, Jost Tobias Springenberg, Jonas Degrave, Steven Bohez, Yuval Tassa, Dan Belov, Nicolas Manfred Otto Heess, and Martin A. Riedmiller. Relative entropy regularized policy iteration. ArXiv, abs/1812.02256, 2018a. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            167
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Abbas Abdolmaleki, Jost Tobias Springenberg, Yuval Tassa, Remi Munos, Nicolas Heess, and Martin Riedmiller. Maximum a posteriori policy optimisation. In International Conference on Learning Representations, 2018b. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ S1ANxQW0b. ",
+        "bbox": [
+            174,
+            176,
+            821,
+            219
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016. ",
+        "bbox": [
+            169,
+            228,
+            823,
+            257
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Prafulla Dhariwal, Christopher Hesse, Oleg Klimov, Alex Nichol, Matthias Plappert, Alec Radford, John Schulman, Szymon Sidor, Yuhuai Wu, and Peter Zhokhov. Openai baselines. https: //github.com/openai/baselines, 2017. ",
+        "bbox": [
+            173,
+            265,
+            825,
+            308
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continuous control. In ICML, pp. 1329–1338, 2016. URL http: //proceedings.mlr.press/v48/duan16.html. ",
+        "bbox": [
+            176,
+            315,
+            823,
+            358
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Justin Fu, Aviral Kumar, Matthew Soh, and Sergey Levine. Diagnosing bottlenecks in deep qlearning algorithms. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 2021–2030, Long Beach, California, USA, 09–15 Jun 2019. PMLR. URL http://proceedings.mlr.press/v97/fu19a.html. ",
+        "bbox": [
+            173,
+            367,
+            826,
+            438
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Scott Fujimoto, Herke van Hoof, and David Meger. Addressing function approximation error in actor-critic methods. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 1587–1596, Stockholmsmassan, Stockholm Sweden, 10–15 Jul 2018. PMLR. URL¨ http://proceedings.mlr.press/ $\\mathtt { v 8 0 }$ /fujimoto18a.html. ",
+        "bbox": [
+            174,
+            445,
+            825,
+            516
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Scott Fujimoto, David Meger, and Doina Precup. Off-policy deep reinforcement learning without exploration. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 2052–2062, Long Beach, California, USA, 09–15 Jun 2019. PMLR. URL http: //proceedings.mlr.press/v97/fujimoto19a.html. ",
+        "bbox": [
+            173,
+            525,
+            825,
+            595
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shixiang Gu, Timothy Lillicrap, Ilya Sutskever, and Sergey Levine. Continuous deep q-learning with model-based acceleration. 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. 2829–2838, New York, New York, USA, 20–22 Jun 2016. PMLR. URL http://proceedings.mlr.press/v48/gu16.html. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            674
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 1861–1870, Stockholmsmassan, ¨ Stockholm Sweden, 10–15 Jul 2018a. PMLR. URL http://proceedings.mlr.press/ v80/haarnoja18b.html. ",
+        "bbox": [
+            174,
+            683,
+            826,
+            766
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 1861–1870, Stockholmsmassan, ¨ Stockholm Sweden, 10–15 Jul 2018b. PMLR. URL http://proceedings.mlr.press/ v80/haarnoja18b.html. ",
+        "bbox": [
+            174,
+            775,
+            826,
+            859
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hirotaka Hachiya, Takayuki Akiyama, Masashi Sugiayma, and Jan Peters. Adaptive importance sampling for value function approximation in off-policy reinforcement learning. Neural Netw., 22(10):1399–1410, December 2009. ISSN 0893-6080. doi: 10.1016/j.neunet.2009.01.002. URL http://dx.doi.org/10.1016/j.neunet.2009.01.002. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Danijar Hafner, James Davidson, and Vincent Vanhoucke. Tensorflow agents: Efficient batched reinforcement learning in tensorflow. CoRR, abs/1709.02878, 2017. URL http://arxiv. org/abs/1709.02878. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double q-learning. In Proceedings of the Thirtieth AAAI Conference on Artificial Intelligence, AAAI’16, pp. 2094– 2100. AAAI Press, 2016. URL http://dl.acm.org/citation.cfm?id=3016100. 3016191. ",
+        "bbox": [
+            173,
+            156,
+            828,
+            213
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Dhruva TB, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, S. M. Ali Eslami, Martin A. Riedmiller, and David Silver. Emergence of locomotion behaviours in rich environments. CoRR, abs/1707.02286, 2017. URL http: //arxiv.org/abs/1707.02286. ",
+        "bbox": [
+            173,
+            223,
+            826,
+            280
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matteo Hessel, Joseph Modayil, Hado van Hasselt, Tom Schaul, Georg Ostrovski, Will Dabney, Daniel Horgan, Bilal Piot, Mohammad Gheshlaghi Azar, and David Silver. Rainbow: Combining improvements in deep reinforcement learning. CoRR, abs/1710.02298, 2017. URL http: //arxiv.org/abs/1710.02298. ",
+        "bbox": [
+            173,
+            291,
+            826,
+            347
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sham Kakade and John Langford. Approximately optimal approximate reinforcement learning. In Proceedings of the Nineteenth International Conference on Machine Learning, ICML ’02, pp. 267–274, San Francisco, CA, USA, 2002. Morgan Kaufmann Publishers Inc. ISBN 1-55860-873-7. URL http://dl.acm.org/citation.cfm?id=645531.656005. ",
+        "bbox": [
+            174,
+            358,
+            826,
+            415
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jens Kober and Jan R. Peters. Policy search for motor primitives in robotics. In D. Koller, D. Schuurmans, Y. Bengio, and L. Bottou (eds.), Advances in Neural Information Processing Systems 21, pp. 849–856. Curran Associates, Inc., 2009. ",
+        "bbox": [
+            173,
+            425,
+            826,
+            468
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aviral Kumar, Justin Fu, George Tucker, and Sergey Levine. Stabilizing off-policy q-learning via bootstrapping error reduction. CoRR, abs/1906.00949, 2019. URL http://arxiv.org/abs/ 1906.00949. ",
+        "bbox": [
+            173,
+            478,
+            825,
+            520
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Timothy P. Lillicrap, Jonathan J. Hunt, Alexander Pritzel, Nicolas Manfred Otto Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. ICLR, 2016. ",
+        "bbox": [
+            174,
+            531,
+            826,
+            574
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Meuleau, Leonid Peshkin, Leslie P. Kaelbling, and Kee eung Kim. Off-policy policy search. Technical report, 2000. ",
+        "bbox": [
+            174,
+            584,
+            823,
+            613
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, February 2015. ISSN 00280836. URL http://dx.doi.org/10.1038/nature14236. ",
+        "bbox": [
+            174,
+            625,
+            826,
+            709
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Remi Munos, Thomas Stepleton, Anna Harutyunyan, and Marc G. Bellemare. Safe and efficient ´ off-policy reinforcement learning. In Proceedings of the 30th International Conference on Neural Information Processing Systems, NIPS’16, pp. 1054–1062, USA, 2016. Curran Associates Inc. ISBN 978-1-5108-3881-9. URL http://dl.acm.org/citation.cfm?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ 3157096. 3157214. ",
+        "bbox": [
+            173,
+            719,
+            826,
+            789
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vinod Nair and Geoffrey E. Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th International Conference on International Conference on Machine Learning, ICML’10, pp. 807–814, USA, 2010. Omnipress. ISBN 978-1-60558-907-7. URL http://dl.acm.org/citation.cfm?id $\\equiv$ 3104322.3104425. ",
+        "bbox": [
+            174,
+            800,
+            826,
+            857
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gerhard Neumann. Variational inference for policy search in changing situations. In Proceedings of the 28th International Conference on International Conference on Machine Learning, ICML’11, pp. 817–824, USA, 2011. Omnipress. ISBN 978-1-4503-0619-5. URL http://dl.acm.org/ citation.cfm?id=3104482.3104585. ",
+        "bbox": [
+            174,
+            867,
+            826,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gerhard Neumann and Jan R. Peters. Fitted q-iteration by advantage weighted regression. In D. Koller, D. Schuurmans, Y. Bengio, and L. Bottou (eds.), Advances in Neural Information Processing Systems 21, pp. 1177–1184. Curran Associates, Inc., 2009. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Yijie Guo, Satinder Singh, and Honglak Lee. Self-imitation learning. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 3878–3887, Stockholmsmassan, ¨ Stockholm Sweden, 10–15 Jul 2018. PMLR. URL http://proceedings.mlr.press/ v80/oh18b.html. ",
+        "bbox": [
+            173,
+            155,
+            826,
+            226
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak, Pulkit Agrawal, Alexei A. Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR) Workshops, July 2017. ",
+        "bbox": [
+            173,
+            236,
+            825,
+            279
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xue Bin Peng, Pieter Abbeel, Sergey Levine, and Michiel van de Panne. Deepmimic: Exampleguided deep reinforcement learning of physics-based character skills. ACM Trans. Graph., 37 (4):143:1–143:14, July 2018. ISSN 0730-0301. doi: 10.1145/3197517.3201311. URL http: //doi.acm.org/10.1145/3197517.3201311. ",
+        "bbox": [
+            174,
+            287,
+            826,
+            344
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jan Peters and Stefan Schaal. Reinforcement learning by reward-weighted regression for operational space control. In Proceedings of the 24th International Conference on Machine Learning, ICML ’07, pp. 745–750, New York, NY, USA, 2007. ACM. ISBN 978-1-59593-793-3. doi: 10.1145/ 1273496.1273590. URL http://doi.acm.org/10.1145/1273496.1273590. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            411
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jan Peters, Katharina Mulling, and Yasemin Alt ¨ un. Relative entropy policy search. In ¨ Proceedings of the Twenty-Fourth AAAI Conference on Artificial Intelligence, AAAI’10, pp. 1607–1612. AAAI Press, 2010. URL http://dl.acm.org/citation.cfm?id=2898607.2898863. ",
+        "bbox": [
+            173,
+            420,
+            826,
+            463
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vitchyr Pong. Rlkit. https://github.com/vitchyr/rlkit, 2019. ",
+        "bbox": [
+            174,
+            473,
+            673,
+            488
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Doina Precup, Richard S. Sutton, and Sanjoy Dasgupta. Off-policy temporal difference learning with function approximation. In Proceedings of the Eighteenth International Conference on Machine Learning, ICML ’01, pp. 417–424, San Francisco, CA, USA, 2001. Morgan Kaufmann Publishers Inc. ISBN 1-55860-778-1. URL http://dl.acm.org/citation.cfm?id $=$ 645530.655817. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            568
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aravind Rajeswaran, Vikash Kumar, Abhishek Gupta, Giulia Vezzani, John Schulman, Emanuel Todorov, and Sergey Levine. Learning Complex Dexterous Manipulation with Deep Reinforcement Learning and Demonstrations. In Proceedings of Robotics: Science and Systems (RSS), 2018. ",
+        "bbox": [
+            178,
+            577,
+            823,
+            621
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In Francis Bach and David Blei (eds.), Proceedings of the 32nd International Conference on Machine Learning, volume 37 of Proceedings of Machine Learning Research, pp. 1889–1897, Lille, France, 07–09 Jul 2015. PMLR. URL http://proceedings.mlr. press/v37/schulman15.html. ",
+        "bbox": [
+            173,
+            630,
+            826,
+            700
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. CoRR, abs/1707.06347, 2017. URL http://arxiv.org/abs/ 1707.06347. ",
+        "bbox": [
+            173,
+            710,
+            826,
+            752
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard S. Sutton and Andrew G. Barto. Introduction to Reinforcement Learning. MIT Press, Cambridge, MA, USA, 1st edition, 1998. ISBN 0262193981. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            791
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton, David A. McAllester, Satinder P. Singh, and Yishay Mansour. Policy gradient methods for reinforcement learning with function approximation. In S. A. Solla, T. K. Leen, and K. Muller (eds.), ¨ Advances in Neural Information Processing Systems 12, pp. 1057–1063. MIT Press, 2000. ",
+        "bbox": [
+            173,
+            801,
+            825,
+            857
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Qing Wang, Jiechao Xiong, Lei Han, peng sun, Han Liu, and Tong Zhang. Exponentially weighted imitation learning for batched historical data. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 6288–6297. Curran Associates, Inc., 2018. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Victor Bapst, Nicolas Heess, Volodymyr Mnih, Remi Munos, Koray Kavukcuoglu, and ´ Nando de Freitas. Sample efficient actor-critic with experience replay. CoRR, abs/1611.01224, 2016. URL http://arxiv.org/abs/1611.01224. ",
+        "bbox": [
+            176,
+            103,
+            826,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Mach. Learn., 8(3-4):229–256, May 1992. ISSN 0885-6125. doi: 10.1007/BF00992696. URL https://doi.org/10.1007/BF00992696. ",
+        "bbox": [
+            176,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 11
+    }
+]

parse/train/ToWi1RjuEr8/ToWi1RjuEr8_middle.json ADDED Viewed

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

parse/train/ToWi1RjuEr8/ToWi1RjuEr8_model.json ADDED Viewed

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

parse/train/fgd7we_uZa6/fgd7we_uZa6.md ADDED Viewed

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

parse/train/fgd7we_uZa6/fgd7we_uZa6_content_list.json ADDED Viewed

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

parse/train/fgd7we_uZa6/fgd7we_uZa6_middle.json ADDED Viewed

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

parse/train/fgd7we_uZa6/fgd7we_uZa6_model.json ADDED Viewed

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

parse/train/oh71uL93yay/oh71uL93yay.md ADDED Viewed

	@@ -0,0 +1,412 @@

+# UNIFYING GRAPH CONVOLUTIONAL NEURAL NETWORKS AND LABEL PROPAGATION
+Anonymous authors Paper under double-blind review
+# ABSTRACT
+Label Propagation (LPA) and Graph Convolutional Neural Networks (GCN) are both message passing algorithms on graphs. Both solve the task of node classification but LPA propagates node label information across the edges of the graph, while GCN propagates and transforms node feature information. However, while conceptually similar, it is unclear how LPA and GCN can be combined under a unified framework to improve node classification. Here we study the relationship between LPA and GCN in terms of feature/label influence, in which we characterize how much the initial feature/label of one node influences the final feature/label of another node in GCN/LPA. Based on our theoretical analysis, we propose an end-to-end model that combines GCN and LPA. In our unified model, edge weights are learnable, and the LPA serves as regularization to assist the GCN in learning proper edge weights that lead to improved classification performance. Our model can also be seen as learning the weights for edges based on node labels, which is more task-oriented than existing feature-based attention models and topology-based diffusion models. In a number of experiments on real-world graphs, our model shows superiority over state-of-the-art graph neural networks in terms of node classification accuracy.
+# 1 INTRODUCTION
+Consider the problem of node classification in a graph, where the goal is to learn a mapping $\mathcal { M } :$ $\nu  \mathcal { L }$ from node set $\nu$ to label set $\mathcal { L }$ . Solution to this problem is widely applicable to various scenarios, e.g., inferring income of users in a social network or classifying scientific articles in a citation network. Different from a generic machine learning problem where samples are independent from each other, nodes are connected by edges in the graph, which provide additional information and require more delicate modeling. To capture the graph information, researchers have mainly designed models on the assumption that labels/features are correlated over the edges of the graph. In particular, on the label side $\mathcal { L }$ , node labels are propagated and aggregated along edges in the graph, which is known as Label Propagation Algorithm (LPA) (Zhu et al., 2005; Zhou et al., 2004; Zhang & Lee, 2007; Wang & Zhang, 2008; Karasuyama & Mamitsuka, 2013; Gong et al., 2017; Liu et al., 2019a); On the node side $\nu$ , node features are propagated along edges and transformed through neural network layers, which is known as Graph Convolutional Neural Networks (GCN)1 (Kipf & Welling, 2017; Hamilton et al., 2017; Li et al., 2018; Xu et al., 2018; Liao et al., 2019; Xu et al., 2019b; Qu et al., 2019).
+GCN and LPA are related in that they propagate features and labels on the two sides of the mapping $\mathcal { M }$ , respectively. Prior work Li et al. (2019) has shown the relationship between GCN and LPA in terms of low-pass graph filtering. However, it is unclear how the discovered relationship benefits node classification. Specifically, can GCN and LPA be combined to develop a more accurate model for node classification in graphs?
+Here we study the theoretical relationship between GCN and LPA from the viewpoint of feature/label influence, where we quantify how much the initial feature/label of node $v _ { b }$ influences the output feature/label of node $v _ { a }$ in GCN/LPA by studying the Jacobian/gradient of node $v _ { b }$ with respect to node $v _ { a }$ . We also prove the quantitative relationship between feature influence and label influence, i.e., the label influence of $v _ { b }$ on $v _ { a }$ equals the cumulative discounted feature influence of $v _ { b }$ on $v _ { a }$ in expectation (Theorem 1).
+Based on the theoretical analysis, we propose a unified model GCN-LPA for node classification. We show that the key to improving the performance of GCN is to enable nodes of the same class to connect more strongly with each other by making edge weights/strengths trainable. Then we prove that increasing the strength of edges between the nodes of the same class is equivalent to increasing the accuracy of LPA’s predictions (Theorem 2). Therefore, we can first learn the optimal edge weights by minimizing the loss of predictions in LPA, then plug the optimal edge weights into a GCN to learn node representations. In GCN-LPA, we further combine the above two steps together and train the whole model in an end-to-end fashion, where the LPA part serves as regularization to assist the GCN part in learning proper edge weights that benefit the separation of different node classes. It is worth noticing that GCN-LPA can also be seen as learning the weights for edges based on node label information, which requires less handcrafting and is more task-oriented than existing attention models that learn edge weights based on node feature similarity (Velickoviˇ c et al.´ , 2018; Thekumparampil et al., 2018; Zhang et al., 2018; Liu et al., 2019b) or diffusion models that learn adjacency matrix based on graph topology (Klicpera et al., 2019a; Xu et al., 2019a; Abu-El-Haija et al., 2019; Klicpera et al., 2019b).
+We conduct extensive experiments on five datasets, and the results indicate that our model outperforms state-of-the-art graph neural networks in terms of classification accuracy. The experimental results also show that combining GCN and LPA together is able to learn more informative edge weights thereby leading to better performance.
+# 2 OUR APPROACH
+In this section, we first formulate the node classification problem and briefly introduce LPA and GCN. We then prove their relationship from the viewpoints of feature influence and label influence. Based on the theoretical finding, we propose a unified model GCN-LPA, and analyze why our model is theoretically superior to vanilla GCN.
+# 2.1 PROBLEM FORMULATION AND PRELIMINARIES
+Consider a graph $\mathcal { G } = ( \nu , A , X , Y )$ , where $\mathcal { V } = \{ v _ { 1 } , \cdots , v _ { n } \}$ is the set of nodes, $A \in \mathbb { R } ^ { n \times n }$ is the adjacency matrix, $X$ is the feature matrix of nodes and $Y$ is labels of nodes. $a _ { i j }$ (the $i j$ -th entry of $A$ ) is the weight of the edge connecting $v _ { i }$ and $v _ { j }$ . $\mathcal { N } ( v )$ denotes the set of first-order neighbors of node $v$ in graph $\mathcal { G }$ . Each node $v _ { i }$ has a feature vector $\mathbf { x } _ { i }$ which is the $i$ -th row of $X$ , while only the first $m$ nodes $( m \ll n )$ have labels $y _ { 1 } , \cdots , y _ { m }$ from a label set $\mathcal { L } = \{ 1 , \cdots , c \}$ . The goal is to learn a mapping $\mathcal { M } : \mathcal { V } \to \mathcal { L }$ and predict labels of unlabeled nodes.
+Label Propagation Algorithm. LPA (Zhu et al., 2005) assumes that two connected nodes are likely to have the same label, and thus it propagates labels iteratively along the edges. Let $Y ^ { ( k ) } =$ $[ y _ { 1 } ^ { ( k ) } , \cdot \cdot \cdot , y _ { n } ^ { ( k ) } ] ^ { \top } \in \mathbb { R } ^ { n \times c }$ ∈ Rn×c be the soft label matrix in iteration k > 0, in which the i-th row y(ki $y _ { i } ^ { ( k ) \top }$ denotes the predicted label distribution for node $v _ { i }$ in iteration $k$ . When $k = 0$ , the initial label matrix $Y ^ { ( 0 ) } = [ y _ { 1 } ^ { ( 0 ) } , \cdot \cdot \cdot , y _ { n } ^ { ( 0 ) } ] ^ { \top }$ consists of one-hot label indicator vectors $y _ { i } ^ { ( 0 ) }$ for $i = 1 , \cdots , m$ (i.e., labeled nodes) or zero vectors otherwise (i.e., unlabeled nodes). Then LPA in iteration $k$ is formulated as the following two steps:
+$$
+\begin{array} { c } { { Y ^ { ( k + 1 ) } = \tilde { A } Y ^ { ( k ) } , } } \\ { { y _ { i } ^ { ( k + 1 ) } = y _ { i } ^ { ( 0 ) } , \forall i \leq m . } } \end{array}
+$$
+In the above equations, $\tilde { A }$ is the normalized adjacency matrix, which can be the random walk transition matrix $\tilde { A } _ { r w } = D ^ { - 1 } A$ or the symmetric transition matrix $\tilde { A } _ { s y m } = D ^ { - \frac { 1 } { 2 } } A D ^ { - \frac { 1 } { 2 } }$ , where $D$ is the diagonal degree matrix for $A$ with entries $\begin{array} { r } { d _ { i i } = \sum _ { j } a _ { i j } } \end{array}$ . Without loss of generosity, we use $\tilde { A } = \tilde { A } _ { r w }$ in this work. In Eq. (1), all nodes propagate labels to their neighbors according to normalized edge weights. Then in Eq. (2), labels of all labeled nodes are reset to their initial values, because LPA wants to persist labels of nodes which are labeled, so that unlabeled nodes do not overpower the labeled ones as the initial labels would otherwise fade away.
+Graph Convolutional Neural Networks. GCN Kipf & Welling (2017) is a multi-layer feedforward neural network that propagates and transforms node features across the graph. The feature propagation scheme of GCN in layer $k$ is:
+$$
+X ^ { ( k + 1 ) } = \sigma \left( \tilde { A } X ^ { ( k ) } W ^ { ( k ) } \right) ,
+$$
+where $W ^ { ( k ) }$ is trainable weight matrix in the $k$ -th layer, $\sigma ( \cdot )$ is an activation function, and $X ^ { ( k ) } = [ \mathbf { x } _ { 1 } ^ { ( k ) } , \cdot \cdot \cdot , \mathbf { x } _ { n } ^ { ( k ) } ] ^ { \intercal }$ are the $k$ -th layer node representations with $X ^ { ( 0 ) } = X$ . By setting the dimension of the last layer to the number of classes $c$ , the last layer can be seen as (unnormalized) label distribution predicted for a given node. The whole model can thus be optimized by minimizing the discrepancy between predicted node label distributions and ground-truth labels $Y$ .
+# 2.2 FEATURE INFLUENCE AND LABEL INFLUENCE
+Consider two nodes $v _ { a }$ and $v _ { b }$ in a graph. Inspired by Koh & Liang (2017) and $\mathrm { X u }$ et al. (2018), we study the relationship between GCN and LPA in terms of influence, i.e., how the output feature/label of $v _ { a }$ will change if the initial feature/label of $v _ { b }$ is varied slightly. Technically, the feature/label influence is measured by the Jacobian/gradient of the output feature/label of $v _ { a }$ with respect to the initial feature/label of $v _ { b }$ . Denote $\mathbf { x } _ { a } ^ { ( k ) }$ as the $k$ -th layer representation vector of $v _ { a }$ in GCN, and $\mathbf { x } _ { b }$ as the initial feature vector of $v _ { b }$ . We quantify the feature influence of $v _ { b }$ on $v _ { a }$ as follows:
+Definition 1 (Feature influence) The feature influence of node $v _ { b }$ on node $v _ { a }$ after $k$ layers of GCN is the $L l$ -norm of the expected Jacobian matrix $\partial \mathbf { x } _ { a } ^ { ( k ) } / \partial \mathbf { x } _ { b }$ : $I _ { f } ( v _ { a } , v _ { b } ; k ) = \left. \mathbb { E } \big [ \partial \mathbf { x } _ { a } ^ { ( k ) } / \partial \mathbf { x } _ { b } \big ] \right. _ { 1 }$ . The normalized feature influence is then defined as $\begin{array} { r } { \tilde { I } _ { f } ( v _ { a } , v _ { b } ; k ) = I _ { f } ( v _ { a } , v _ { b } ; k ) / \sum _ { v _ { i } \in \mathcal { V } } I _ { f } ( v _ { a } , v _ { i } ; k ) } \end{array}$ .
+We also consider the label influence of node $v _ { b }$ on node $v _ { a }$ in LPA (this implies that $v _ { a }$ is unlabeled and $v _ { b }$ is labeled). Since different label dimensions of $y _ { i } ^ { ( \cdot ) }$ do not interact with each other in LPA, we assume that all $y _ { i }$ and $y _ { i } ^ { ( \cdot ) }$ are scalars within $[ 0 , 1 ]$ (i.e., this is a binary classification task) for simplicity. Label influence is defined as follows:
+Definition 2 (Label influence) The label influence of labeled node $v _ { b }$ on unlabeled node $v _ { a }$ after $k$ iterations of LPA is the gradient of $y _ { a } ^ { ( k ) }$ with respect to $y _ { b } \colon I _ { l } ( v _ { a } , v _ { b } ; k ) = \partial y _ { a } ^ { ( k ) } / \partial y _ { b }$ .
+The following theorem shows the relationship between feature influence and label influence:
+Theorem 1 (Relationship between feature influence and label influence) Assume the activation function used in GCN is ReLU. Denote $v _ { a }$ as an unlabeled node, $v _ { b }$ as a labeled node, and $\beta$ as the fraction of unlabeled nodes. Then the label influence of $v _ { b }$ on $v _ { a }$ after $k$ iterations of LPA equals, in expectation, to the cumulative normalized feature influence of $v _ { b }$ on $v _ { a }$ after $k$ layers of GCN:
+$$
+\mathbb { E } \big [ I _ { l } ( v _ { a } , v _ { b } ; k ) \big ] = \sum _ { j = 1 } ^ { k } \beta ^ { j } \tilde { I } _ { f } ( v _ { a } , v _ { b } ; j ) .
+$$
+Proof of Theorem 1 is in Appendix A. Intuitively, Theorem 1 shows that if $v _ { b }$ has high label influence on $v _ { a }$ , then the initial feature vector of $v _ { b }$ will also affect the output feature vector of $v _ { a }$ greatly. Theorem 1 provides the theoretical guideline for designing our unified model in the next subsection.
+# 2.3 THE UNIFIED MODEL
+Before introducing the proposed model, we rethink the GCN method and see what an ideal set of node representations should be like. Since we aim to classify nodes, the perfect node representation would be such that nodes with the same label are embedded closely together, which would give a large separation between different classes. Intuitively, the key to achieve this goal is to enable nodes within the same class to connect more strongly with each other, so that they are pushed together by GCN (more discussion is presented in Section 2.4). We can therefore make edge strengths/weights trainable, then learn to increase the intra-class feature influence: $\begin{array} { r } { \sum _ { i \in \mathcal { L } } \sum _ { v _ { a } , v _ { b } : y _ { a } = i , y _ { b } = i } \tilde { I } _ { f } ( v _ { a } , v _ { b } ) } \end{array}$ ( $\mathcal { L }$ is the label set), by adjusting edge weights. However, this requires operating on Jacobian matrices with the size of $d ^ { ( 0 ) } \times d ^ { ( \mathrm { \bar { \tiny { K } } } ) }$ $\bar { \boldsymbol { d } } ^ { ( 0 ) }$ and $d ^ { ( K ) }$ are the dimensions of input and output in GCN, respectively), which is impractical if initial node features are high-dimensional. Fortunately, we can turn to optimizing the intra-class label influence instead, i.e., $\begin{array} { r } { \dot { \sum _ { i \in \mathcal { L } } } \sum _ { v _ { a } , v _ { b } : y _ { a } = i , y _ { b } = i } I _ { l } ( v _ { a } , v _ { b } ) } \end{array}$ , according to Theorem 1. Note that $\begin{array} { r } { \sum _ { i \in \mathcal { L } } \sum _ { v _ { a } , v _ { b } : y _ { a } = i , y _ { b } = i } I _ { l } ( v _ { a } , v _ { b } ) = \sum _ { v _ { a } } \sum _ { v _ { b } : y _ { b } = y _ { a } } I _ { l } ( v _ { a } , v _ { b } ) } \end{array}$ . We further show, by the following theorem, that the term $\scriptstyle \sum _ { v _ { b } : y _ { b } = y _ { a } } I _ { l } ( v _ { a } , v _ { b } )$ (the total intra-class label influence on a given node $v _ { a }$ ) is proportional to the probability that $v _ { a }$ is classified correctly by LPA:
+Theorem 2 (Relationship between label influence and LPA’s prediction) Consider a given node $v _ { a }$ and its label $y _ { a }$ . If we treat node $v _ { a }$ as unlabeled, then the total label influence of nodes with label $y _ { a }$ on node $v _ { a }$ is proportional to the probability that node $v _ { a }$ is classified as $y _ { a }$ by $L P A$ :
+$$
+\sum _ { v _ { b } : y _ { b } = y _ { a } } I _ { l } ( v _ { a } , v _ { b } ; k ) \propto \mathrm { P r } \big ( \hat { y } _ { a } ^ { l p a } = y _ { a } \big ) ,
+$$
+where $\hat { y } _ { a } ^ { l p a }$ is the predicted label of $v _ { a }$ using a $k$ -iteration $L P A$
+Proof of Theorem 2 is in Appendix B. Theorem 2 indicates that, if edge weights $\{ a _ { i j } \}$ maximize the probability that $v _ { a }$ is correctly classified by LPA, then they also maximize the intra-class label influence on node $v _ { a }$ . We can therefore first learn the optimal edge weights $A ^ { * }$ by minimizing the loss of predicted labels by LPA:2
+$$
+A ^ { * } = \underset { A } { \arg \operatorname* { m i n } } L _ { l p a } ( A ) = \underset { A } { \arg \operatorname* { m i n } } \ \frac { 1 } { m } \sum _ { v _ { a } : a \leq m } J ( \hat { y } _ { a } ^ { l p a } , y _ { a } ) ,
+$$
+where $J$ is the cross-entropy loss, $\hat { y } _ { a } ^ { l p a }$ and $y _ { a }$ are the predicted label distribution of $v _ { a }$ using LPA and the true one-hot label of $v _ { a }$ , respectively. $a \leq m$ means $v _ { a }$ is labeled. The optimal $A ^ { * }$ maximizes the probability that each node is correctly labeled by LPA, thus also maximizes the intra-class label influence (according to Theorem 2) and intra-class feature influence (according to Theorem 1). Since $A ^ { * }$ increases the connection strength within each class, it is expected to improve the performance of GCN compared with the original adjacency matrix $A$ . Therefore, we can plug $A ^ { * }$ into GCN to predict labels:
+$$
+X ^ { ( k + 1 ) } = \sigma ( A ^ { * } X ^ { ( k ) } W ^ { ( k ) } ) , k = 0 , 1 , \cdots , K - 1 .
+$$
+We use $\hat { y } _ { a } ^ { g c n }$ , the $a$ -th row of $X ^ { ( K ) }$ , to denote the predicted label distribution of $v _ { a }$ using the GCN specified in Eq. (7). Then the optimal transformation matrices in the GCN can be learned by minimizing the loss of predicted labels by GCN:
+$$
+W ^ { * } = \arg \operatorname* { m i n } _ { W } L _ { g c n } ( W , A ^ { * } ) = \arg \operatorname* { m i n } _ { W } \frac { 1 } { m } \sum _ { v _ { a } : a \leq m } J ( \hat { y } _ { a } ^ { g c n } , y _ { a } ) ,
+$$
+It is more elegant (and empirically better) to combine the above two steps together into a multiobjective optimization problem, and train the whole model in an end-to-end fashion:
+$$
+W ^ { * } , A ^ { * } = \underset { W , A } { \arg \operatorname* { m i n } } \ L _ { g c n } ( W , A ) + \lambda L _ { l p a } ( A ) ,
+$$
+where $\lambda$ is the balancing hyper-parameter. In this way, $L _ { l p a } ( A )$ serves as a regularization term that assists the learning of edge weights $A$ , since it is hard for GCN to learn both $W$ and $A$ simultaneously due to overfitting. The proposed GCN-LPA approach can also be seen as learning the importance of edges that can be used to reconstruct node labels accurately by LPA, then transferring this knowledge from label space to feature space for GCN.
+It is also worth noticing how the optimal $A ^ { * }$ is configured. The principle here is that we do not modify the basic structure of the original graph (i.e., not adding or removing edges) but only adjusting weights of existing edges. This is equivalent to learning a positive mask matrix $M$ for the adjacency matrix $A$ and taking the Hadamard product $M \circ A = A ^ { * }$ . Each element $M _ { i j }$ can be set as either a free variable or a function of the two nodes, for example, $M _ { i j } = \log \left( \exp ( \mathbf { x } _ { i } ^ { \top } \mathbf { H } \mathbf { x } _ { j } ) + 1 \right)$ where $\mathbf { H }$ is a learnable kernel matrix for measuring feature similarity.
+# 2.4 ANALYSIS OF GCN-LPA MODEL BEHAVIOR
+In this subsection, we show benefits of our unified model compared with GCN by analyzing properties of embeddings produced by the two models. We first analyze the update rule of GCN for node $\begin{array} { r } { \mathbf { \Phi } _ { \upsilon i } \colon \mathbf { x } _ { i } ^ { ( k + 1 ) } = \sigma \left( \sum _ { v _ { j } \in \mathcal { N } ( v _ { i } ) } \tilde { a } _ { i j } \mathbf { x } _ { j } ^ { ( k ) } W ^ { ( k ) } \right) } \end{array}$ , where $\tilde { a } _ { i j } = a _ { i j } / d _ { i i }$ is the normalized weight of edge $( j , i )$ . This formula can be decomposed into the following two steps: (1) In aggregation step, we calculate the aggregated representation ${ \bf h } _ { i } ^ { ( k ) }$ of all neighborhoods $\begin{array} { r } { \mathcal { N } ( v _ { i } ) \colon { \mathbf { h } } _ { i } ^ { ( k ) } = \sum _ { v _ { j } \in \mathcal { N } ( v _ { i } ) } \tilde { a } _ { i j } { \mathbf { x } } _ { j } ^ { ( k ) } } \end{array}$ (2) In transformation step, the aggregated representation ${ \bf h } _ { i } ^ { ( k ) }$ is mapped to a new space by a transformation matrix and nonlinear function: x(k+1)i = σh(k)i W (k). We show by the following theorem that the aggregation step reduces the overall distance in the embedding space between the nodes that are connected in the graph:
+Theorem 3 (Shrinking property in GCN) Let $\begin{array} { r } { D ( \mathbf { x } ) = \frac { 1 } { 2 } \sum _ { v _ { i } , v _ { j } } \widetilde { a } _ { i j } \| \mathbf { x } _ { i } - \mathbf { x } _ { j } \| _ { 2 } ^ { 2 } } \end{array}$ be a distance metric over node embeddings x. Then we have $D ( \mathbf { h } ^ { ( k ) } ) \leq D ( \mathbf { x } ^ { ( k ) } )$ .
+Proof of Theorem 3 is in Appendix C. Theorem 3 indicates that the overall distance among connected nodes is reduced after taking one aggregation step, which implies that connected components in the graph “shrink” and nodes within each connected component get closer to each other in the embedding space. In an ideal case where edges only connect nodes with the same label, the aggregation step will push nodes within the same class together, which greatly benefits the transformation step that acts like using a hyperplane $W ^ { ( k ) }$ for classification. However, two connected nodes may have different labels. These “noisy” edges will impede the formation of clusters and make the interclass boundary less clear.
+Fortunately, in GCN-LPA, edge weights are learned by minimizing the difference between ground-truth labels and labels reconstructed
+![](images/9825536a37154ab50e035bbf48b2a28cdb0bb40f69695acd0d2dbfcaa0fd3973.jpg)
+Figure 1: A graph with two classes of nodes, while white nodes are unlabeled (Figure 1a). To classify nodes, our model will increase the connecting strength among nodes within the same class, thereby increasing their feature/label influence on each other. In this way, our model is able to identify potential intra-class edges (bold links in Figure 1b) and strengthen their weights.
+from local neighbors. This will force the model to increase the weight/bandwidth of possible paths that connect nodes with the same label, so that labels can “flow” easily along these paths for the purpose of label reconstruction. In this way, GCN-LPA is able to identify potential intra-class edges and increase their weights to assist learning clustering structures ( see Figure 1 for an illustrating example).
+To empirically justify our claim, we apply a two-layer untrained GCN with randomly initialized transformation matrices to the well-known Zachary’s karate club network (Zachary, 1977) as shown in Figure 2a, which contains 34 nodes of 2 classes and 78 unweighted edges (grey solid lines). We then increase the weights of intra-class edges by ten times to simulate GCN-LPA. We find that GCN works well on this network (Figure 2b), but GCN-LPA performs even better than GCN because the node embeddings are completely linearly separable as shown in Figure 2c. To further justify our claim, we randomly add 20 “noisy” inter-class edges (grey dotted lines) to the original network, from which we observe that GCN is misled by noise and mixes nodes of two classes together (Figure 2d), but GCN-LPA still distinguishes the two clusters (Figure 2e) because it is better at “denoising” undesirable edges based on the supervised signal of labels.
+# 3 CONNECTION TO EXISTING WORK
+Edge weights play a key role in graph-based machine learning algorithms. In this section, we discuss three lines of related work that learn edge weights adaptively.
+![](images/8b89d54087379580a1fbf7d646ab988e468f16e6f929c417af73e0bd5bd30559.jpg)
+Figure 2: Node embeddings of Zachary’s karate club network trained on a node classification task (red vs. blue). Figure 2a visualizes the graph. Node coordinates in Figure 2b-2e are the embedding coordinates. Notice that GCN does not produce linearly separable embeddings (Figure 2b vs. Figure 2c), while GCN-LPA performs much better even in the presence of noisy edges (Figure 2d vs. Figure 2e). Additional visualizations are included in Appendix D.
+Locally Linear Embedding. Locally linear embedding (LLE) (Roweis & Saul, 2000) and its variants (Zhang & Wang, 2007; Kong et al., 2012) learn edge weights by constructing a linear dependency between a node and its neighbors, then use the learned edge weights to embed highdimensional nodes into a low-dimensional space. Our work is similar to LLE in the aspect of transferring the knowledge of edge importance from one space to another, but the difference is that LLE is an unsupervised dimension reduction method that learns the graph structure based on local proximity only, while our work is semi-supervised and explores high-order relationship among nodes.
+Label Propagation Algorithm. Classical LPA (Zhu et al., 2005; Zhou et al., 2004) can only make use of node labels rather than node features. In contrast, adaptive LPA considers node features by making edge weights learnable. Typical techniques of learning edge weights include adopting kernel functions (Zhu et al., 2003; Liu et al., 2019a) (e.g., $a _ { i j } \ = \ \mathrm { { e x p } } ( - { \textstyle \sum } _ { d } ( x _ { i d } - x _ { j d } ) ^ { 2 } / \sigma _ { d } ^ { 2 } )$ where $d$ is dimensionality of features), minimizing neighborhood reconstruction error (Wang & Zhang, 2008; Karasuyama & Mamitsuka, 2013), using leave-one-out loss (Zhang & Lee, 2007), or imposing sparseness on edge weights (Hong et al., 2009). However, in these LPA variants, node features are only used to assist learning the graph structure rather than explicitly mapped to node labels, which limits their capability in node classification. Another notable difference is that adaptive LPA learns edge weights by introducing the regularizations above, while our work takes LPA itself as regularization to learn edge weights.
+Attention and Diffusion on Graphs. Our method is also conceptually connected to attention mechanism on graphs, in which an attention weight $\alpha _ { i j }$ is learned between node $v _ { i }$ and $v _ { j }$ . For example, $\alpha _ { i j } = \mathrm { L e a k y R e L U } ( a ^ { \top } [ W \mathbf { x } _ { i } | | W \mathbf { x } _ { j } ] )$ in GAT (Velickovi ˇ c et al. ´ , 2018), $\alpha _ { i j } = a \cdot \cos ( W \mathbf { x } _ { i } , W \mathbf { x } _ { j } )$ in AGNN (Thekumparampil et al., 2018), $\alpha _ { i j } = ( W _ { 1 } \mathbf { x } _ { i } ) ^ { \top } W _ { 2 } \mathbf { x } _ { j }$ in GaAN (Zhang et al., 2018), and $\alpha _ { i j } = \pmb { a } ^ { \top } \operatorname { t a n h } ( W _ { 1 } \mathbf { x } _ { i } + W _ { 2 } \mathbf { x } _ { j } )$ in GeniePath (Liu et al., 2019b), where $a$ and $W$ are trainable variables. Our method is also similar to diffusion-based methods (Klicpera et al., 2019a; Xu et al., 2019a; Abu-El-Haija et al., 2019; Klicpera et al., 2019b; Jiang et al., 2019; Yang et al., 2019). Graph diffusion uses extended neighborhoods for aggregation in GNNs, which can be seen as learning a new adjacency matrix for a given graph. A significant difference between attention/diffusion mechanisms and our work is that attention/diffusion is learned based on feature similarity/graph topology, while we propose that edge weights should be consistent with the distribution of labels on the graph, which requires less handcrafting of the attention/diffusion function and is more task-oriented.
+# 4 EXPERIMENTS
+# 4.1 EXPERIMENT SETUP
+Datasets. We use the following five datasets in our experiments. Cora, Citeseer, and Pubmed (Sen et al., 2008) are citation networks, where nodes correspond to documents, edges correspond to citation links, and each node has a sparse bag-of-words feature vector as well as a class label. We also use two co-authorship networks (Shchur et al., 2018), Coauthor-CS and Coauthor-Phy, where nodes are authors and an edge indicates that two authors co-authored a paper. Node features represent paper keywords for each author’s papers, and class labels indicate most active fields of
+<table><tr><td>Method</td><td>Cora</td><td>Citeseer</td><td>Pubmed</td><td>Coauthor-CS</td><td>Coauthor-Phy</td></tr><tr><td>LR</td><td>57.1 ± 2.3</td><td>61.0±2.2</td><td>64.1 ± 3.1</td><td>86.4±0.9</td><td>86.7±1.5</td></tr><tr><td>LPA</td><td>74.4± 2.6</td><td>67.8 ± 2.1</td><td>70.5 ± 5.3</td><td>73.6 ± 3.9</td><td>86.6 ± 2.0</td></tr><tr><td>GCN</td><td>81.4 ± 1.3</td><td>71.9 ± 1.9</td><td>77.5 ± 2.9</td><td>91.1 ± 0.5</td><td>92.4 ± 1.0</td></tr><tr><td>GAT</td><td>80.7 ±1.3</td><td>71.4 ± 1.9</td><td>76.7 ± 2.3</td><td>90.5 ± 0.6</td><td>92.2 ± 0.9</td></tr><tr><td>JK-Net</td><td>81.3 ± 1.4</td><td>70.2 ±1.3</td><td>77.6 ± 0.9</td><td>90.3 ± 0.4</td><td>91.0 ± 0.7</td></tr><tr><td>GIN</td><td>74.5 ± 1.5</td><td>60.7 ±1.3</td><td>73.4 ±1.2</td><td>84.1 ± 1.9</td><td>87.3 ±1.7</td></tr><tr><td>GDC</td><td>83.2 ± 0.9</td><td>72.2 ±1.4</td><td>77.8 ± 0.8</td><td>91.4 ± 1.0</td><td>92.0± 0.7</td></tr><tr><td>GCN+LPA</td><td>78.4± 0.7</td><td>69.8 ± 1.4</td><td>74.1 ± 0.9</td><td>84.5 ±1.0</td><td>89.7 ± 0.8</td></tr><tr><td>GCN-LPA</td><td>83.0±1.4</td><td>72.6± 0.9</td><td>78.4 ± 1.5</td><td>91.9± 0.9</td><td>93.4± 1.6</td></tr></table>
+Table 1: Mean and the $9 5 \%$ confidence intervals of test set accuracy for all methods and datasets.
+![](images/f2e00f387ed5dd75968b2e3dee9711338c82e71e21c227901943451cea3df114.jpg)
+Figure 3: Sensitivity to the number of LPA iterations on Citeseer dataset.
+![](images/2739308ba9dc241429355300c63f9ecee44905c7a88e31e0c6d8c41dd3291e12.jpg)
+Figure 4: Sensitivity to $\lambda$ (weight of LPA loss) on Citeseer dataset.
+![](images/b8eb7838ea7c122c499093fc31310f4c5ee59e5087729ed812b8387432c2c282.jpg)
+Figure 5: Training time per epoch on random graphs.
+study for each author. Statistics of the five datasets are shown in Appendix E. We also calculate the intra-class edge rate (the fraction of edges that connect two nodes within the same class), which is significantly higher than inter-class edge rate in all networks. The finding supports our claim in Section 2.4 that node classification benefits from intra-class edges in a graph.
+Baselines. We compare against the following baselines in our experiments. Logistic Regression (LR) is feature-based methods that do not consider the graph structure. Label Propagation (LPA) (Zhu et al., 2005), on the other hand, only consider the graph structure and ignore node features. We also compare with several GNNs: Graph Convolutional Network (GCN) (Kipf & Welling, 2017), Graph Attention Network (GAT), Jumping Knowledge Network (JK-Net) (Xu et al., 2018), Graph Isomorphism Network (GIN) (Xu et al., 2019b), and Graph Diffusion Convolution (GDC) (Klicpera et al., 2019b) (with GCN as the base model). In addition, we propose another baseline $\mathbf { G C \bar { N } + L P A }$ , which simply adds predictions of GCN and LPA together.
+Experimental Setup. Our experiments focus on the transductive setting where we only know labels of part of nodes but have access to the entire graph as well as features of all nodes.3 We randomly sample 20 nodes per class as training set, 50 nodes per class as validation set, and the remaining nodes as test set. The weight of each edge is treated as a free variable during training. We train our model for 200 epochs using Adam (Kingma & Ba, 2015) and report the test set accuracy when validation set accuracy is maximized. Each experiment is repeated five times and we report the mean and the $9 5 \%$ confidence interval. We initialize weights according to Glorot & Bengio (2010) and row-normalize input features. During training, we apply L2 regularization to the transformation matrices and use the dropout technique (Srivastava et al., 2014). The settings of all other hyperparameters can be found in Appendix F.
+# 4.2 RESULTS
+Comparison with Baselines. The results of node classification are summarized in Table 1. Table 1 indicates that only using node features (LR) or graph structure (LPA) will lead to information loss and cannot fully exploit datasets. The results demonstrate that our proposed GCN-LPA model surpasses state-of-the-art GNN baselines. We notice that GDC is a strong baseline on Cora, but it does not perform consistently well on other datasets. In addition, $\mathrm { G C N + L P A }$ does not perform well, since it utilizes the prediction of LPA directly, making its performance limited by LPA.
+<table><tr><td>Labeled node rate</td><td>5%</td><td>10%</td><td>20%</td><td>50%</td><td>80%</td></tr><tr><td>LPA</td><td>67.9 ± 2.1</td><td>68.1 ± 1.3</td><td>70.5± 1.5</td><td>72.5 ± 1.2</td><td>76.4 ±1.1</td></tr><tr><td>GCN</td><td>72.1 ± 1.9</td><td>72.5 ± 1.8</td><td>74.3 ± 0.9</td><td>76.8 ± 0.6</td><td>80.2 ±1.5</td></tr><tr><td>GCN-LPA</td><td>72.7 ± 1.2</td><td>73.2 ± 1.1</td><td>75.4 ± 1.5</td><td>78.2 ± 1.3</td><td>82.3 ± 0.9</td></tr></table>
+Table 2: Accuracy of LPA, GCN, and GCN-LPA on Citeseer with different labeled node rate.
+Efficacy of LPA Regularization. We investigate the influence of the number of LPA iterations and the training weight of LPA loss term $\lambda$ on the performance of classification. The results on Citeseer dataset are plotted in Figures 3 and 4, respectively, where each line corresponds to a given number of GCN layers in GCN-LPA. From Figure 3 we observe that the performance is boosted at first when the number of LPA iterations increases, then the accuracy stops increasing and decreases since a large number of LPA iterations will include more noisy nodes. Figure 4 shows that training without the LPA loss term (i.e., $\lambda = 0$ ) is more difficult than the case where $\lambda = 1 \sim 5$ , which justifies our aforementioned claim that it is hard for the GCN part to learn both transformation matrices $W$ and edge weights $A$ simultaneously without the assistance of LPA regularization.
+Influence of Labeled Node Rate. To study the influence of labeled node rate on the performance of our model, we vary the ratio of labeled node rate on Citeseer from $5 \%$ to $8 0 \%$ while keeping the validation and test set fixed, and report the result in Table 2. From Table 2 we observe that GCN-LPA outperforms GCN and LPA consistently, and the improvement achieved by GCN-LPA increases when labeled node rate is larger (from $0 . 6 \%$ to $2 . 1 \%$ compared with GCN). This is because GCN-LPA requires node labels to calculate edge weights. Therefore, a larger labeled node rate will provide more information for identifying noisy edges.
+Visualization of Learned Edge Weights. To intuitively understand what our model learns about edge weights, we split nodes in CoauthorCS dataset into 15 groups according to their labels, and calculate the average weights of edges connecting every pair of node groups as well as the average weights of edges within every group. The results are shown in Figure 6, where darker color indicates higher average weights of edges. It is clear that values along the diagonal (intra-class edges weights) are significantly larger than off-diagonal values (inter-class edge weights) in general, which demonstrates that GCN-LPA is able to identify the importance of edges and distinguish inter-class and intraclass edges. The visualization results are similar for other datasets.
+Time Complexity. We study the training time of GCN-LPA on random graphs. We use the one-hot identity vector as feature and 0 as label for each node. The size of training set and validation set is 100 and 200, respectively, while the rest is test set. The average number of neighbors for each node is set as 5, and the number of nodes is varied from one thousand to one million. We run GCN-LPA and GCN for 100 epochs on a Microsoft Azure virtual machine with 1 NVIDIA Tesla M60 GPU, 12 Intel Xeon CPUs $\left( \mathrm { E 5 - } 2 6 9 0 \mathrm { v } 3 @ 2 . 6 0 \mathrm { G H z } \right)$ , and 128GB of RAM, using the same hyper-parameter setting as in Cora. The training time per epoch of GCN-LPA and GCN is presented in Figure 5. Our result shows that GCN-LPA requires only $9 . 2 \%$ extra training time on average compared to GCN.
+![](images/12752225748b0306fa8c5f9ff6a59d1eb807ee3556ff1e27994a80b83cb73e9a.jpg)
+Figure 6: Visualization of learned edge weights in Coauthor-CS dataset.
+# 5 CONCLUSION
+We studies the theoretical relationship between two types of well-known graph-based algorithms for node classification, label propagation algorithm and graph convolutional neural networks, from the perspectives of feature/label influence. We then propose a unified model GCN-LPA, which learns transformation matrices and edge weights simultaneously in GCN with the assistance of LPA regularizer. We also analyze why our unified model performs better than traditional GCN in terms of node classification. Experiments on five datasets demonstrate that our model outperforms stateof-the-art baselines, and it is also highly time-efficient with respect to the size of a graph.
+# REFERENCES
+Sami Abu-El-Haija, Bryan Perozzi, Amol Kapoor, Nazanin Alipourfard, Kristina Lerman, Hrayr Harutyunyan, Greg Ver Steeg, and Aram Galstyan. Mixhop: Higher-order graph convolutional architectures via sparsified neighborhood mixing. In Proceedings of the 36th International Conference on Machine Learning, pp. 21–29, 2019.
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the 13th International Conference on Artificial Intelligence and Statistics, 2010.
+Chen Gong, Dacheng Tao, Wei Liu, Liu Liu, and Jie Yang. Label propagation via teaching-tolearn and learning-to-teach. IEEE Transactions on Neural Networks and Learning Lystems, 28 (6), 2017.
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, 2017.
+Cheng Hong, Zicheng Liu, and Jie Yang. Sparsity induced similarity measure for label propagation. In Proceedings of the 12th IEEE International Conference on Computer Vision. IEEE, 2009.
+Bo Jiang, Ziyan Zhang, Doudou Lin, Jin Tang, and Bin Luo. Semi-supervised learning with graph learning-convolutional networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 11313–11320, 2019.
+Masayuki Karasuyama and Hiroshi Mamitsuka. Manifold-based similarity adaptation for label propagation. In Advances in Neural Information Processing Systems, 2013.
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Proceedings of the 3rd International Conference on Learning Representations, 2015.
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In Proceedings of the 5th International Conference on Learning Representations, 2017.
+Johannes Klicpera, Aleksandar Bojchevski, and Stephan Gunnemann. Predict then propagate:¨ Graph neural networks meet personalized pagerank. In Proceedings of the 7th International Conference on Learning Representations, 2019a.
+Johannes Klicpera, Stefan Weißenberger, and Stephan Gunnemann. Diffusion improves graph learn- ¨ ing. In Advances in Neural Information Processing Systems, pp. 13354–13366, 2019b.
+Pang Wei Koh and Percy Liang. Understanding black-box predictions via influence functions. In Proceedings of the 34th International Conference on Machine Learning, 2017.
+Deguang Kong, Chris Ding, Heng Huang, and Feiping Nie. An iterative locally linear embedding algorithm. In Proceedings of the 29th International Coference on International Conference on Machine Learning. Omnipress, 2012.
+Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi-supervised learning. In The 32nd AAAI Conference on Artificial Intelligence, 2018.
+Qimai Li, Xiao-Ming Wu, Han Liu, Xiaotong Zhang, and Zhichao Guan. Label efficient semisupervised learning via graph filtering. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9582–9591, 2019.
+Renjie Liao, Zhizhen Zhao, Raquel Urtasun, and Richard S Zemel. Lanczosnet: Multi-scale deep graph convolutional networks. In Proceedings of the 7th International Conference on Learning Representations, 2019.
+Yanbin Liu, Juho Lee, Minseop Park, Saehoon Kim, Eunho Yang, Sung Ju Hwang, and Yi Yang. Learning to propagate labels: Transductive propagation network for few-shot learning. In Proceedings of the 7th International Conference on Learning Representations, 2019a.
+Ziqi Liu, Chaochao Chen, Longfei Li, Jun Zhou, Xiaolong Li, Le Song, and Yuan Qi. Geniepath: Graph neural networks with adaptive receptive paths. In The 33rd AAAI Conference on Artificial Intelligence, 2019b.
+Meng Qu, Yoshua Bengio, and Jian Tang. Gmnn: Graph markov neural networks. In Proceedings of the 36th International Conference on Machine Learning, 2019.
+Ryan A Rossi, Luke K McDowell, David William Aha, and Jennifer Neville. Transforming graph data for statistical relational learning. Journal of Artificial Intelligence Research, 45:363–441, 2012.
+Sam T Roweis and Lawrence K Saul. Nonlinear dimensionality reduction by locally linear embedding. science, 290(5500), 2000.
+Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3), 2008.
+Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Gunnemann. Pitfalls ¨ of graph neural network evaluation. In Neural Information Processing Systems Workshop on Relational Representation Learning, 2018.
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1), 2014.
+Kiran K Thekumparampil, Chong Wang, Sewoong Oh, and Li-Jia Li. Attention-based graph neural network for semi-supervised learning. arXiv preprint arXiv:1803.03735, 2018.
+Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. In Proceedings of the 6th International Conference on Learning Representations, 2018.
+Fei Wang and Changshui Zhang. Label propagation through linear neighborhoods. IEEE Transactions on Knowledge and Data Engineering, 20(1), 2008.
+Bingbing Xu, Huawei Shen, Qi Cao, Keting Cen, and Xueqi Cheng. Graph convolutional networks using heat kernel for semi-supervised learning. In Proceedings of the 28th International Joint Conference on Artificial Intelligence, pp. 1928–1934. AAAI Press, 2019a.
+Keyulu Xu, Chengtao Li, Yonglong Tian, Tomohiro Sonobe, Ken-ichi Kawarabayashi, and Stefanie Jegelka. Representation learning on graphs with jumping knowledge networks. In Proceedings of the 35th International Conference on Machine Learning, 2018.
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In Proceedings of the 7th International Conference on Learning Representations, 2019b.
+Liang Yang, Zesheng Kang, Xiaochun Cao, Di Jin, Bo Yang, and Yuanfang Guo. Topology optimization based graph convolutional network. In IJCAI, pp. 4054–4061, 2019.
+Wayne W Zachary. An information flow model for conflict and fission in small groups. Journal of anthropological research, 33(4), 1977.
+Jiani Zhang, Xingjian Shi, Junyuan Xie, Hao Ma, Irwin King, and Dit-Yan Yeung. Gaan: Gated attention networks for learning on large and spatiotemporal graphs. arXiv preprint arXiv:1803.07294, 2018.
+Xinhua Zhang and Wee S Lee. Hyperparameter learning for graph based semi-supervised learning algorithms. In Advances in Neural Information Processing Systems, 2007.
+Zhenyue Zhang and Jing Wang. Mlle: Modified locally linear embedding using multiple weights. In Advances in Neural Information Processing Systems, 2007.
+Dengyong Zhou, Olivier Bousquet, Thomas N Lal, Jason Weston, and Bernhard Scholkopf. Learn- ¨ ing with local and global consistency. In Advances in Neural Information Processing Systems, 2004.
+Xiaojin Zhu, Zoubin Ghahramani, and John D Lafferty. Semi-supervised learning using gaussian fields and harmonic functions. In Proceedings of the 20th International Conference on Machine Learning, 2003.
+Xiaojin Zhu, John Lafferty, and Ronald Rosenfeld. Semi-supervised learning with graphs. PhD thesis, Carnegie Mellon University, school of language technologies institute, 2005.
+# APPENDIX
+A PROOF OF THEOREM 1
+Before proving Theorem 1, we first give two lemmas that demonstrate the exact form of feature influence and label influence defined in this paper. The relationship between feature influence and label influence can then be deduced from their exact forms.
+Lemma 1 Assume that the nonlinear activation function in GCN is ReLU. Let $\mathcal { P } _ { k } ^ { a  b }$ be a path $[ v ^ { ( k ) } , v ^ { ( k - 1 ) } , \cdot \cdot \cdot , v ^ { ( 0 ) } ]$ of length $k$ from node $v _ { a }$ to node $v _ { b }$ , where $\boldsymbol { v } ^ { ( k ) } = \boldsymbol { v } _ { a }$ , $\boldsymbol { v } ^ { ( 0 ) } = \boldsymbol { v } _ { b }$ , and $v ^ { ( i - 1 ) } \in \mathcal { N } ( v ^ { ( i ) } ) f o r i = k , \cdots , 1$ . Then we have
+$$
+\tilde { I } _ { f } ( v _ { a } , v _ { b } ; k ) = \sum _ { \mathcal { P } _ { k } ^ { a  b } } \prod _ { i = k } ^ { 1 } \tilde { a } _ { v ^ { ( i - 1 ) } , v ^ { ( i ) } } ,
+$$
+where $\tilde { a } _ { v ^ { ( i - 1 ) } , v ^ { ( i ) } }$ is the normalized weight of edge $( v ^ { ( i ) } , v ^ { ( i - 1 ) } )$ .
+Proof. See $\mathrm { X u }$ et al. (2018) for the detailed proof.
+The product term in Eq. (10) is the probability of a given path $\mathcal { P } _ { k } ^ { a  b }$ . Therefore, the right hand side in Eq. (10) is the sum over probabilities of all possible paths of length $k$ from $v _ { a }$ to $v _ { b }$ , which is the probability that a random walk starting at $v _ { a }$ ends at $v _ { b }$ after taking $k$ steps.
+Lemma 2 Let $\mathcal { U } _ { j } ^ { a  b }$ be a path $[ v ^ { ( j ) } , v ^ { ( j - 1 ) } , \cdot \cdot \cdot , v ^ { ( 0 ) } ]$ of length $j$ from node $v _ { a }$ to node $v _ { b }$ , where $\boldsymbol { v } ^ { ( j ) } = \boldsymbol { v } _ { a }$ , $v ^ { ( 0 ) } = v _ { b }$ , $v ^ { ( i - 1 ) } \in \mathcal { N } ( v ^ { ( i ) } ) .$ for $i = j , \cdots , 1$ , and all nodes along the path are unlabeled except $v ^ { ( 0 ) }$ . Then we have
+$$
+I _ { l } ( v _ { a } , v _ { b } ; k ) = \sum _ { j = 1 } ^ { k } \sum _ { \mathcal { U } _ { j } ^ { a  b } } \prod _ { i = j } ^ { 1 } \tilde { a } _ { v ^ { ( i - 1 ) } , v ^ { ( i ) } } ,
+$$
+where $\tilde { a } _ { v ^ { ( i - 1 ) } , v ^ { ( i ) } }$ is the normalized weight of edge $( v ^ { ( i ) } , v ^ { ( i - 1 ) } )$ .
+To intuitively understand this lemma, note that there are two differences between Lemma 1 and Lemma 2: (1) In Lemma 1, $\tilde { I } _ { f } ( v _ { a } , v _ { b } ; k )$ sums over all paths from $v _ { a }$ to $v _ { b }$ of length $k$ , but in Lemma 2, $I _ { l } ( v _ { a } , v _ { b } ; k )$ sums over all paths from $v _ { a }$ to $v _ { b }$ of length no more than $k$ . The is because in LPA, $v _ { b }$ ’s label is reset to its initial value after each iteration, which means that the label of $v _ { b }$ serves as a constant signal that begins propagating in the graph again and again after each iteration. (2) In Lemma 1 we consider all possible paths from $v _ { a }$ to $v _ { b }$ , but in Lemma 2, the paths are restricted to contain unlabeled nodes only. The reason here is the same as above: Since the labels of labeled nodes are reset to their initial values after each iteration in LPA, the influence of $v _ { b }$ ’s label will be absorbed in labeled nodes, and the propagation of $v _ { b }$ ’s label will be cut off at these nodes. Therefore, $v _ { b }$ ’s label can only flow to $v _ { a }$ along the paths with unlabeled nodes only. See Figure 7 for an illustrating example showing the label propagation in LPA.
+Proof. As mentioned above, a significant difference between LPA and GCN is that all labeled $y _ { b }$ des are of node $v _ { b }$ et to its original labappears not only as $y _ { b } ^ { ( 0 ) }$ fter each iteration, but also as every $y _ { b } ^ { ( j ) }$ PA.for $j = 1 , \cdots , k - 1$ the initial label. Therefore, the influence of $y _ { b }$ on $y _ { a } ^ { ( k ) }$ is the cumulative influence of $y _ { b } ^ { ( j ) }$ on $y _ { a } ^ { ( k ) }$ for $j = 0 , 1 , \cdots , k - 1$ :
+$$
+I _ { l } ( v _ { a } , v _ { b } ; k ) = \frac { \partial y _ { a } ^ { ( k ) } } { \partial y _ { b } } = \sum _ { j = 0 } ^ { k - 1 } \frac { \partial y _ { a } ^ { ( k ) } } { \partial y _ { b } ^ { ( j ) } } .
+$$
+According to the updating rule of LPA, we have
+$$
+\frac { \partial y _ { a } ^ { ( k ) } } { \partial y _ { b } ^ { ( j ) } } = \frac { \partial \sum _ { v _ { z } \in \mathcal { N } ( v _ { a } ) } \tilde { a } _ { a z } y _ { z } ^ { ( k - 1 ) } } { \partial y _ { b } ^ { ( j ) } } = \sum _ { v _ { z } \in \mathcal { N } ( v _ { a } ) } \tilde { a } _ { a z } \frac { \partial y _ { z } ^ { ( k - 1 ) } } { \partial y _ { b } ^ { ( j ) } } .
+$$
+![](images/a8be6adfe9b29716610210ac6cd406194bbbff6b169ed3ea15aab2b7784c6266.jpg)
+Figure 7: An illustrating example of label propagation in LPA. Suppose labels are propagated for three iterations, and no self-loop exists. Blue nodes are labeled while white nodes are unlabeled. (a) $v _ { a }$ ’s label propagates to $v _ { 1 }$ (yellow arrows). Note that the propagation of $v _ { a }$ ’s label to $v _ { 3 }$ is cut off since $v _ { 3 }$ is labeled thus absorbing $v _ { a }$ ’s label. (b) $v _ { a }$ ’s label that propagated to $v _ { 1 }$ further propagates to $v _ { 2 }$ and $v _ { b }$ (yellow arrows). Meanwhile, $v _ { a }$ ’s label is reset to its initial value then propagates from $v _ { a }$ again (green arrows). (c) Label propagation in iteration 3. Purple arrows denote the propagation of $v _ { a }$ ’s label starting from $v _ { a }$ for the third time. (d) All possible paths of length no more than three from $v _ { a }$ to $v _ { b }$ containing unlabeled nodes only. Note that there is no path of length one from $v _ { a }$ to $v _ { b }$ .
+In the above equation, the derivative ∂y(k)a $\frac { \partial y _ { a } ^ { ( k ) } } { \partial y _ { b } ^ { ( j ) } }$ is decomposed into the weighted average of ∂y(k���1)z ∂ y ( j )b , where $v _ { z }$ traverses all neighbors of $v _ { a }$ . For those $v _ { z }$ ’s that are initially labeled, $y _ { z } ^ { ( k - 1 ) }$ is reset to their initial labels in each iteration. Therefore, they are always constant and independent of $y _ { b } ^ { ( j ) }$ , meaning that their derivatives w.r.t. $y _ { b } ^ { ( j ) }$ are zero. So we only need to consider the terms where $v _ { z }$ is
+$$
+\frac { \partial y _ { a } ^ { ( k ) } } { \partial y _ { b } ^ { ( j ) } } = \sum _ { v _ { z } \in \mathcal { N } \left( v _ { a } \right) , z > m } \tilde { a } _ { a z } \frac { \partial y _ { z } ^ { ( k - 1 ) } } { \partial y _ { b } ^ { ( j ) } } ,
+$$
+where $z > m$ means $v _ { z }$ is unlabeled. To intuitively understand Eq. (14), one can imagine that we perform a random walk starting from node $v _ { a }$ for one step, where the “transition probability” is the edge weights $\tilde { a }$ , and all nodes in this random walk are restricted to unlabeled nodes only. Note that we can further decompose every $y _ { z } ^ { ( k - 1 ) }$ in Eq. (14) in the way similar to what we do for $y _ { a } ^ { ( k ) }$ in Eq. (13). So the expansion in Eq. (14) can be performed iteratively until the index $k$ decreases to $j$ . This is equivalent to performing all possible random walks for $k - j$ steps starting from $v _ { a }$ , where all nodes but the last in the random walk are restricted to be unlabeled nodes:
+$$
+\frac { \partial y _ { a } ^ { ( k ) } } { \partial y _ { b } ^ { ( j ) } } = \sum _ { v _ { z } \in \mathcal { V } } \sum _ { \mathcal { U } _ { k - j } ^ { a \to z } } \left( \prod _ { i = k - j } ^ { 1 } \tilde { a } _ { v ^ { ( i - 1 ) } , v ^ { ( i ) } } \right) \frac { \partial y _ { z } ^ { ( j ) } } { \partial y _ { b } ^ { ( j ) } } ,
+$$
+where $v _ { z }$ in the first summation term is the end node of a random walk, $\mathcal { U } _ { k - j } ^ { a  z }$ in the second summation term is an unlabeled-nodes-only path from $v _ { a }$ to $v _ { z }$ of length $k - j$ , and the product term is the probability of a given path $\mathcal { U } _ { k - j } ^ { a  z }$ . Consider the last term ∂ y(j)b in Eq. (15). We know that $\begin{array} { r } { \frac { \partial y _ { z } ^ { ( j ) } } { \partial y _ { b } ^ { ( j ) } } = 0 } \end{array}$ for all $z \neq b$ and $\begin{array} { r } { \frac { \partial y _ { z } ^ { ( j ) } } { \partial y _ { b } ^ { ( j ) } } = 1 } \end{array}$ for $z = b$ , which means that only those random-walk paths that end exactly at $v _ { b }$ (i.e., the end node $v _ { z }$ is exactly $v _ { b }$ ) count for the computation in Eq. (15). Therefore, we have
+$$
+{ \frac { \partial y _ { a } ^ { ( k ) } } { \partial y _ { b } ^ { ( j ) } } } = \sum _ { \mathcal { U } _ { k - j } ^ { a  b } } \prod _ { i = k - j } ^ { 1 } \tilde { a } _ { v ^ { ( i - 1 ) } , v ^ { ( i ) } } ,
+$$
+where $\mathcal { U } _ { k - j } ^ { a  b }$ is a path from $v _ { a }$ to $v _ { b }$ of length $k - j$ containing only unlabeled nodes except $v _ { b }$ Substituting the right hand term of Eq. (12) with Eq. (16), we obtain that
+$$
+I _ { l } ( v _ { a } , v _ { b } ; k ) = \sum _ { j = 0 } ^ { k - 1 } \sum _ { \mathcal { U } _ { k - j } ^ { a  b } } \prod _ { i = k - j } ^ { 1 } \tilde { a } _ { v ^ { ( i - 1 ) } , v ^ { ( i ) } } = \sum _ { j = 1 } ^ { k } \sum _ { \mathcal { U } _ { j } ^ { a  b } } \prod _ { i = j } ^ { 1 } \tilde { a } _ { v ^ { ( i - 1 ) } , v ^ { ( i ) } } .
+$$
+Now Theorem 1 can be proved by combining Lemma 1 and Lemma 2:
+Proof. Suppose that whether a node is labeled or not is independent of each other for the given graph. Then we have
+$$
+\begin{array} { r l } & { \mathbb { E } [ \boldsymbol { I } _ { l } ( v _ { a } , v _ { b } ; k ) ] = \mathbb { E } [ \displaystyle \sum _ { j = 1 } ^ { k } \sum _ { U _ { j } ^ { a - b } } \prod _ { i = j } ^ { 1 } \tilde { a } _ { v ^ { ( i - 1 ) } , v ^ { ( i ) } } ] = \displaystyle \sum _ { j = 1 } ^ { k } \mathbb { E } [ \displaystyle \sum _ { U _ { j } ^ { a - b } } \prod _ { i = j } ^ { 1 } \tilde { a } _ { v ^ { ( i - 1 ) } , v ^ { ( i ) } } ] } \\ & { \qquad = \displaystyle \sum _ { j = 1 } ^ { k } \sum _ { \mathcal { P } _ { j } ^ { a - b } } \operatorname* { P r } ( \mathcal { P } _ { j } ^ { a  b } \mathrm { \ i s ~ a n ~ u n l a b e l e d - n o d e s - o n l y ~ p a t h } ) \prod _ { i = j } ^ { 1 } \tilde { a } _ { v ^ { ( i - 1 ) } , v ^ { ( i ) } } } \\ & { \qquad = \displaystyle \sum _ { j = 1 } ^ { k } \sum _ { \mathcal { P } _ { j } ^ { a - b } } \beta ^ { j } \prod _ { i = j } ^ { 1 } \tilde { a } _ { v ^ { ( i - 1 ) } , v ^ { ( i ) } } = \displaystyle \sum _ { j = 1 } ^ { k } \beta ^ { j } \tilde { I } _ { f } ( v _ { a } , v _ { b } ; j ) . } \end{array}
+$$
+# B PROOF OF THEOREM 2
+Proof. Denote the set of labels as $\mathcal { L }$ . Since different label dimensions in $y _ { a } ^ { ( \cdot ) }$ do not interact with each other when running LPA, the value of the $y _ { a }$ -th dimension in $y _ { a } ^ { ( \cdot ) }$ (denoted by $y _ { a } ^ { ( \cdot ) } [ y _ { a } ] \rangle$ ) comes only from the nodes with initial label $y _ { a }$ . It is clear that
+$$
+y _ { a } ^ { ( k ) } [ y _ { a } ] = \sum _ { v _ { b } : y _ { b } = y _ { a } } \sum _ { j = 1 } ^ { k } \sum _ { \mathcal { U } _ { j } ^ { a  b } } \prod _ { i = j } ^ { 1 } \tilde { a } _ { v ^ { ( i - 1 ) } , v ^ { ( i ) } } ,
+$$
+which equals $\begin{array} { r } { \sum _ { v { b } : y _ { b } = y _ { a } } I _ { l } ( v _ { a } , v _ { b } ; k ) } \end{array}$ according to Lemma 2. Therefore, we have
+$$
+\mathrm { P r } ( \hat { y } _ { a } = y _ { a } ) = \frac { y _ { a } ^ { ( k ) } [ y _ { a } ] } { \sum _ { i \in \mathcal { L } } y _ { a } ^ { ( k ) } [ i ] } \propto y _ { a } ^ { ( k ) } [ y _ { a } ] = \sum _ { v _ { b } : y _ { b } = y _ { a } } I _ { l } ( v _ { a } , v _ { b } ; k )
+$$
+# C PROOF OF THEOREM 3
+In this proof we assume that the dimension of node representations is one, but note that the conclusion can be easily generalized to the case of multi-dimensional representations since the function $D ( \mathbf { x } )$ can be decomposed into the sum of one-dimensional cases. In the following of this proof, we still use bold notations $\mathbf { x } _ { i } ^ { ( k ) }$ ) and h(k)i t o denote node representations, but keep in mind that they are scalars rather than vectors.
+We give two lemmas before proving Theorem 3. The first one is about the gradient of $D ( \mathbf { x } )$
+Lemma 3 $\begin{array} { r } { \mathbf { h } _ { i } ^ { ( k ) } = \mathbf { x } _ { i } ^ { ( k ) } - \frac { \partial D ( \mathbf { x } ^ { ( k ) } ) } { \partial \mathbf { x } _ { i } ^ { ( k ) } } } \end{array}$
+$$
+\begin{array} { r } { \mathbf { x } _ { i } ^ { ( k ) } - \frac { \partial D ( \mathbf { x } ^ { ( k ) } ) } { \partial \mathbf { x } _ { i } ^ { ( k ) } } = \mathbf { x } _ { i } ^ { ( k ) } - \sum _ { v _ { j } \in N ( v _ { i } ) } \widetilde { a } _ { i j } \big ( \mathbf { x } _ { i } ^ { ( k ) } - \mathbf { x } _ { j } ^ { ( k ) } \big ) = \sum _ { v _ { j } \in N ( v _ { i } ) } \widetilde { a } _ { i j } \mathbf { x } _ { j } ^ { ( k ) } = \mathbf { h } _ { i } ^ { ( k ) } . } \end{array}
+$$
+It is interesting to see from Lemma 3 that the aggregation step in GCN is equivalent to running gradient descent for one step with a step size of one. However, this is not able to guarantee that $\mathbf { \bar { \Gamma } } D ( \mathbf { h } ^ { ( k ) } ) \leq D ( \mathbf { x } ^ { ( k ) } )$ because the step size may be too large to reduce the value of $D$ .
+The second lemma is about the Hessian of $D ( \mathbf { x } )$ :
+Lemma 4 $\nabla ^ { 2 } D ( \mathbf { x } ) \preceq 2 I _ { ! }$ , or equivalently, $2 I - \nabla ^ { 2 } D ( \mathbf { x } )$ is a positive semidefinite matrix.
+Proof. We first calculate the Hessian of $\begin{array} { r } { D ( \mathbf { x } ) = \frac { 1 } { 2 } \sum _ { v _ { i } , v _ { j } } \widetilde { a } _ { i j } \| \mathbf { x } _ { i } - \mathbf { x } _ { j } \| _ { 2 } ^ { 2 } } \end{array}$
+$$
+\nabla ^ { 2 } D ( { \bf x } ) = \left[ \begin{array} { c c c c } { 1 - \tilde { a } _ { 1 1 } } & { - \tilde { a } _ { 1 2 } } & { \cdots } & { - \tilde { a } _ { 1 n } } \\ { - \tilde { a } _ { 2 1 } } & { 1 - \tilde { a } _ { 2 2 } } & { \cdots } & { - \tilde { a } _ { 2 n } } \\ { \vdots } & { \vdots } & { \ddots } & { \vdots } \\ { - \tilde { a } _ { n 1 } } & { - \tilde { a } _ { n 2 } } & { \cdots } & { 1 - \tilde { a } _ { n n } } \end{array} \right] = I - D ^ { - 1 } A .
+$$
+Therefore, $2 I - \nabla ^ { 2 } D ( \mathbf { x } ) = I + D ^ { - 1 } A$ . Since $D ^ { - 1 } A$ is Markov matrix (i.e., each entry is nonnegative and the sum of each row is one), its eigenvalues are within the range [-1, 1], so the eigenvalues of $I + D ^ { - 1 } A$ are within the range [0, 2]. Therefore, $I + D ^ { - 1 } A$ is a positive semidefinite matrix, and we have $\nabla ^ { 2 } D ( \mathbf { x } ) \preceq 2 I$ .
+We can now prove Theorem 3:
+Proof. Since $D$ is a quadratic function, we perform a second-order Taylor expansion of $D$ around $\mathbf { x } ^ { ( k ) }$ and obtain the following inequality:
+$$
+\begin{array} { r l } & { D ( \mathbf { h } ^ { ( k ) } ) = D ( \mathbf { x } ^ { ( k ) } ) + \nabla D ( \mathbf { x } ^ { ( k ) } ) ^ { \top } ( \mathbf { h } ^ { ( k ) } - \mathbf { x } ^ { ( k ) } ) + \displaystyle \frac { 1 } { 2 } ( \mathbf { h } ^ { ( k ) } - \mathbf { x } ^ { ( k ) } ) ^ { \top } \nabla ^ { 2 } D ( \mathbf { x } ) ( \mathbf { h } ^ { ( k ) } - \mathbf { x } ^ { ( k ) } ) } \\ & { \qquad = D ( \mathbf { x } ^ { ( k ) } ) - \nabla D ( \mathbf { x } ^ { ( k ) } ) ^ { \top } \nabla D ( \mathbf { x } ^ { ( k ) } ) + \displaystyle \frac { 1 } { 2 } \nabla D ( \mathbf { x } ^ { ( k ) } ) ^ { \top } \nabla ^ { 2 } D ( \mathbf { x } ) \nabla D ( \mathbf { x } ^ { ( k ) } ) } \\ & { \qquad \leq D ( \mathbf { x } ^ { ( k ) } ) - \nabla D ( \mathbf { x } ^ { ( k ) } ) ^ { \top } \nabla D ( \mathbf { x } ^ { ( k ) } ) + \nabla D ( \mathbf { x } ^ { ( k ) } ) ^ { \top } \nabla D ( \mathbf { x } ^ { ( k ) } ) } \\ & { \qquad = D ( \mathbf { x } ^ { ( k ) } ) . } \end{array}
+$$
+# D MORE VISUALIZATION RESULTS ON KARATE CLUB NETWORK
+Figure 8 illustrates more visualization of GCN and GCN-LPA on karate club network. In each subfigure, we vary the number of layers from 1 to 4 to examine how the learned representations evolve. The initial node features are one-hot identity vectors, and the dimension of hidden layers and output layer is 2. The transformation matrices are uniformly initialized within range [-1, 1]. We use sigmoid function as the nonlinear activation function. Comparing the four figures in each row, we conclude that the aggregation step and transformation step in GCN and GCN-LPA do benefit the separation of different classes. Comparing Figure 8a and 8c (or Figure 8b and 8d), we conclude that more inter-class edges will make the separation harder for GCN (or GCN-LPA). Comparing Figure 8a and 8b (or Figure 8c and 8d), we conclude that GCN-LPA is more noise-resistant than GCN, therefore, GCN-LPA can better differentiate classes and identify clustering substructures.
+# E DATASETS DETAILS
+The statistics of all datasets are shown in Table 3.
+Table 3: Statistics for all datasets.
+<table><tr><td></td><td>Cora</td><td>Citeseer</td><td>Pubmed</td><td>Coauthor-CS</td><td>Coauthor-Phy</td></tr><tr><td>#nodes</td><td>2,708</td><td>3,327</td><td>19,717</td><td>18,333</td><td>34,493</td></tr><tr><td># edges</td><td>5,278</td><td>4,552</td><td>44,324</td><td>81,894</td><td>247,962</td></tr><tr><td># features</td><td>1,433</td><td>3,703</td><td>500</td><td>6.805</td><td>8,415</td></tr><tr><td>#classes</td><td>7</td><td>6</td><td>3</td><td>15</td><td>5</td></tr><tr><td>Intra-class edge rate</td><td>81.0%</td><td>73.6%</td><td>80.2%</td><td>80.8%</td><td>93.1%</td></tr><tr><td>Labeled node rate</td><td>5.2%</td><td>3.6%</td><td>0.3%</td><td>1.6%</td><td>0.3%</td></tr></table>
+# F HYPER-PARAMETER SETTINGS
+The detailed hyper-parameter settings for all datasets are listed in Table 4. In GCN-LPA, we use the same dimension for all hidden layers. Note that the number of GCN layers and the number of LPA iterations can actually be different since GCN and LPA are implemented as two independent modules. We use grid search to determine hyper-parameters on Cora, and perform fine-tuning on other datasets, i.e., varying one hyper-parameter per time to see if the performance can be further improved. The search spaces for hyper-parameters are as follows:
+![](images/9a2e196e94e5bcbff2b2721b9a616cc0e0339bd5fb0c29307d9645d266cde7e0.jpg)
+Figure 8: Visualization of GCN and GCN-LPA with $1 \sim 4$ layers on karate club network.
+Table 4: Hyper-parameter settings for all datasets.
+<table><tr><td></td><td>Cora</td><td>Citeseer</td><td>Pubmed</td><td>Coauthor-CS</td><td>Coauthor-Phy</td></tr><tr><td>Dimension of hidden layers</td><td>32</td><td>16</td><td>32</td><td>32</td><td>32</td></tr><tr><td># GCN layers</td><td>5</td><td>2</td><td>2</td><td>2</td><td>2</td></tr><tr><td>#LPA iterations</td><td>5</td><td>5</td><td>1</td><td>2</td><td>3</td></tr><tr><td>L2 weight</td><td>1×10 -4</td><td>5×10-4</td><td>2 ×10-4</td><td>1×10-4</td><td>1×10-4</td></tr><tr><td>LPA weight (入)</td><td>10</td><td>1</td><td>1</td><td>2</td><td>1</td></tr><tr><td>Dropout rate</td><td>0.2</td><td>0</td><td>0</td><td>0.2</td><td>0.2</td></tr><tr><td>Learning rate</td><td>0.05</td><td>0.2</td><td>0.1</td><td>0.1</td><td>0.05</td></tr></table>
+• Dimension of hidden layers: $\{ 8 , 1 6 , 3 2 \}$ ;
+• # GCN layers: $\{ 1 , 2 , 3 , 4 , 5 , 6 \}$ ;
+• # LPA iterations: $\{ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 \}$ ;
+• L2 weight: $\{ 1 0 ^ { - 7 } , 2 \times 1 0 ^ { - 7 } , 5 \times 1 0 ^ { - 7 } , 1 0 ^ { - 6 } , 2 \times 1 0 ^ { - 6 } , 5 \times 1 0 ^ { - 6 } , 1 0 ^ { - 5 } , 2 \times 1 0 ^ { - 5 } , 5 \times 1 0 ^ { - 6 } , 1 \}$ $1 0 ^ { - 5 } , 1 0 ^ { - 4 } , 2 \times 1 0 ^ { - 4 } , 5 \times 1 0 ^ { - 4 } , 1 0 ^ { - 3 } \}$ ;
+• LPA weight $( \lambda )$ : $\{ 0 , 1 , 2 , 5 , 1 0 , 1 5 , 2 0 \}$ ; • Dropout rate: $\{ 0 , 0 . 1 , 0 . 2 , 0 . 3 , 0 . 4 , 0 . 5 \}$ ;
+• Learning rate: $\{ 0 . 0 1 , 0 . 0 2 , 0 . 0 5 , 0 . 1 , 0 . 2 , 0 . 5 \}$ .